LangChain & LangGraph

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

# Each component is a Runnable - they share a standard interface:
#   .invoke()   - single call
#   .batch()    - parallel calls
#   .stream()   - streaming tokens
result = chain.invoke({"topic": "machine learning"})

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

# --- Build the retriever ---
vectorstore = Chroma(
    collection_name="docs",
    embedding_function=OpenAIEmbeddings(),
    persist_directory="./chroma_db",
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# --- 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 ---
llm = ChatAnthropic(model="claude-sonnet-4-6")
parser = StrOutputParser()

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

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

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 search_web(query: str) -> str:
    """Search the web for up-to-date information."""
    return f"[Search result for '{query}': placeholder response]"

tools = [search_web]
llm = ChatAnthropic(model="claude-sonnet-4-6").bind_tools(tools)

# --- Nodes ---
def call_model(state: AgentState) -> AgentState:
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

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

def should_continue(state: AgentState) -> str:
    last_msg = state["messages"][-1]
    return "run_tools" if last_msg.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("What happened in tech news today?")]})
print(result["messages"][-1].content)

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize this text: ..."}],
)
print(response.content[0].text)