Quickstart

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

Using an AI coding assistant?

Install the LangChain Docs MCP servers to give your agent access to up-to-date LangChain documentation and examples.
Connect LangChain docs MCP servers
Install LangChain Skills to improve your agent’s performance on LangChain ecosystem tasks.
Install LangChain Skills

Prerequisites

Before you begin, make sure you have an API key from a model provider (e.g., Gemini, Anthropic, OpenAI). See chat model integrations 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.

Setup

Install langgraph, langchain, and langchain-anthropic:

pip install -U langgraph langchain langchain-anthropic

uv add langgraph langchain langchain-anthropic

This example uses Anthropic. Set your API key in the shell or a .env file:

export ANTHROPIC_API_KEY="your-api-key"

ANTHROPIC_API_KEY=your-api-key

To use another provider, see chat model integrations and adapt the model initialization in the next steps.

1. Choose the API

Both paths build the same calculator agent: the model can call tools, then the agent calls the model again until it returns a final answer.

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.

Pick a tab. Create one file. Add the code from each step below the previous step. Not sure which to pick? See Choosing between Graph and Functional APIs. For conceptual information, see Graph API overview and Functional API overview.

Use the Graph API
Use the Functional API

Build the LangGraph Graph API calculator quickstart

2. Define tools and model

This example uses the Claude Sonnet model and defines tools for addition, multiplication, and division.Create a file for the agent (agent.py or agent.ts). Add the following:

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)

3. Define state

The graph’s state stores the messages and the number of LLM calls.Add the following below the tools and model:

State in LangGraph persists throughout the agent’s execution.The Annotated type with operator.add appends new messages to the list instead of replacing it.

from langchain.messages import AnyMessage
from typing_extensions import TypedDict, Annotated
import operator


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

4. Define model node

The model node calls the LLM and decides whether to call a tool.Add the following below the state schema:

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
    }

5. Define tool node

The tool node calls the tools and returns the results.Add the following below the model node:

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}

6. Define end logic

The conditional edge function routes to the tool node or to the end, depending on whether the LLM made a tool call.Add the following below the tool node:

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

7. Build and compile the agent

Add the following below the routing function. Build the graph with StateGraph and compile it with compile:

# 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()

8. Set up LangSmith tracing

LangSmith shows tool calls and model responses as the agent runs.This step is optional. Sign up at smith.langchain.com, create an API key, and set these environment variables in the shell before you run the agent:

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"

9. Run the agent

Add the following below the compiled graph:

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()

Run the file:

python agent.py

You should see the human message, a tool call to add, the tool result 7, and a final assistant reply. The exact text varies by model, but the tool result is 7.To check your file, compare it with the full example:

Full code example

# Step 2: 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 3: Define state

from langchain.messages import AnyMessage
from typing_extensions import TypedDict, Annotated
import operator


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

# Step 4: 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 5: 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 6: Define end logic

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 7: Build and compile the 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()


# Step 8: Set up LangSmith tracing (optional)
# export LANGSMITH_TRACING=true
# export LANGSMITH_API_KEY="your-langsmith-api-key"

# Step 9: Run the agent
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()

Build the LangGraph Functional API calculator quickstart

2. Define tools and model

This example uses the Claude Sonnet model and defines tools for addition, multiplication, and division.Create a file for the agent (agent.py or agent.ts). Add the following:

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

3. Define model task

The model task calls the LLM and decides whether to call a tool.Add the following below the tools and model:

The @task decorator marks a function as a task in the agent. Call tasks synchronously or asynchronously from the entrypoint.

@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
    )

4. Define tool task

The tool task calls the tools and returns the results.Add the following below the model task:

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

5. Define agent

Add the following below the tasks. Define the agent with @entrypoint:

The Functional API uses ordinary control flow (loops and conditionals) in a single function instead of explicit nodes and edges.

@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

6. Set up LangSmith tracing

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"

7. Run the agent

Add the following below the entrypoint:

from langchain.messages import HumanMessage

messages = [HumanMessage(content="Add 3 and 4.")]
messages = agent.invoke(messages)
for m in messages:
    m.pretty_print()

Run the file:

python agent.py

Full code example

# Step 2: 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 3: Define model task

@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 4: Define tool task

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


# Step 5: 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

# Step 6: Set up LangSmith tracing (optional)
# export LANGSMITH_TRACING=true
# export LANGSMITH_API_KEY="your-langsmith-api-key"

# Step 7: Run the agent
messages = [HumanMessage(content="Add 3 and 4.")]
messages = agent.invoke(messages)
for m in messages:
    m.pretty_print()

Next steps

You now have a working calculator agent. Continue with one of the following subjects:

Learn the APIs: Choosing between Graph and Functional APIs, then the Build checklist for the Graph API or the Build checklist for the Functional API.
Add persistence: Use a checkpointer so runs can pause and resume across sessions.
Add human-in-the-loop: Pause with interrupts for approval or edits.
Stream results: Follow streaming for tokens and state updates.
Go deeper: Thinking in the Graph API, Thinking in the Functional API, and Workflows and agents.
Deploy: Host the agent with LangSmith Deployment.
Evaluate: Test behavior with LangSmith evaluation.

Connect these docs to your agent of choice via MCP for real-time answers.

Edit this page on GitHub or file an issue.

Get started

Capabilities

Patterns

Build with the Graph API

Deployment

Frontend

Advanced

Prerequisites

Setup

1. Choose the API

2. Define tools and model

3. Define state

4. Define model node

5. Define tool node

6. Define end logic

7. Build and compile the agent

8. Set up LangSmith tracing

9. Run the agent

2. Define tools and model

3. Define model task

4. Define tool task

5. Define agent

6. Set up LangSmith tracing

7. Run the agent

Next steps

​Prerequisites

​Setup

​1. Choose the API

​2. Define tools and model

​3. Define state

​4. Define model node

​5. Define tool node

​6. Define end logic

​7. Build and compile the agent

​8. Set up LangSmith tracing

​9. Run the agent

​2. Define tools and model

​3. Define model task

​4. Define tool task

​5. Define agent

​6. Set up LangSmith tracing

​7. Run the agent

​Next steps

Prerequisites

Setup

1. Choose the API

2. Define tools and model

3. Define state

4. Define model node

5. Define tool node

6. Define end logic

7. Build and compile the agent

8. Set up LangSmith tracing

9. Run the agent

2. Define tools and model

3. Define model task

4. Define tool task

5. Define agent

6. Set up LangSmith tracing

7. Run the agent

Next steps