Quickstart

This quickstart demonstrates how to build a calculator agent using the LangGraph Graph API or the Functional API.

Build a LangGraph calculator agent in this working directory by following the LangGraph quickstart.

Step 1: Read the guide

Detect whether this project uses Python or TypeScript/JavaScript. Fetch and follow the matching page; treat it as the source of truth for package names, model strings, and code:

Ask the user whether to use the Graph API or the Functional API. If they have no preference, use the Graph API path.

Step 2: Install dependencies

Install the packages required by the chosen path with the package manager already used in this project.

Step 3: Configure model credentials

This quickstart uses Anthropic by default. Check whether ANTHROPIC_API_KEY is set. If it is not, ask the user to create a key and set it in the shell or a .env file, then stop and wait for confirmation. Do not invent, hardcode, or commit API keys. If the user prefers another chat model provider from the integrations docs, adapt the example accordingly after confirming.

Step 4: Implement the calculator agent

Implement the selected quickstart path end to end: tools for add, multiply, and divide; the agent graph or functional workflow; and a sample invocation that exercises tool calling. Print the final result so the user can verify the run.

Rules

Stay scoped to this quickstart. Do not add deployment, evals, or unrelated frameworks unless the user asks.
Prefer the APIs and structure shown on the fetched guide over inventing a different agent pattern.
Ask rather than guess when a secret, API choice, or project convention is unclear.

**Using an AI coding assistant?**

- Install the [LangChain Docs MCP servers](/use-these-docs) to give your agent access to up-to-date LangChain documentation and examples.

  
- Install [LangChain Skills](https://github.com/langchain-ai/langchain-skills) to improve your agent's performance on LangChain ecosystem tasks.

Use the Graph API if you prefer to define your agent as a graph of nodes and edges.
Use the Functional API if you prefer to define your agent as a single function.

For conceptual information, see Graph API overview (opens in a new tab) and Functional API overview (opens in a new tab).

For this example, you will need to set up a Claude (Anthropic) (opens in a new tab) account and get an API key. Then, set the ANTHROPIC_API_KEY environment variable in your terminal. See chat model integrations (opens in a new tab) for all available providers. If you use LangSmith Gateway, you can bring your own provider keys or use Gateway Credits to access models without a provider key.

Use the Graph API

1. Define tools and model

In this example, we'll use the Claude Sonnet 4.5 model and define tools for addition, multiplication, and division.

from langchain.tools import tool
from langchain.chat_models import init_chat_model
 
 
model = init_chat_model(
    "claude-sonnet-4-6",
    temperature=0
)
 
 
# Define tools
@tool
def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a * b
 
 
@tool
def add(a: int, b: int) -> int:
    """Adds `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a + b
 
 
@tool
def divide(a: int, b: int) -> float:
    """Divide `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a / b
 
 
# Augment the LLM with tools
tools = [add, multiply, divide]
tools_by_name = {tool.name: tool for tool in tools}
model_with_tools = model.bind_tools(tools)

2. Define state

The graph's state is used to store the messages and the number of LLM calls.

State in LangGraph persists throughout the agent's execution.

The `Annotated` type with `operator.add` ensures that new messages are appended to the existing list rather than replacing it.

from langchain.messages import AnyMessage
from typing_extensions import TypedDict, Annotated
 
 
class MessagesState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]
    llm_calls: int

3. Define model node

The model node is used to call the LLM and decide whether to call a tool or not.

from langchain.messages import SystemMessage
 
 
def llm_call(state: dict):
    """LLM decides whether to call a tool or not"""
 
    return {
        "messages": [
            model_with_tools.invoke(
                [
                    SystemMessage(
                        content="You are a helpful assistant tasked with performing arithmetic on a set of inputs."
                    )
                ]
                + state["messages"]
            )
        ],
        "llm_calls": state.get('llm_calls', 0) + 1
    }

4. Define tool node

The tool node is used to call the tools and return the results.

from langchain.messages import ToolMessage
 
 
def tool_node(state: dict):
    """Performs the tool call"""
 
    result = []
    for tool_call in state["messages"][-1].tool_calls:
        tool = tools_by_name[tool_call["name"]]
        observation = tool.invoke(tool_call["args"])
        result.append(ToolMessage(content=observation, tool_call_id=tool_call["id"]))
    return {"messages": result}

5. Define end logic

The conditional edge function is used to route to the tool node or end based upon whether the LLM made a tool call.

from typing import Literal
from langgraph.graph import StateGraph, START, END
 
 
def should_continue(state: MessagesState) -> Literal["tool_node", END]:
    """Decide if we should continue the loop or stop based upon whether the LLM made a tool call"""
 
    messages = state["messages"]
    last_message = messages[-1]
 
    # If the LLM makes a tool call, then perform an action
    if last_message.tool_calls:
        return "tool_node"
 
    # Otherwise, we stop (reply to the user)
    return END

6. Build and compile the agent

The agent is built using the @[StateGraph] class and compiled using the @[compile][StateGraph.compile] method.

# Build workflow
agent_builder = StateGraph(MessagesState)
 
# Add nodes
agent_builder.add_node("llm_call", llm_call)
agent_builder.add_node("tool_node", tool_node)
 
# Add edges to connect nodes
agent_builder.add_edge(START, "llm_call")
agent_builder.add_conditional_edges(
    "llm_call",
    should_continue,
    ["tool_node", END]
)
agent_builder.add_edge("tool_node", "llm_call")
 
# Compile the agent
agent = agent_builder.compile()
 
# Show the agent
from IPython.display import Image, display
display(Image(agent.get_graph(xray=True).draw_mermaid_png()))
 
# Invoke
from langchain.messages import HumanMessage
messages = [HumanMessage(content="Add 3 and 4.")]
messages = agent.invoke({"messages": messages})
for m in messages["messages"]:
    m.pretty_print()

Trace and debug your agent with LangSmith (opens in a new tab). Follow the tracing quickstart to get set up. When ready for production, see Deploy for hosting options.

We recommend you also set up LangSmith Engine which monitors your traces, detects issues, and proposes fixes.

Congratulations! You've built your first agent using the LangGraph Graph API.

Full code example

# Step 1: Define tools and model
 
from langchain.tools import tool
from langchain.chat_models import init_chat_model
 
 
model = init_chat_model(
    "claude-sonnet-4-6",
    temperature=0
)
 
 
# Define tools
@tool
def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a * b
 
 
@tool
def add(a: int, b: int) -> int:
    """Adds `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a + b
 
 
@tool
def divide(a: int, b: int) -> float:
    """Divide `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a / b
 
 
# Augment the LLM with tools
tools = [add, multiply, divide]
tools_by_name = {tool.name: tool for tool in tools}
model_with_tools = model.bind_tools(tools)
 
# Step 2: Define state
 
from langchain.messages import AnyMessage
from typing_extensions import TypedDict, Annotated
 
 
class MessagesState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]
    llm_calls: int
 
# Step 3: Define model node
from langchain.messages import SystemMessage
 
 
def llm_call(state: MessagesState):
    """LLM decides whether to call a tool or not"""
 
    return {
        "messages": [
            model_with_tools.invoke(
                [
                    SystemMessage(
                        content="You are a helpful assistant tasked with performing arithmetic on a set of inputs."
                    )
                ]
                + state["messages"]
            )
        ],
        "llm_calls": state.get('llm_calls', 0) + 1
    }
 
 
# Step 4: Define tool node
 
from langchain.messages import ToolMessage
 
 
def tool_node(state: MessagesState):
    """Performs the tool call"""
 
    result = []
    for tool_call in state["messages"][-1].tool_calls:
        tool = tools_by_name[tool_call["name"]]
        observation = tool.invoke(tool_call["args"])
        result.append(ToolMessage(content=observation, tool_call_id=tool_call["id"]))
    return {"messages": result}
 
# Step 5: Define logic to determine whether to end
 
from typing import Literal
from langgraph.graph import StateGraph, START, END
 
 
# Conditional edge function to route to the tool node or end based upon whether the LLM made a tool call
def should_continue(state: MessagesState) -> Literal["tool_node", END]:
    """Decide if we should continue the loop or stop based upon whether the LLM made a tool call"""
 
    messages = state["messages"]
    last_message = messages[-1]
 
    # If the LLM makes a tool call, then perform an action
    if last_message.tool_calls:
        return "tool_node"
 
    # Otherwise, we stop (reply to the user)
    return END
 
# Step 6: Build agent
 
# Build workflow
agent_builder = StateGraph(MessagesState)
 
# Add nodes
agent_builder.add_node("llm_call", llm_call)
agent_builder.add_node("tool_node", tool_node)
 
# Add edges to connect nodes
agent_builder.add_edge(START, "llm_call")
agent_builder.add_conditional_edges(
    "llm_call",
    should_continue,
    ["tool_node", END]
)
agent_builder.add_edge("tool_node", "llm_call")
 
# Compile the agent
agent = agent_builder.compile()
 
 
from IPython.display import Image, display
# Show the agent
display(Image(agent.get_graph(xray=True).draw_mermaid_png()))
 
# Invoke
from langchain.messages import HumanMessage
messages = [HumanMessage(content="Add 3 and 4.")]
messages = agent.invoke({"messages": messages})
for m in messages["messages"]:
    m.pretty_print()

Use the Functional API

1. Define tools and model

In this example, we'll use the Claude Sonnet 4.5 model and define tools for addition, multiplication, and division.

from langchain.tools import tool
from langchain.chat_models import init_chat_model
 
 
model = init_chat_model(
    "claude-sonnet-4-6",
    temperature=0
)
 
 
# Define tools
@tool
def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a * b
 
 
@tool
def add(a: int, b: int) -> int:
    """Adds `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a + b
 
 
@tool
def divide(a: int, b: int) -> float:
    """Divide `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a / b
 
 
# Augment the LLM with tools
tools = [add, multiply, divide]
tools_by_name = {tool.name: tool for tool in tools}
model_with_tools = model.bind_tools(tools)
 
from langgraph.graph import add_messages
from langchain.messages import (
    SystemMessage,
    HumanMessage,
    ToolCall,
)
from langchain_core.messages import BaseMessage
from langgraph.func import entrypoint, task

2. Define model node

The model node is used to call the LLM and decide whether to call a tool or not.

The @[`@task`] decorator marks a function as a task that can be executed as part of the agent. Tasks can be called synchronously or asynchronously within your entrypoint function.

@task
def call_llm(messages: list[BaseMessage]):
    """LLM decides whether to call a tool or not"""
    return model_with_tools.invoke(
        [
            SystemMessage(
                content="You are a helpful assistant tasked with performing arithmetic on a set of inputs."
            )
        ]
        + messages
    )

3. Define tool node

The tool node is used to call the tools and return the results.

@task
def call_tool(tool_call: ToolCall):
    """Performs the tool call"""
    tool = tools_by_name[tool_call["name"]]
    return tool.invoke(tool_call)

4. Define agent

The agent is built using the @[@entrypoint] function.

In the Functional API, instead of defining nodes and edges explicitly, you write standard control flow logic (loops, conditionals) within a single function.

@entrypoint()
def agent(messages: list[BaseMessage]):
    model_response = call_llm(messages).result()
 
    while True:
        if not model_response.tool_calls:
            break
 
        # Execute tools
        tool_result_futures = [
            call_tool(tool_call) for tool_call in model_response.tool_calls
        ]
        tool_results = [fut.result() for fut in tool_result_futures]
        messages = add_messages(messages, [model_response, *tool_results])
        model_response = call_llm(messages).result()
 
    messages = add_messages(messages, model_response)
    return messages
 
# Invoke
messages = [HumanMessage(content="Add 3 and 4.")]
stream = agent.stream_events(messages, version="v3")
for snapshot in stream.values:
    print(snapshot)
    print("\n")

Trace and debug your agent with LangSmith (opens in a new tab). Follow the tracing quickstart to get set up. When ready for production, see Deploy for hosting options.

We recommend you also set up LangSmith Engine which monitors your traces, detects issues, and proposes fixes.

Congratulations! You've built your first agent using the LangGraph Functional API.

# Step 1: Define tools and model
 
from langchain.tools import tool
from langchain.chat_models import init_chat_model
 
 
model = init_chat_model(
    "claude-sonnet-4-6",
    temperature=0
)
 
 
# Define tools
@tool
def multiply(a: int, b: int) -> int:
    """Multiply `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a * b
 
 
@tool
def add(a: int, b: int) -> int:
    """Adds `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a + b
 
 
@tool
def divide(a: int, b: int) -> float:
    """Divide `a` and `b`.
 
    Args:
        a: First int
        b: Second int
    """
    return a / b
 
 
# Augment the LLM with tools
tools = [add, multiply, divide]
tools_by_name = {tool.name: tool for tool in tools}
model_with_tools = model.bind_tools(tools)
 
from langgraph.graph import add_messages
from langchain.messages import (
    SystemMessage,
    HumanMessage,
    ToolCall,
)
from langchain_core.messages import BaseMessage
from langgraph.func import entrypoint, task
 
 
# Step 2: Define model node
 
@task
def call_llm(messages: list[BaseMessage]):
    """LLM decides whether to call a tool or not"""
    return model_with_tools.invoke(
        [
            SystemMessage(
                content="You are a helpful assistant tasked with performing arithmetic on a set of inputs."
            )
        ]
        + messages
    )
 
 
# Step 3: Define tool node
 
@task
def call_tool(tool_call: ToolCall):
    """Performs the tool call"""
    tool = tools_by_name[tool_call["name"]]
    return tool.invoke(tool_call)
 
 
# Step 4: Define agent
 
@entrypoint()
def agent(messages: list[BaseMessage]):
    model_response = call_llm(messages).result()
 
    while True:
        if not model_response.tool_calls:
            break
 
        # Execute tools
        tool_result_futures = [
            call_tool(tool_call) for tool_call in model_response.tool_calls
        ]
        tool_results = [fut.result() for fut in tool_result_futures]
        messages = add_messages(messages, [model_response, *tool_results])
        model_response = call_llm(messages).result()
 
    messages = add_messages(messages, model_response)
    return messages
 
# Invoke
messages = [HumanMessage(content="Add 3 and 4.")]
stream = agent.stream_events(messages, version="v3")
for snapshot in stream.values:
    print(snapshot)
    print("\n")

runtime Build a custom SQL agent