Build with LangGraph - SambaNova Integration Guide

This article walks you through integrating LangGraph with SambaNova, from setup to real-world use cases. LangGraph provides a low-level infrastructure framework for building stateful, long-running workflows and agents.

Prerequisites

Before you begin, ensure you have:

A SambaCloud account with an active API key
Python 3.10 or higher installed. langgraph and langchain-sambanova do not support Python 3.9 or earlier.
A model that supports function calling, if your graph calls tools. The examples on this page use Meta-Llama-3.3-70B-Instruct, which supports it. For the full list, see Function calling and JSON mode. A tool-calling graph on a model without function-calling support never emits a tool call, so the graph returns a plain text answer and skips your tool node entirely.

macOS ships with Python 3.9 and exposes it as python3 rather than python. Check your version with python3 --version. If it is below 3.10, install a supported version with pyenv, uv, or brew install python@3.12 before continuing.

Installation and setup

Create a virtual environment:

python3 -m venv .venv
source .venv/bin/activate
python --version

Install the required libraries:

pip install langchain-sambanova langchain langgraph

Set your API key:

export SAMBANOVA_API_KEY="your-api-key"

Each package covers a different part of the examples on this page:

Package	What it provides
`langchain-sambanova`	`ChatSambaNova`, the chat model that talks to SambaCloud
`langgraph`	`StateGraph`, `MessagesState`, and the `START` and `END` sentinels. It also pulls in `langgraph-prebuilt` for `ToolNode` and `tools_condition`, and `langgraph-checkpoint` for `InMemorySaver`.
`langchain`	`langchain-core` primitives such as the `@tool` decorator, plus `langchain.agents.create_agent` if you later want a prebuilt agent instead of a hand-built graph

The examples on this page were verified against langchain-sambanova 1.1.1, langgraph 1.2.10, and langchain 1.3.14. To reproduce that exact set, pin them: pip install langchain-sambanova==1.1.1 langchain==1.3.14 langgraph==1.2.10.

Quickstart

Instantiate a SambaCloud chat model and send your first message:

from langchain_sambanova import ChatSambaNova

llm = ChatSambaNova(model="Meta-Llama-3.3-70B-Instruct")
response = llm.invoke([("human", "Hello!")])
print(response.content)

You should see an output similar to the one below.

Hello. How can I help you today?

ChatSambaNova reads your key from the SAMBANOVA_API_KEY environment variable. invoke returns an AIMessage, so response.content is the reply text. Once this prints a response, you can wire the model into a graph.

Build a graph

Add the model to a single-node graph. The MessagesState schema uses the add_messages reducer, so each node’s return value is appended to the conversation instead of replacing it:

from langchain_sambanova import ChatSambaNova
from langgraph.graph import END, START, MessagesState, StateGraph

llm = ChatSambaNova(model="Meta-Llama-3.3-70B-Instruct")


def chat(state: MessagesState) -> MessagesState:
    return {"messages": [llm.invoke(state["messages"])]}


builder = StateGraph(MessagesState)
builder.add_node("chat", chat)
builder.add_edge(START, "chat")
builder.add_edge("chat", END)
graph = builder.compile()

result = graph.invoke({"messages": [("human", "Hello!")]})
print(result["messages"][-1].content)

You should see an output similar to the one below.

Hello. How can I help you today?

graph.invoke returns the final state, not a single reply. Because MessagesState accumulates, result["messages"] holds the whole conversation: your input first, the model’s AIMessage last. That is why the example reads result["messages"][-1].content rather than result.content. If you print the whole state instead, you can see the shape you are indexing into:

{'messages': [HumanMessage(content='Hello!', ...), AIMessage(content='Hello. How can I help you today?', ...)]}

Add a tool and a conditional edge

A single node is not yet an agent. To let the model decide when to call a tool, bind the tools to the model, add a ToolNode that runs them, and route between the two with a conditional edge. tools_condition inspects the last message: if it contains tool calls it returns "tools", otherwise it ends the graph. The edge from tools back to model is what makes the loop, so the model sees each tool result and can call another tool or answer:

from langchain_core.tools import tool
from langchain_sambanova import ChatSambaNova
from langgraph.graph import START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode, tools_condition


@tool
def get_exchange_rate(base: str, quote: str) -> str:
    """Return the exchange rate from one currency code to another."""
    rates = {("USD", "EUR"): 0.92, ("USD", "JPY"): 157.0}
    rate = rates.get((base.upper(), quote.upper()))
    if rate is None:
        return f"No rate available for {base} to {quote}."
    return f"1 {base.upper()} = {rate} {quote.upper()}"


tools = [get_exchange_rate]
llm = ChatSambaNova(model="Meta-Llama-3.3-70B-Instruct").bind_tools(tools)


def call_model(state: MessagesState) -> MessagesState:
    return {"messages": [llm.invoke(state["messages"])]}


builder = StateGraph(MessagesState)
builder.add_node("model", call_model)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "model")
builder.add_conditional_edges("model", tools_condition)
builder.add_edge("tools", "model")
graph = builder.compile()

result = graph.invoke({"messages": [("human", "How many euros is 100 US dollars?")]})
for message in result["messages"]:
    message.pretty_print()

The get_exchange_rate tool above returns hardcoded rates so the example runs without a second API key. Swap in a real rates API before you rely on the numbers.

pretty_print on each message is the fastest way to confirm the loop actually ran. You should see four messages: your question, the model’s tool call, the tool result, and the final answer.

================================ Human Message =================================

How many euros is 100 US dollars?
================================== Ai Message ==================================
Tool Calls:
  get_exchange_rate (call_abc123)
 Call ID: call_abc123
  Args:
    base: USD
    quote: EUR
================================= Tool Message =================================
Name: get_exchange_rate

1 USD = 0.92 EUR
================================== Ai Message ==================================

100 US dollars is about 92 euros.

If you only see two messages, your question, then a text answer, the model did not emit a tool call. Confirm the model supports function calling, and make the tool docstring describe clearly when to use it.

You do not have to build this graph by hand. from langchain.agents import create_agent returns an equivalent compiled ReAct agent in one call. Build the graph yourself when you need to add your own nodes, custom routing, or state fields.

Persist state across turns

Each graph.invoke call starts from a fresh state, so the graph above cannot remember anything. To keep a conversation, compile with a checkpointer and pass a thread_id. The checkpointer saves state per thread, and the thread_id selects which conversation you are continuing:

from langchain_sambanova import ChatSambaNova
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import END, START, MessagesState, StateGraph

llm = ChatSambaNova(model="Meta-Llama-3.3-70B-Instruct")


def chat(state: MessagesState) -> MessagesState:
    return {"messages": [llm.invoke(state["messages"])]}


builder = StateGraph(MessagesState)
builder.add_node("chat", chat)
builder.add_edge(START, "chat")
builder.add_edge("chat", END)
graph = builder.compile(checkpointer=InMemorySaver())

config = {"configurable": {"thread_id": "conversation-1"}}
graph.invoke({"messages": [("human", "My name is Ada.")]}, config)
result = graph.invoke({"messages": [("human", "What is my name?")]}, config)
print(result["messages"][-1].content)

You should see an output similar to the one below.

Your name is Ada.

The second call sends only the new question, but the checkpointer replays the saved messages for conversation-1, so the model still has the first turn. Change thread_id to a new value and the model no longer knows the name.

InMemorySaver keeps state in the process and loses it on exit, which is what you want for local development. MemorySaver is a backwards-compatible alias for the same class. For anything you deploy, use a durable checkpointer such as PostgresSaver from langgraph-checkpoint-postgres.

Example use cases

You can use LangGraph with SambaCloud to create multi-agent workflows such as web search, Retrieval-Augmented Generation (RAG), and SQL agents. The examples below are complete, runnable versions of those patterns.

Agentic Search: a notebook that builds a chatbot combining a web search tool with a SambaCloud model.
Agentic Graph RAG: a full application, not a notebook, that answers natural-language questions over a healthcare graph database using intelligent routing and generated Cypher queries. Built with LangGraph and FastAPI, with a web interface.

Troubleshooting

command not found: python

macOS does not provide a python executable, only python3. Use python3 -m venv .venv to create the environment. After you activate it with source .venv/bin/activate, python works as expected inside the environment.

sambanova.SambaNovaError: The api_key client option must be set

ChatSambaNova builds its HTTP client while the object is being constructed, so an unset SAMBANOVA_API_KEY fails on the ChatSambaNova(...) line before any request is sent. Confirm the key is visible to the process with echo $SAMBANOVA_API_KEY. An export applies only to the shell it ran in, so a new terminal or a new editor session needs it again.

sambanova.AuthenticationError: Error code: 401 - Incorrect API key provided

The key is set but is not valid. Copy it again from the SambaCloud portal.

ModuleNotFoundError: No module named 'langgraph' or 'langchain_sambanova'

The virtual environment is not active. Run source .venv/bin/activate again, confirm the prompt shows (.venv), then re-run the install command from step 2.

A model error when you did not set a model

If you omit model=, ChatSambaNova falls back to its own default, Llama-4-Maverick-17B-128E-Instruct, which SambaCloud has retired and no longer serves, so the request fails rather than quietly running on a different model. Always pass model= explicitly, using an ID from SambaCloud models.

ChatSambaNovaCloud does not work

Older tutorials import ChatSambaNovaCloud. In langchain-sambanova 1.x that name is a deprecated placeholder with no implementation: the class is decorated @deprecated(since="0.2.0", removal="1.0.0") and has an empty body. Use ChatSambaNova, which serves both SambaCloud and SambaStack and selects between them from base_url.

AttributeError: 'dict' object has no attribute 'content'

You called .content on the graph result. graph.invoke returns the state dictionary, not a message, so read the last message out of the state first with result["messages"][-1].content. Only llm.invoke returns an AIMessage you can read .content from directly.

ValueError: Checkpointer requires one or more of the following 'configurable' keys: thread_id, checkpoint_ns, checkpoint_id

You compiled the graph with a checkpointer but invoked it without a config. A checkpointer needs to know which conversation to load, so pass a thread_id on every call: graph.invoke(payload, {"configurable": {"thread_id": "conversation-1"}}). Reuse the same value to continue a conversation and use a new value to start a fresh one.

langgraph.errors.GraphRecursionError: Recursion limit of 25 reached

The graph kept looping without reaching END. In a tool-calling graph this usually means the model calls a tool, dislikes the result, and calls it again. Print the messages with message.pretty_print() to see what is repeating. Fix the tool so it returns a usable answer or a clear error string rather than raising, and sharpen its docstring so the model knows when it is done. Raise the ceiling only once the loop itself is correct: graph.invoke(payload, {"recursion_limit": 50}).

LangGraphDeprecatedSinceV10: create_react_agent has been moved to langchain.agents

In langgraph-prebuilt 1.1 and later, create_react_agent is deprecated. Replace from langgraph.prebuilt import create_react_agent with from langchain.agents import create_agent and call create_agent(model, tools). ToolNode and tools_condition are not deprecated, so the hand-built graph shown above stays valid.

The model answers in text and never calls your tool

Two common causes. First, the model does not support function calling, so it cannot emit a tool call at all. Check it against Function calling and JSON mode. Second, you built the graph but never bound the tools, so the model does not know they exist. ToolNode(tools) only runs tool calls, it does not advertise them. You need both ToolNode(tools) in the graph and .bind_tools(tools) on the model.

Additional resources

LangGraph documentation for the full graph API, persistence backends, and streaming options
langchain-sambanova on PyPI for constructor options and ChatSambaNova reference
SambaCloud models for current model IDs, context windows, and which models support function calling
Function calling and JSON mode to confirm which models can emit tool calls
SambaCloud API reference

Overview

Developer tools

Frameworks

Interfaces and low-code

Data and infrastructure

Multimodal

Evaluation and monitoring

LangGraph integration guide

Prerequisites

Installation and setup

Quickstart

Build a graph

Add a tool and a conditional edge

Persist state across turns

Example use cases

Troubleshooting

Additional resources

​Prerequisites

​Installation and setup

​Quickstart

​Build a graph

​Add a tool and a conditional edge

​Persist state across turns

​Example use cases

​Troubleshooting

​Additional resources

Prerequisites

Installation and setup

Quickstart

Build a graph

Add a tool and a conditional edge

Persist state across turns

Example use cases

Troubleshooting

Additional resources