Deployment: From local to cloud
Full analysis of LangGraph deployment system

1What problem is this lecture going to solve?

In the previous lectures, we built Simple Graph, Chain, Router, and Agent, all of which were passed in Jupyter Notebookgraph.invoke()Synchronous call. This is no problem in the learning stage, but you will encounter several serious problems in the production environment:

2Five component hierarchy

The LangGraph deployment system consists of five components, and their hierarchical relationship is as follows: from the lowest Python/JS library, to the API server, to three different access/hosting methods.

Layer-by-layer analysis

3Why do you need LangGraph API?

This is a key issue in understanding the entire deployment system. Use directlyinvoke()Isn't it simpler? Let's compare the two ways:

Problem with invoke(): synchronous blocking

# 直接 invoke —— 简单，但在生产环境有严重问题
result = graph.invoke({"messages": [HumanMessage("帮我研究量子计算的最新进展")]})
# ^ 这里会阻塞 5~10 分钟，直到 Agent 完成所有工具调用
# Web 服务器的请求会超时，用户体验极差

Three major capabilities of LangGraph API

# 通过 API 的异步方式 —— 立即返回，streaming 获取结果
async for chunk in client.runs.stream(thread_id, "agent", input=input):
    # 每个图步骤完成后立即收到更新，不阻塞
    print(chunk.data)

4Local development process: langgraph dev

Before deploying the Agent to the cloud, you need to start the LangGraph API server locally so that you can use Studio for visual debugging and use the SDK for integration testing.

studio/ directory structure

Each module has astudio/subdirectory, which is the root directory of the LangGraph API server. The structure is as follows:

langgraph.json is the core configuration

// module-1/studio/langgraph.json
{
  "dependencies": ["."],           // 依赖当前目录（读取 requirements.txt）
  "graphs": {
    "agent": "./agent.py:graph",   // 注册图：graph_id → 文件:变量名
    "router": "./router.py:graph"  // 可以注册多个图
  },
  "env": ".env"                   // 环境变量文件路径
}

Start local server

# 在 studio/ 目录下运行
$ langgraph dev

# 成功启动后输出：
🚀 API: http://127.0.0.1:2024
🎨 Studio UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024

What can Studio do?

• Visualize the nodes and edges of the graph (automatically rendered as a flowchart)
• Directly enter the message and manually trigger the run
• View the complete State content after each step is executed
• View LangSmith trace details (per LLM call, tool call)
• Supports Interrupt (Human-in-the-Loop) of Module 3

5SDK: Programmatic way to access graphs

LangGraph SDK（pip install langgraph-sdk) is a Python client library that lets you interact with the LangGraph API from code. The core entrance isget_client()：

from langgraph_sdk import get_client

# 连接本地开发服务器
URL = "http://127.0.0.1:2024"
client = get_client(url=URL)

# 连接云端部署（切换一行代码即可）
# URL = "https://your-deployment-xxxx.us.langgraph.app"
# client = get_client(url=URL, api_key="lsv2_...")

clientIt is the operation entrance of the entire SDK, through which all resources are accessed:

Complete SDK call example

from langgraph_sdk import get_client
from langchain_core.messages import HumanMessage

# 1. 建立连接
URL = "http://127.0.0.1:2024"
client = get_client(url=URL)

# 2. 查看已注册的图（对应 langgraph.json 里的 graphs）
assistants = await client.assistants.search()
print(assistants)
# [{'assistant_id': '...', 'graph_id': 'agent', ...},
#  {'assistant_id': '...', 'graph_id': 'router', ...}]

# 3. 创建一个对话线程（对应一个持久化的 State 容器）
thread = await client.threads.create()
print(thread['thread_id'])   # 类似 UUID 的字符串

# 4. 在这个线程上发起流式运行
input = {"messages": [HumanMessage(content="Multiply 3 by 2.")]}

async for chunk in client.runs.stream(
    thread['thread_id'],   # 线程 ID
    "agent",              # graph_id（对应 langgraph.json 中的键）
    input=input,
    stream_mode="values",  # 每步后返回完整 State
):
    if chunk.data and chunk.event != "metadata":
        print(chunk.data['messages'][-1])

6Three core concepts: Assistant/Thread/Run

Understanding these three concepts is the basis for making good use of the SDK. They are the resource model of LangGraph API, similar to the three tables in the database.

The relationship between the three

7Streaming operation: detailed explanation of stream_mode

client.runs.stream()Returns an asynchronous iterator, each iteration gets achunkobject.chunkThere are two key fields:chunk.eventandchunk.data。

type of chunk.event

stream_mode parameter comparison

chunk.data structure of stream_mode="values"

# chunk.event == "values" 时，chunk.data 就是完整 State：
chunk.data = {
    "messages": [
        HumanMessage(content="Multiply 3 by 2."),
        AIMessage(content="", tool_calls=[{
            "name": "multiply",
            "args": {"a": 3, "b": 2}
        }]),
        ToolMessage(content="6"),
        AIMessage(content="3 multiplied by 2 equals 6.")
    ]
}

# 每步执行后都会收到一次这样的 chunk，messages 列表逐步增长
# 所以用 chunk.data['messages'][-1] 只看最新的消息

8Local vs. Cloud: Unified Interface for SDK

The most important design concept of LangGraph SDK isLocal development and cloud production use the exact same API. The only difference is the URL and authentication key when connecting.

from langgraph_sdk import get_client

# 本地：只需 URL
client = get_client(
    url="http://127.0.0.1:2024"
)

# 以下代码完全相同 ↓
thread = await client.threads.create()
async for chunk in client.runs.stream(
    thread['thread_id'],
    "agent",
    input=input,
    stream_mode="values",
):
    ...

from langgraph_sdk import get_client

# 云端：URL + API Key
client = get_client(
    url="https://xxx.us.langgraph.app",
    api_key="lsv2_pt_..."
)

# 以下代码完全相同 ↓
thread = await client.threads.create()
async for chunk in client.runs.stream(
    thread['thread_id'],
    "agent",
    input=input,
    stream_mode="values",
):
    ...

On-Premise vs. Cloud: A Complete Comparison

9Cloud deployment process (LangSmith Deployment)

After your Agent passes the local test, you can deploy it to the LangSmith cloud to obtain a stable online service address.

10Complete process series

Connect all the knowledge points together and take a look at a complete LangGraph development to deployment process:

Knowledge point quick check card