LangBot Day 6: Output Parsers — Transforming Raw Responses into Usable Data

chain = prompt | llm | parser

from langchain_core.output_parsers import StrOutputParser

chain = prompt | llm | StrOutputParser()
result = chain.invoke({"input": "Hello"})
# result: "Hey there! What can I help you with today? 👋"
#         ^-- plain str, no .content needed

response = chain.invoke(...)
print(f"LangBot: {response.content}")   # AIMessage attribute access

response = chain.invoke(...)
print(f"LangBot: {response}")           # already a string

from langchain_core.output_parsers import CommaSeparatedListOutputParser

parser = CommaSeparatedListOutputParser()
chain = prompt | llm | parser

result = chain.invoke({"input": "List 5 programming languages"})
# result: ["Python", "JavaScript", "Rust", "Go", "TypeScript"]
#         ^-- actual list[str], not a string you have to split

print(parser.get_format_instructions())
# Your response should be a list of comma separated values, eg: `foo, bar, baz`

# 🆕 Day 6: Output parsers
from langchain_core.output_parsers import StrOutputParser, CommaSeparatedListOutputParser

# 🆕 Day 6: Keywords that signal the user wants a list
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)

# 🆕 Day 6: Prompt that tells the model to output a comma-separated list
list_parser = CommaSeparatedListOutputParser()

LIST_SYSTEM_PROMPT = SYSTEM_PROMPT + "\n\n" + list_parser.get_format_instructions()

# 🆕 Day 6: Build a list-specific chain
list_prompt = ChatPromptTemplate.from_messages([
    ("system", LIST_SYSTEM_PROMPT),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}"),
])
list_chain = list_prompt | llm | list_parser   # returns list[str]

# 🆕 Day 6: Also showcase StrOutputParser for plain-string output
string_chain = prompt | llm | StrOutputParser   # returns str (no .content needed)

# 🆕 Day 6: Route to the right chain based on intent
if wants_list(user_input):
    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}")
    # Store as a regular text reply for history
    reply_text = f"Here are some suggestions: {', '.join(items)}"
else:
    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

messages.append(HumanMessage(content=user_input))
messages.append(AIMessage(content=reply_text))

# langbot.py — Day 6: Output parsers
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 6: String chain — prompt → raw LLM → StrOutputParser → plain str
    string_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("─" * 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 — returns list[str]
            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 (model doesn't need the parsed list)
            reply_text = f"Here are some suggestions: {', '.join(items)}"
        else:
            # Chat mode — returns LangBotResponse (Day 5)
            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 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'
────────────────────────────────────────

You: What is Python?

LangBot [thoughtful | 100% confidence]:
  Python is a high-level programming language known for its readability — kind of like English, but with more indentations and fewer Oxford commas. 🐍

You: list 5 must-read sci-fi books

LangBot's suggestions (5 items):
  1. Dune by Frank Herbert
  2. Neuromancer by William Gibson
  3. The Left Hand of Darkness by Ursula K. Le Guin
  4. Foundation by Isaac Asimov
  5. Snow Crash by Neal Stephenson

You: suggest weekend activities for a programmer

LangBot's suggestions (5 items):
  1. Build a tiny side project in a language you don't know
  2. Refactor something you wrote 6 months ago and cringe
  3. Go outside and touch grass (then come back and write a script to water it)
  4. Read the documentation of a library you use daily but never actually read
  5. Attend a local hackathon or join an online game jam

You: What's the best book from that sci-fi list?

LangBot [thoughtful | 85% confidence]:
  Dune — it's the one every sci-fi fan eventually circle back to. Frank Herbert built a universe so detailed you'll start checking your water consumption. 🏜️

You: quit

👋 Goodbye!

# Chain with a retriever (Day 9 preview)
rag_chain = retriever | prompt | llm | StrOutputParser()

# Chain with multiple parsers (one for each branch)
main_chain = prompt | llm
text_branch = main_chain | StrOutputParser()
list_branch = main_chain | CommaSeparatedListOutputParser()

# Custom parser as a lambda
weird_chain = prompt | llm | (lambda msg: msg.content[::-1])  # reverses the text

response = chain.invoke(...)
text = response.content           # parsing responsibility
text = text.strip()               # cleanup responsibility
if "," in text:                   # format-detection responsibility
    items = [x.strip() for x in text.split(",")]
print(items)                      # display responsibility

items = list_chain.invoke(...)    # parsing + cleanup handled by the chain
for i, item in enumerate(items, 1):
    print(f"  {i}. {item}")       # display is the only responsibility left

from langchain_core.output_parsers import BaseOutputParser
from typing import List

class NumberedListOutputParser(BaseOutputParser[List[str]]):
    """Parse '1. foo\n2. bar' into ['foo', 'bar']."""

    def parse(self, text: str) -> List[str]:
        lines = text.strip().split("\n")
        return [line.split(". ", 1)[1] for line in lines if ". " in line]

# Use it just like the built-in ones
chain = prompt | llm | NumberedListOutputParser()

# Wrong — structured_llm returns LangBotResponse, not AIMessage
chain = prompt | structured_llm | StrOutputParser()
# Error: StrOutputParser expects an AIMessage or str, got LangBotResponse

# Wrong — the model has no idea it should output comma-separated values
list_chain = prompt | llm | CommaSeparatedListOutputParser()

# Result: the model returns full sentences. The parser splits on commas and
# you get garbage like ["I'd recommend Dune", " which is a classic", ...]

# Wrong — storing the list directly in the message list
messages.append(AIMessage(content=items))  # items is a list, not a string

reply_text = f"Here are some suggestions: {', '.join(items)}"
messages.append(AIMessage(content=reply_text))

# These do the same thing:
chain_a = prompt | llm | StrOutputParser()
chain_b = prompt | llm

text_a = chain_a.invoke(...)          # str
text_b = chain_b.invoke(...).content  # str (manual .content access)

# Over-engineered: using an LLM call to decide which chain to use
intent = llm.invoke(f"Is this a list request? {user_input}")
if "yes" in intent.content.lower():
    ...

# langbot.py — Day 6: Output parsers
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 6: String chain — prompt → raw LLM → StrOutputParser → plain str
    string_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("─" * 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 — returns list[str]
            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 (model doesn't need the parsed list)
            reply_text = f"Here are some suggestions: {', '.join(items)}"
        else:
            # Chat mode — returns LangBotResponse (Day 5)
            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 2: Store the exchange in history
        messages.append(HumanMessage(content=user_input))
        messages.append(AIMessage(content=reply_text))


if __name__ == "__main__":
    main()