Recap — Building Your First Graph

# Building Your First Graph A LangGraph state graph has four parts: state schema, nodes, edges, entry point. Compile and invoke. ## Step 1 — Define the state schema State is a `TypedDict` (or Pydantic model) describing what data flows through the graph. ```python from typing import TypedDict, Annotated from langchain_core.messages import BaseMessage import operator class AgentState(TypedDict): # `messages` is a list that ACCUMULATES across nodes (operator.add appends) messages: Annotated[list[BaseMessage], operator.add] # `iteration` REPLACES on update (default behavior — last write wins) iteration: int ``` `Annotated` controls how state updates merge: - `Annotated[list, operator.add]` — append to list. - No annotation — replace. For agent messages, you almost always want append behavior — accumulate the conversation. ## Step 2 — Define nodes A node is a function that takes state and returns a state update (partial dict): ```python from langchain_anthropic import ChatAnthropic from langchain_core.messages import HumanMessage, AIMessage llm = ChatAnthropic(model="claude-sonnet-4-6") def call_model(state: AgentState) -> dict: response = llm.invoke(state["messages"]) return { "messages": [response], # appended (because of operator.add) "iteration": state["iteration"] + 1, # replaces } def call_tool(state: AgentState) -> dict: # Last message has tool_calls (from the LLM) last_message = state["messages"][-1] tool_messages = [] for tc in last_message.tool_calls: tool = TOOL_REGISTRY[tc["name"]] result = tool.invoke(tc["args"]) tool_messages.append( ToolMessage(content=str(result), tool_call_id=tc["id"]) ) return {"messages": tool_messages} ``` Each node returns only the state pieces it changes. LangGraph merges them based on the schema's annotations. ## Step 3 — Define the graph ```python from langgraph.graph import StateGraph, END builder = StateGraph(AgentState) builder.add_node("agent", call_model) builder.add_node("tools", call_tool) # Entry point builder.set_entry_point("agent") # Edges def should_continue(state: AgentState) -> str: last = state["messages"][-1] if hasattr(last, "tool_calls") and last.tool_calls: return "tools" return END builder.add_conditional_edges("agent", should_continue) builder.add_edge("tools", "agent") # after tool, go back to agent graph = builder.compile() ``` What's happening: - Start at `agent` node. - After `agent`, check `should_continue`: - If LLM wants to call a tool → go to `tools` node. - Otherwise → END (graph completes). - After `tools`, always go back to `agent`. This is the classic agent loop: LLM → tool → LLM → tool → ... → final answer. ## Step 4 — Bind tools and run ```python from langchain_core.tools import tool @tool def get_weather(city: str) -> str: '''Get current weather.''' return f"Sunny, 28°C in {city}." TOOL_REGISTRY = {"get_weather": get_weather} # Bind tools to the LLM llm_with_tools = llm.bind_tools([get_weather]) # Update call_model to use bound LLM def call_model(state): response = llm_with_tools.invoke(state["messages"]) return {"messages": [response], "iteration": state["iteration"] + 1} # Run initial_state = { "messages": [HumanMessage(content="What's the weather in Mumbai?")], "iteration": 0, } final_state = graph.invoke(initial_state) print(final_state["messages"][-1].content) ``` The graph: 1. Calls the LLM with "What's the weather in Mumbai?". 2. LLM responds with tool_call: get_weather(city="Mumbai"). 3. `should_continue` sees tool_calls → routes to "tools". 4. `call_tool` executes get_weather → "Sunny, 28°C in Mumbai". 5. `add_edge("tools", "agent")` routes back to agent. 6. LLM sees the tool result, generates final response. 7. `should_continue` sees no tool_calls → END. ## Inspecting the graph ```python # See the graph structure print(graph.get_graph().draw_ascii()) # Or save as PNG: graph.get_graph().draw_png("graph.png") ``` For agents, having the graph diagram in your repo is good documentation. ## Streaming execution ```python for state_chunk in graph.stream(initial_state): print(state_chunk) # {"agent": {"messages": [AIMessage(...)], "iteration": 1}} # {"tools": {"messages": [ToolMessage(...)]}} # {"agent": {"messages": [AIMessage(...)], "iteration": 2}} ``` Each chunk shows which node ran and what state changes. Built-in observability. ## Pre-built `prebuilt.create_react_agent` For common agent patterns, LangGraph ships pre-built constructors: ```python from langgraph.prebuilt import create_react_agent agent = create_react_agent(llm, tools=[get_weather]) result = agent.invoke({"messages": [HumanMessage("Weather in Mumbai?")]}) ``` This is equivalent to the graph above but more concise. Use it for standard ReAct agents; build custom graphs when you need different control flow. ## State design tips 1. **Use Pydantic over Typed