LangChain & LangGraph

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template("Define {topic} in one short sentence.")
llm = ChatAnthropic(model="claude-sonnet-5")
output_parser = StrOutputParser()

# LCEL composes components with the pipe operator.
chain = prompt | llm | output_parser

# Every piece is a Runnable, so the composed chain is one too and inherits
# the whole interface: invoke, batch, and stream, with no extra work.
print("invoke:", chain.invoke({"topic": "machine learning"}))

print("\nstream:", end=" ")
for chunk in chain.stream({"topic": "a vector database"}):
    print(chunk, end="", flush=True)

print("\n\nbatch:")
for answer in chain.batch([{"topic": "RAG"}, {"topic": "an LLM agent"}]):
    print(" -", answer)

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

# --- Build and populate the vector store ---
# Chroma runs embedded here: from_texts creates the collection, embeds the
# documents, and holds them in memory. No server and no pre-existing data.
vectorstore = Chroma.from_texts(
    texts=[
        "Returns are accepted within 30 days of delivery, unopened and in "
        "the original packaging. Refunds go back to the original payment "
        "method within 5 business days of us receiving the item.",
        "Standard shipping takes 3 to 5 business days. Express shipping is "
        "next business day if ordered before 2pm.",
        "Warranty covers manufacturing defects for 2 years from purchase. "
        "It does not cover accidental damage or normal wear.",
    ],
    embedding=OpenAIEmbeddings(model="text-embedding-3-small"),
    collection_name="docs",
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

# --- Define the prompt ---
prompt = ChatPromptTemplate.from_template("""
Answer the question using only the context below.

Context: {context}
Question: {question}
""")

# --- Compose the RAG chain with LCEL ---
# Note the mix: OpenAI for embeddings, Anthropic for generation. Swapping
# either one is a single-line change, which is LangChain's main selling point.
llm = ChatAnthropic(model="claude-sonnet-5")
parser = StrOutputParser()

rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | parser
)

# --- Invoke ---
print(rag_chain.invoke("What is the return policy?"))

from typing import Annotated, TypedDict
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import BaseMessage, HumanMessage, ToolMessage
from langchain_core.tools import tool
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages

# --- State definition ---
class AgentState(TypedDict):
    messages: Annotated[list[BaseMessage], add_messages]

# --- Tools ---
@tool
def get_weather(city: str) -> str:
    """Return the current weather for a city."""
    readings = {"lisbon": "19C, clear", "oslo": "3C, sleet"}
    return readings.get(city.lower(), "no data for that city")

tools = [get_weather]
tool_map = {t.name: t for t in tools}
llm = ChatAnthropic(model="claude-sonnet-5").bind_tools(tools)

# --- Nodes ---
# Nodes return a partial update, not the whole state, so the annotation is
# dict rather than AgentState.
def call_model(state: AgentState) -> dict:
    return {"messages": [llm.invoke(state["messages"])]}

def run_tools(state: AgentState) -> dict:
    last_msg = state["messages"][-1]
    results = []
    for call in last_msg.tool_calls:
        result = tool_map[call["name"]].invoke(call["args"])
        print(f"  [tool] {call['name']}({call['args']}) -> {result}")
        results.append(ToolMessage(content=result, tool_call_id=call["id"]))
    return {"messages": results}

def should_continue(state: AgentState) -> str:
    return "run_tools" if state["messages"][-1].tool_calls else END

# --- Build the graph ---
graph = StateGraph(AgentState)
graph.add_node("call_model", call_model)
graph.add_node("run_tools", run_tools)
graph.add_edge(START, "call_model")
graph.add_conditional_edges("call_model", should_continue)
graph.add_edge("run_tools", "call_model")
agent = graph.compile()

# --- Run ---
result = agent.invoke({"messages": [
    HumanMessage("Compare the weather in Lisbon and Oslo. One sentence.")
]})

# .text, not .content: with thinking enabled, content is a list of blocks.
print(result["messages"][-1].text)
print(f"\nmessages in final state: {len(result['messages'])}")

import anthropic

client = anthropic.Anthropic()

TEXT = (
    "The 30 day return window starts on the delivery date, not the order "
    "date. Items must be unopened. Refunds reach the original payment "
    "method within 5 business days of the warehouse receiving the item."
)

response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": f"Summarize in one sentence:\n\n{TEXT}"}],
)
print(next(b.text for b in response.content if b.type == "text"))