Streaming LLM Responses

• Use client.messages.stream to receive tokens live.
• Print text as it arrives (the typing effect).
• Understand why streaming improves perceived speed.
• Collect the full text + stop reason after streaming.

non-streaming:  ...... (10s of blank screen) ...... full answer appears
streaming:      answer appears word-by-word as it's generated

Same total time, completely different feel. Streaming lets the user start reading immediately and signals "I'm working". Every good chat UI streams.

The streaming context manager

import anthropic
client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-haiku-4-5",
    max_tokens=500,
    messages=[{"role": "user", "content": "Write a short poem about the sea."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)   # print each chunk, no newline
print()   # final newline

stream.text_stream yields text chunks as they arrive. end="", flush=True makes them appear immediately instead of buffering.

Get the full message afterwards

with client.messages.stream(...) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final = stream.get_final_message()   # full text, usage, stop_reason
print("\ntokens:", final.usage.output_tokens)

Build the string while streaming

chunks = []
with client.messages.stream(...) as stream:
    for text in stream.text_stream:
        chunks.append(text)
        print(text, end="", flush=True)
full_reply = "".join(chunks)

Lower-level events (optional)

For fine control (tool-use deltas, etc.) you can iterate stream directly and inspect event types. For most apps, text_stream is all you need.

# stream_chat.py — a multi-turn streaming chat in the terminal
import anthropic
client = anthropic.Anthropic()

SYSTEM = "You are a concise, friendly assistant. Keep replies under 80 words."
history = []   # remembers the conversation

print("Chat (type 'quit' to exit)\n")
while True:
    user = input("You: ").strip()
    if user.lower() in ("quit", "exit"):
        break

    history.append({"role": "user", "content": user})

    print("AI: ", end="", flush=True)
    chunks = []
    with client.messages.stream(
        model="claude-haiku-4-5", max_tokens=400,
        system=SYSTEM, messages=history,
    ) as stream:
        for text in stream.text_stream:
            print(text, end="", flush=True)
            chunks.append(text)
    print("\n")

    history.append({"role": "assistant", "content": "".join(chunks)})

Sample session

You: what's a fun fact about octopuses?
AI: Octopuses have three hearts and blue blood! Two hearts pump blood to the
gills, and the third pumps it to the body. Even cooler — the body heart stops
beating when they swim, which is why they often prefer to crawl. 🐙

You: do they sleep?
AI: Yes! And they may even dream — their skin flickers with colour while...

Read the diff

Two things make this a real chat: streaming (replies type out live) and history (we append both sides, so the model remembers context — "they" in the second question resolves to octopuses). Append the user message before the call and the assistant's full reply after. That's the entire conversational loop.

Streaming hands you tokens as they're generated via client.messages.stream + stream.text_stream. Print with end="", flush=True for the live typing effect, and collect chunks to keep the full reply. Maintain a history list (append user then assistant) for memory, and cap it to control cost. Next: put this in a Flask web app.