Implementation Blueprint

# Ensure Python 3.10+ is installed
python3 -m venv langgraph-env
source langgraph-env/bin/activate

# Install LangGraph, LangChain, and a model provider
pip install langgraph langchain-openai

export OPENAI_API_KEY="sk-your-openai-api-key"

import operator
from typing import TypedDict, Annotated, Sequence
from langchain_openai import ChatOpenAI
from langchain_core.messages import BaseMessage, HumanMessage
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolExecutor, ToolNode

# 1. Define custom tools (Mocked for example)
from langchain_core.tools import tool
@tool
def get_weather(location: str) -> str:
    """Returns the current weather for a location."""
    if "san francisco" in location.lower():
        return "It is 60 degrees and foggy."
    return "It is 75 degrees and sunny."

tools = [get_weather]

# 2. Define the Agent State
# The state is passed and updated at every node.
class AgentState(TypedDict):
    # The 'add' operator ensures messages are appended, not overwritten
    messages: Annotated[Sequence[BaseMessage], operator.add]

# 3. Initialize the model and bind tools
model = ChatOpenAI(temperature=0)
model_with_tools = model.bind_tools(tools)
tool_node = ToolNode(tools) # Built-in node to execute tools

# 4. Define Graph Nodes (Functions)
def call_model(state: AgentState):
    """The node that calls the LLM."""
    messages = state['messages']
    response = model_with_tools.invoke(messages)
    # Return a dictionary that matches the State keys to update it
    return {"messages": [response]}

# 5. Define Routing Logic
def should_continue(state: AgentState) -> str:
    """Conditional edge logic to decide the next step."""
    messages = state['messages']
    last_message = messages[-1]
    
    # If the LLM decided to call a tool, route to the tool node
    if last_message.tool_calls:
        return "continue"
    # Otherwise, it's done reasoning. Route to END.
    return "end"

# 6. Build the Graph
workflow = StateGraph(AgentState)

# Add nodes
workflow.add_node("agent", call_model)
workflow.add_node("action", tool_node)

# Set the entry point
workflow.set_entry_point("agent")

# Add conditional routing from agent to either action or END
workflow.add_conditional_edges(
    "agent",
    should_continue,
    {
        "continue": "action",
        "end": END
    }
)

# Add a normal edge: after an action executes, always go back to the agent to interpret it
workflow.add_edge("action", "agent")

# 7. Compile the graph
app = workflow.compile()

# 8. Execute the compiled graph
inputs = {"messages": [HumanMessage(content="What is the weather in San Francisco?")]}
print("Executing LangGraph...")

# Stream the execution steps
for output in app.stream(inputs):
    for key, value in output.items():
        print(f"Node '{key}':")
        print(value)
        print("---")

from langgraph.checkpoint.memory import MemorySaver

# Use an in-memory saver for testing. In prod, use PostgresSaver or similar.
memory = MemorySaver()

# Compile the graph with persistence and a breakpoint *before* the action node
app_persistent = workflow.compile(
    checkpointer=memory,
    interrupt_before=["action"] # Wait before letting the agent execute a tool
)

# Execution requires a thread ID to track the session
config = {"configurable": {"thread_id": "session-1234"}}
inputs = {"messages": [HumanMessage(content="What is the weather in San Francisco?")]}

print("Executing until breakpoint...")
for event in app_persistent.stream(inputs, config):
    print(event)

# The graph pauses here. 
# A human could look at a web UI to approve the tool call.

print("Resuming execution...")
# Passing None as input tells the graph to resume from its saved state
for event in app_persistent.stream(None, config):
    print(event)