LangBot Day 7: Streaming Output — Token-by-Token Responses

# Before (Day 6): wait for everything
response = chain.invoke({"input": "Hello"})
print(response)                        # all at once

# After (Day 7): get chunks as they arrive
for chunk in chain.stream({"input": "Hello"}):
    print(chunk, end="", flush=True)   # one piece at a time

# Chain: prompt | llm | StrOutputParser()
# Chunk type: str
for chunk in chain.stream(...):
    # chunk = "The" then " best" then " way" then " to" then " learn" ...

# Chain: prompt | llm   (no output parser)
# Chunk type: AIMessageChunk
for chunk in chain.stream(...):
    # chunk.content = "The" then " best" then " way" ...
    # You access .content manually each iteration

# Chain: prompt | structured_llm   (with_structured_output)
# Chunk type: partial JSON strings or incremental model objects
# (Provider-dependent. OpenAI streams JSON fragments; LangChain
#  tries to assemble them into complete objects but the behavior
#  varies. More on this below.)

stream_chain = prompt | llm | StrOutputParser()

# 🆕 Day 7: Streaming chain — prompt → LLM → StrOutputParser → streaming str chunks
stream_chain = prompt | llm | StrOutputParser()

# Day 6: invoke — wait for everything
response = chat_chain.invoke({"input": user_input, "history": messages})

print(f"\nLangBot [{response.mood.value} | {response.confidence:.0%} confidence]:")
print(f"  {response.message}")

reply_text = response.message

# 🆕 Day 7: stream — print tokens as they arrive
print(f"\nLangBot: ", end="", flush=True)
full_response = ""
for chunk in stream_chain.stream({"input": user_input, "history": messages}):
    print(chunk, end="", flush=True)
    full_response += chunk
print()  # final newline after streaming finishes

reply_text = full_response

# Optional: get structured metadata after streaming
meta = chat_chain.invoke({"input": user_input, "history": messages})
print(f"  [{meta.mood.value} | {meta.confidence:.0%} confidence]")

# langbot.py — Day 7: Streaming output
from dotenv import load_dotenv
from pydantic import BaseModel, Field
from enum import Enum
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser, CommaSeparatedListOutputParser

load_dotenv()


# ── Day 5: Mood enum ───────────────────────────────────────────────
class Mood(str, Enum):
    """Emotional tones LangBot can express."""
    CHEERFUL = "cheerful"
    SARCASTIC = "sarcastic"
    THOUGHTFUL = "thoughtful"
    APOLOGETIC = "apologetic"


# ── Day 5: Response model ──────────────────────────────────────────
class LangBotResponse(BaseModel):
    """Every LangBot reply is a typed object, not raw text."""
    message: str = Field(description="LangBot's actual reply to the user")
    mood: Mood = Field(description="The emotional tone LangBot chose for this response")
    confidence: float = Field(
        description="How sure LangBot is about this response. 0.0 = total guess, 1.0 = absolutely certain.",
        ge=0.0,
        le=1.0,
    )


# Day 6: Keywords that signal the user wants a list, not a chat
LIST_KEYWORDS = {"list", "suggest", "recommend", "top", "options", "ideas", "rank"}


def wants_list(user_input: str) -> bool:
    """Return True if the user is asking for a list or suggestions."""
    words = set(user_input.lower().split())
    return bool(words & LIST_KEYWORDS)


def main():
    llm = ChatOpenAI(model="gpt-4.1-mini", temperature=0.7)

    # Day 3 + Day 5: Personality with mood guidance
    SYSTEM_PROMPT = """You are LangBot, a witty and slightly sarcastic AI assistant.
You love bad puns, you use emojis sparingly, and you always keep responses
under three sentences. If you don't know something, you admit it with style.

Choose your mood for each response:
- cheerful: when the conversation is light, the user is happy, or you're making a joke
- sarcastic: when you're being playfully snarky or the user said something ridiculous
- thoughtful: when the question is deep, technical, or deserves a careful answer
- apologetic: when you realize you got something wrong or don't know the answer

Set confidence based on how sure you are. Factual answers = high confidence.
Opinions and jokes = moderate confidence. Guesses = low confidence."""

    # Day 3: Chat prompt template
    prompt = ChatPromptTemplate.from_messages([
        ("system", SYSTEM_PROMPT),
        MessagesPlaceholder(variable_name="history"),
        ("human", "{input}"),
    ])

    # Day 5: Structured output chain — returns LangBotResponse objects
    structured_llm = llm.with_structured_output(LangBotResponse)
    chat_chain = prompt | structured_llm

    # Day 6: Build the list-mode output parser
    list_parser = CommaSeparatedListOutputParser()

    # Day 6: List-specific prompt — injects format instructions for the model
    LIST_SYSTEM_PROMPT = SYSTEM_PROMPT + "\n\n" + list_parser.get_format_instructions()

    list_prompt = ChatPromptTemplate.from_messages([
        ("system", LIST_SYSTEM_PROMPT),
        MessagesPlaceholder(variable_name="history"),
        ("human", "{input}"),
    ])

    # Day 6: List chain — prompt → raw LLM → comma-split parser → list[str]
    list_chain = list_prompt | llm | list_parser

    # 🆕 Day 7: Streaming chain — prompt → LLM → StrOutputParser → str chunks
    #           Replace the Day 6 string_chain with an explicitly named streaming
    #           chain. Same composition, new role: the chain we stream.
    stream_chain = prompt | llm | StrOutputParser()

    # Day 2: Conversation history
    messages = []

    print("🤖 LangBot (type 'quit' to exit)")
    print("─" * 40)
    print("  Try: 'list 5 programming books' or 'suggest weekend activities'")
    print("  Now streaming — watch LangBot type! ⚡")
    print("─" * 40)

    while True:
        user_input = input("\nYou: ").strip()

        if user_input.lower() in ("quit", "exit", "q"):
            print("👋 Goodbye!")
            break

        if not user_input:
            continue

        # Day 6: Route to the right chain based on intent
        if wants_list(user_input):
            # List mode — invoke for a complete list (streaming makes no sense here)
            items = list_chain.invoke({"input": user_input, "history": messages})

            print(f"\nLangBot's suggestions ({len(items)} items):")
            for i, item in enumerate(items, 1):
                print(f"  {i}. {item}")

            # Reconstruct a text reply for history
            reply_text = f"Here are some suggestions: {', '.join(items)}"
        else:
            # 🆕 Day 7: Chat mode — stream the response token by token
            print(f"\nLangBot: ", end="", flush=True)
            full_response = ""
            for chunk in stream_chain.stream({"input": user_input, "history": messages}):
                print(chunk, end="", flush=True)
                full_response += chunk
            print()  # final newline after streaming finishes

            # 🆕 Day 7: reply_text is the accumulated full response
            reply_text = full_response

            # Optional: uncomment the next three lines to also get mood/confidence
            # meta = chat_chain.invoke({"input": user_input, "history": messages})
            # print(f"  [{meta.mood.value} | {meta.confidence:.0%} confidence]")
            # reply_text = meta.message   # use the structured version for history

        # Day 2: Store the exchange in history
        messages.append(HumanMessage(content=user_input))
        messages.append(AIMessage(content=reply_text))


if __name__ == "__main__":
    main()

python langbot.py

🤖 LangBot (type 'quit' to exit)
────────────────────────────────────────
  Try: 'list 5 programming books' or 'suggest weekend activities'
  Now streaming — watch LangBot type! ⚡
────────────────────────────────────────

You: What is the difference between .stream() and .invoke()?

LangBot: .invoke() waits for the entire response to finish — like ordering a pizza and
staring at the door until it arrives. .stream() is the tracker app that shows "your pizza
is being made... now it's in the oven... now it's on the way." Same pizza, less anxiety. 🍕

You: Explain quantum computing in one sentence

LangBot: Quantum computing uses qubits that can be both 0 and 1 simultaneously thanks to
superposition — which is either incredibly powerful or a great excuse when your code doesn't
work, depending on how you measure it. ⚛️

You: list 3 programming languages for beginners

LangBot's suggestions (3 items):
  1. Python
  2. JavaScript
  3. Scratch

You: quit

👋 Goodbye!

import asyncio
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

async def stream_chat(user_input: str):
    llm = ChatOpenAI(model="gpt-4.1-mini", temperature=0.7)
    prompt = ChatPromptTemplate.from_template("You are a helpful assistant.\n\n{input}")
    chain = prompt | llm | StrOutputParser()

    full_response = ""
    async for chunk in chain.astream({"input": user_input}):
        print(chunk, end="", flush=True)
        full_response += chunk
    print()
    return full_response

# Run it
asyncio.run(stream_chat("Explain async/await in one sentence"))

# Wrong — output is buffered and may not appear until the loop finishes
for chunk in chain.stream(...):
    print(chunk, end="")   # no flush

# Wrong — each token on its own line
for chunk in chain.stream(...):
    print(chunk)   # default end="\n"

# Wrong — storing the iterator or individual chunks
for chunk in chain.stream(...):
    messages.append(AIMessage(content=chunk))   # one message per token!

# Wrong — streaming a CommaSeparatedListOutputParser
for chunk in list_chain.stream({"input": "list 5 movies"}):
    print(chunk, end="", flush=True)
# Output: "TheGodfather, PulpFiction, TheDarkKnight, ..." — unreadable

# Wrong — "LangBot:" and then tokens start on the next line
print("LangBot:")          # ends with \n
for chunk in chain.stream(...):
    print(chunk, end="", flush=True)

# langbot.py — Day 7: Streaming output
from dotenv import load_dotenv
from pydantic import BaseModel, Field
from enum import Enum
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser, CommaSeparatedListOutputParser

load_dotenv()


# ── Day 5: Mood enum ───────────────────────────────────────────────
class Mood(str, Enum):
    """Emotional tones LangBot can express."""
    CHEERFUL = "cheerful"
    SARCASTIC = "sarcastic"
    THOUGHTFUL = "thoughtful"
    APOLOGETIC = "apologetic"


# ── Day 5: Response model ──────────────────────────────────────────
class LangBotResponse(BaseModel):
    """Every LangBot reply is a typed object, not raw text."""
    message: str = Field(description="LangBot's actual reply to the user")
    mood: Mood = Field(description="The emotional tone LangBot chose for this response")
    confidence: float = Field(
        description="How sure LangBot is about this response. 0.0 = total guess, 1.0 = absolutely certain.",
        ge=0.0,
        le=1.0,
    )


# Day 6: Keywords that signal the user wants a list, not a chat
LIST_KEYWORDS = {"list", "suggest", "recommend", "top", "options", "ideas", "rank"}


def wants_list(user_input: str) -> bool:
    """Return True if the user is asking for a list or suggestions."""
    words = set(user_input.lower().split())
    return bool(words & LIST_KEYWORDS)


def main():
    llm = ChatOpenAI(model="gpt-4.1-mini", temperature=0.7)

    # Day 3 + Day 5: Personality with mood guidance
    SYSTEM_PROMPT = """You are LangBot, a witty and slightly sarcastic AI assistant.
You love bad puns, you use emojis sparingly, and you always keep responses
under three sentences. If you don't know something, you admit it with style.

Choose your mood for each response:
- cheerful: when the conversation is light, the user is happy, or you're making a joke
- sarcastic: when you're being playfully snarky or the user said something ridiculous
- thoughtful: when the question is deep, technical, or deserves a careful answer
- apologetic: when you realize you got something wrong or don't know the answer

Set confidence based on how sure you are. Factual answers = high confidence.
Opinions and jokes = moderate confidence. Guesses = low confidence."""

    # Day 3: Chat prompt template
    prompt = ChatPromptTemplate.from_messages([
        ("system", SYSTEM_PROMPT),
        MessagesPlaceholder(variable_name="history"),
        ("human", "{input}"),
    ])

    # Day 5: Structured output chain — returns LangBotResponse objects
    structured_llm = llm.with_structured_output(LangBotResponse)
    chat_chain = prompt | structured_llm

    # Day 6: Build the list-mode output parser
    list_parser = CommaSeparatedListOutputParser()

    # Day 6: List-specific prompt — injects format instructions for the model
    LIST_SYSTEM_PROMPT = SYSTEM_PROMPT + "\n\n" + list_parser.get_format_instructions()

    list_prompt = ChatPromptTemplate.from_messages([
        ("system", LIST_SYSTEM_PROMPT),
        MessagesPlaceholder(variable_name="history"),
        ("human", "{input}"),
    ])

    # Day 6: List chain — prompt → raw LLM → comma-split parser → list[str]
    list_chain = list_prompt | llm | list_parser

    # 🆕 Day 7: Streaming chain — prompt → LLM → StrOutputParser → str chunks
    stream_chain = prompt | llm | StrOutputParser()

    # Day 2: Conversation history
    messages = []

    print("🤖 LangBot (type 'quit' to exit)")
    print("─" * 40)
    print("  Try: 'list 5 programming books' or 'suggest weekend activities'")
    print("  Now streaming — watch LangBot type! ⚡")
    print("─" * 40)

    while True:
        user_input = input("\nYou: ").strip()

        if user_input.lower() in ("quit", "exit", "q"):
            print("👋 Goodbye!")
            break

        if not user_input:
            continue

        # Day 6: Route to the right chain based on intent
        if wants_list(user_input):
            # List mode — invoke for a complete list
            items = list_chain.invoke({"input": user_input, "history": messages})

            print(f"\nLangBot's suggestions ({len(items)} items):")
            for i, item in enumerate(items, 1):
                print(f"  {i}. {item}")

            # Reconstruct a text reply for history
            reply_text = f"Here are some suggestions: {', '.join(items)}"
        else:
            # 🆕 Day 7: Chat mode — stream the response token by token
            print(f"\nLangBot: ", end="", flush=True)
            full_response = ""
            for chunk in stream_chain.stream({"input": user_input, "history": messages}):
                print(chunk, end="", flush=True)
                full_response += chunk
            print()  # final newline

            reply_text = full_response

            # Optional: uncomment for mood/confidence metadata
            # meta = chat_chain.invoke({"input": user_input, "history": messages})
            # print(f"  [{meta.mood.value} | {meta.confidence:.0%} confidence]")
            # reply_text = meta.message

        # Day 2: Store the exchange in history
        messages.append(HumanMessage(content=user_input))
        messages.append(AIMessage(content=reply_text))


if __name__ == "__main__":
    main()