客户支持

### **模板应用**

模板是开源的参考应用，旨在帮助您快速开始使用 LangGraph 构建应用。它们提供了常见的代理工作流程的示例，可以根据您的需求进行自定义。

您可以使用 LangGraph CLI 从模板创建应用。

---

#### **环境要求**
- **Python** >= 3.11
- **LangGraph CLI**：需要 `langchain-cli[inmem]` >= 0.1.58

---

#### **安装 LangGraph CLI**
```bash
pip install "langgraph-cli[inmem]" --upgrade
```

---

#### **可用模板**
| 模板名称               | 描述                                                                 | Python 仓库 | JS/TS 仓库 |
|------------------------|----------------------------------------------------------------------|-------------|------------|
| **New LangGraph Project** | 一个简单、最小化的聊天机器人，带有记忆功能。                           | [Repo](https://github.com/langgraph/template-new-project-python) | [Repo](https://github.com/langgraph/template-new-project-js) |
| **ReAct Agent**         | 一个简单的代理，可以灵活扩展以支持多种工具。                           | [Repo](https://github.com/langgraph/template-react-agent-python) | [Repo](https://github.com/langgraph/template-react-agent-js) |
| **Memory Agent**         | 一个 ReAct 风格的代理，带有额外的工具，用于跨线程存储记忆。             | [Repo](https://github.com/langgraph/template-memory-agent-python) | [Repo](https://github.com/langgraph/template-memory-agent-js) |
| **Retrieval Agent**     | 一个包含基于检索的问答系统的代理。                                     | [Repo](https://github.com/langgraph/template-retrieval-agent-python) | [Repo](https://github.com/langgraph/template-retrieval-agent-js) |
| **Data-Enrichment Agent** | 一个执行网络搜索并将其发现组织成结构化格式的代理。                     | [Repo](https://github.com/langgraph/template-data-enrichment-agent-python) | [Repo](https://github.com/langgraph/template-data-enrichment-agent-js) |

---

#### **🌱 创建 LangGraph 应用**
要从模板创建新应用，请使用 `langgraph new` 命令：
```bash
langgraph new
```

---

#### **下一步**
1. **查看 README.md 文件**  
   在您的新 LangGraph 应用的根目录中，查看 `README.md` 文件，了解模板的详细信息以及如何自定义它。

2. **启动应用**  
   在正确配置应用并添加 API 密钥后，可以使用以下命令启动应用：
   ```bash
   langgraph dev
   ```

3. **部署应用**  
   参考以下指南部署您的应用：
   - [启动本地 LangGraph 服务器](https://langgraph.ai/quickstart)：本快速入门指南展示了如何为 ReAct Agent 模板启动本地 LangGraph 服务器。其他模板的步骤类似。
   - [部署到 LangGraph Cloud](https://langgraph.ai/deploy)：使用 LangGraph Cloud 部署您的应用。

---

#### **LangGraph 框架**
- [LangGraph 概念](https://langgraph.ai/concepts)：学习 LangGraph 的基础概念。
- [LangGraph 操作指南](https://langgraph.ai/guides)：了解使用 LangGraph 完成常见任务的指南。

---

#### **📚 了解更多关于 LangGraph 平台**
通过以下资源扩展您的知识：
- [LangGraph 平台概念](https://langgraph.ai/concepts)：了解 LangGraph 平台的基础概念。
- [LangGraph 平台操作指南](https://langgraph.ai/guides)：探索构建和部署应用的逐步指南。

---

**开始构建您的智能系统吧！🚀**

模板应用

### **快速入门：本地启动 LangGraph 服务器**

本指南将帮助您在本地快速启动并运行 LangGraph 应用。

---

#### **环境要求**
- **Python** >= 3.11
- **LangGraph CLI**：需要 `langchain-cli[inmem]` >= 0.1.58

---

#### **安装 LangGraph CLI**
```bash
pip install --upgrade "langgraph-cli[inmem]"
```

---

#### **创建 LangGraph 应用**
使用 `react-agent` 模板创建一个新应用。该模板是一个简单的代理，可以灵活扩展以支持多种工具。

```bash
langgraph new path/to/your/app --template react-agent-python
```

**其他模板**  
如果不指定模板，`langgraph new` 会显示交互式菜单，供您选择可用模板。

---

#### **安装依赖**
在应用根目录下，以编辑模式安装依赖，以便服务器使用本地更改：

```bash
pip install -e .
```

---

#### **创建 `.env` 文件**
在应用根目录下找到 `.env.example` 文件，创建 `.env` 文件并复制内容，填写必要的 API 密钥：

```env
LANGSMITH_API_KEY=lsv2...
TAVILY_API_KEY=tvly-...
ANTHROPIC_API_KEY=sk-
OPENAI_API_KEY=sk-...
```

---

#### **启动 LangGraph 服务器**
```bash
langgraph dev
```

如果成功启动，您将看到类似以下输出：

```
Ready!

API: http://localhost:2024

Docs: http://localhost:2024/docs

LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
```

**内存模式**  
`langgraph dev` 以内存模式启动服务器，适合开发和测试。生产环境应使用持久化存储后端。

**持久化模式**  
使用 `langgraph up` 命令启动持久化模式（需要 Docker）。

---

#### **LangGraph Studio Web UI**
LangGraph Studio Web 是一个专用 UI，可连接到 LangGraph API 服务器，支持可视化、交互和调试。

访问 `langgraph dev` 输出中的 URL 即可使用。

**自定义主机/端口**  
如果服务器使用自定义主机/端口，可以通过修改 `baseUrl` 参数指向服务器。例如，端口为 `8000` 时：

```
https://smith.langchain.com/studio/baseUrl=http://127.0.0.1:8000
```

**Safari 兼容性**  
目前，LangGraph Studio Web 不支持 Safari。

---

#### **测试 API**
**安装 Python SDK**
```bash
pip install langgraph-sdk
```

**发送消息（无线程运行）**
```python
from langgraph_sdk import get_client

client = get_client(url="http://localhost:2024")

async for chunk in client.runs.stream(
    None,  # 无线程运行
    "agent", # 代理名称（在 langgraph.json 中定义）
    input={
        "messages": [{
            "role": "human",
            "content": "What is LangGraph?",
        }],
    },
    stream_mode="updates",
):
    print(f"Receiving new event of type: {chunk.event}...")
    print(chunk.data)
    print("\n\n")
```

**认证**  
连接远程服务器时，需要提供 LangSmith API 密钥。详见客户端 API 参考。

---

#### **下一步**
现在您已成功在本地运行 LangGraph 应用，接下来可以探索部署和高级功能：

- **🌐 部署到 LangGraph Cloud**  
  使用 LangGraph Cloud 快速部署您的应用。
- **📚 学习 LangGraph 平台**  
  通过以下资源扩展知识：
  - [LangGraph 平台概念](https://langgraph.ai/concepts)
  - [LangGraph 平台操作指南](https://langgraph.ai/guides)
- **🛠️ 开发者参考**  
  访问详细文档：
  - [LangGraph 服务器 API 参考](https://langgraph.ai/api)
  - [Python SDK 参考](https://langgraph.ai/sdk/python)
  - [JS/TS SDK 参考](https://langgraph.ai/sdk/js)

---

**开始构建您的智能系统吧！🚀**

快速入门：本地启动 LangGraph 服务器

### **工作流与代理：构建智能系统的核心模式**

在构建智能系统时，理解“工作流”和“代理”的区别至关重要。Anthropic 提供了一个清晰的解释：

- **工作流**：通过预定义的代码路径编排 LLM 和工具的系统。
- **代理**：LLM 动态指导自身过程和工具使用的系统，保持对任务完成方式的控制。

LangGraph 提供了构建这些系统的强大工具，支持持久化、流式处理、调试和部署。以下是详细指南：

---

#### **环境设置**
首先，安装依赖并配置 API 密钥：

```python
%%capture --no-stderr
%pip install -U langgraph langsmith langchain_anthropic

import os
import getpass

def _set_env(var: str):
    if not os.environ.get(var):
        os.environ[var] = getpass.getpass(f"{var}: ")

_set_env("ANTHROPIC_API_KEY")

from langchain_anthropic import ChatAnthropic
llm = ChatAnthropic(model="claude-3-5-sonnet-latest")
```

---

#### **构建块：增强的 LLM**
LLM 可以通过结构化输出和工具调用进行增强。以下是示例：

```python
from pydantic import BaseModel, Field

class SearchQuery(BaseModel):
    search_query: str = Field(None, description="优化网络搜索的查询。")
    justification: str = Field(None, description="为什么此查询与用户请求相关。")

# 增强 LLM 以支持结构化输出
structured_llm = llm.with_structured_output(SearchQuery)

# 调用增强的 LLM
output = structured_llm.invoke("钙 CT 评分与高胆固醇有何关系？")
print(output)
```

---

#### **提示链**
提示链将任务分解为一系列步骤，每个 LLM 调用处理前一个调用的输出：

```python
from langgraph.graph import StateGraph, START, END
from typing_extensions import TypedDict

# 定义状态
class State(TypedDict):
    topic: str
    joke: str
    improved_joke: str
    final_joke: str

# 节点函数
def generate_joke(state: State):
    msg = llm.invoke(f"写一个关于 {state['topic']} 的短笑话。")
    return {"joke": msg.content}

def check_punchline(state: State):
    if "?" in state["joke"] or "!" in state["joke"]:
        return "Fail"
    return "Pass"

def improve_joke(state: State):
    msg = llm.invoke(f"通过添加文字游戏使这个笑话更有趣：{state['joke']}")
    return {"improved_joke": msg.content}

def polish_joke(state: State):
    msg = llm.invoke(f"为这个笑话添加一个意想不到的转折：{state['improved_joke']}")
    return {"final_joke": msg.content}

# 构建工作流
workflow = StateGraph(State)
workflow.add_node("generate_joke", generate_joke)
workflow.add_node("improve_joke", improve_joke)
workflow.add_node("polish_joke", polish_joke)
workflow.add_edge(START, "generate_joke")
workflow.add_conditional_edges("generate_joke", check_punchline, {"Fail": "improve_joke", "Pass": END})
workflow.add_edge("improve_joke", "polish_joke")
workflow.add_edge("polish_joke", END)
chain = workflow.compile()

# 调用
state = chain.invoke({"topic": "猫"})
print(state["final_joke"])
```

---

#### **并行化**
并行化允许 LLM 同时处理任务，并将输出聚合：

```python
# 定义状态
class State(TypedDict):
    topic: str
    joke: str
    story: str
    poem: str
    combined_output: str

# 节点函数
def call_llm_1(state: State):
    msg = llm.invoke(f"写一个关于 {state['topic']} 的笑话。")
    return {"joke": msg.content}

def call_llm_2(state: State):
    msg = llm.invoke(f"写一个关于 {state['topic']} 的故事。")
    return {"story": msg.content}

def call_llm_3(state: State):
    msg = llm.invoke(f"写一首关于 {state['topic']} 的诗。")
    return {"poem": msg.content}

def aggregator(state: State):
    combined = f"这是关于 {state['topic']} 的故事、笑话和诗！\n\n"
    combined += f"故事：\n{state['story']}\n\n"
    combined += f"笑话：\n{state['joke']}\n\n"
    combined += f"诗：\n{state['poem']}"
    return {"combined_output": combined}

# 构建工作流
parallel_builder = StateGraph(State)
parallel_builder.add_node("call_llm_1", call_llm_1)
parallel_builder.add_node("call_llm_2", call_llm_2)
parallel_builder.add_node("call_llm_3", call_llm_3)
parallel_builder.add_node("aggregator", aggregator)
parallel_builder.add_edge(START, "call_llm_1")
parallel_builder.add_edge(START, "call_llm_2")
parallel_builder.add_edge(START, "call_llm_3")
parallel_builder.add_edge("call_llm_1", "aggregator")
parallel_builder.add_edge("call_llm_2", "aggregator")
parallel_builder.add_edge("call_llm_3", "aggregator")
parallel_builder.add_edge("aggregator", END)
parallel_workflow = parallel_builder.compile()

# 调用
state = parallel_workflow.invoke({"topic": "狗"})
print(state["combined_output"])
```

---

#### **代理**
代理通过工具调用和环境反馈在循环中执行任务：

```python
from langgraph.graph import MessagesState
from langchain_core.messages import SystemMessage, HumanMessage, ToolMessage
from langchain_core.tools import tool

# 定义工具
@tool
def multiply(a: int, b: int) -> int:
    return a * b

@tool
def add(a: int, b: int) -> int:
    return a + b

@tool
def divide(a: int, b: int) -> float:
    return a / b

# 增强 LLM 以支持工具调用
tools = [add, multiply, divide]
tools_by_name = {tool.name: tool for tool in tools}
llm_with_tools = llm.bind_tools(tools)

# 节点函数
def llm_call(state: MessagesState):
    return {
        "messages": [
            llm_with_tools.invoke(
                [
                    SystemMessage(content="你是一个帮助执行算术运算的助手。")
                ]
                + state["messages"]
            )
        ]
    }

def tool_node(state: dict):
    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}

def should_continue(state: MessagesState) -> Literal["environment", END]:
    if state["messages"][-1].tool_calls:
        return "Action"
    return END

# 构建代理
agent_builder = StateGraph(MessagesState)
agent_builder.add_node("llm_call", llm_call)
agent_builder.add_node("environment", tool_node)
agent_builder.add_edge(START, "llm_call")
agent_builder.add_conditional_edges("llm_call", should_continue, {"Action": "environment", END: END})
agent_builder.add_edge("environment", "llm_call")
agent = agent_builder.compile()

# 调用
messages = [HumanMessage(content="3 加 4 等于多少？")]
messages = agent.invoke({"messages": messages})
for m in messages["messages"]:
    m.pretty_print()
```

---

#### **LangGraph 的优势**
- **持久化**：支持人类干预和动作批准。
- **流式处理**：支持流式输出和中间状态。
- **部署**：提供简单的部署、可观察性和评估。

---

**下一步**  
- 探索 [LangGraph 文档](https://langgraph.ai/concepts)。
- 学习 [LangChain Academy](https://langchain.academy) 的课程。
- 构建更复杂的智能系统！ 🚀

工作流与代理：构建智能系统的核心模式

### **构建支持聊天机器人：从基础到高级功能**

---

#### **概述**
在本教程中，我们将使用 LangGraph 构建一个支持聊天机器人，具备以下功能：
- ✅ 通过搜索网络回答常见问题
- ✅ 在多次调用中维护对话状态
- ✅ 将复杂查询路由给人工审核
- ✅ 使用自定义状态控制行为
- ✅ 回滚并探索替代对话路径

我们将从一个基础聊天机器人开始，逐步添加更复杂的功能，并在此过程中介绍 LangGraph 的核心概念。让我们开始吧！ 🌟

---

#### **环境设置**
首先，安装所需的包并配置环境：

```python
%%capture --no-stderr
%pip install -U langgraph langsmith langchain_anthropic

import getpass
import os

def _set_env(var: str):
    if not os.environ.get(var):
        os.environ[var] = getpass.getpass(f"{var}: ")

_set_env("ANTHROPIC_API_KEY")
```

**设置 LangSmith**  
注册 [LangSmith](https://langsmith.com/) 以快速发现问题并优化 LangGraph 项目的性能。LangSmith 允许你使用跟踪数据调试、测试和监控基于 LangGraph 构建的 LLM 应用。

---

#### **第一部分：构建基础聊天机器人**
我们将首先使用 LangGraph 创建一个简单的聊天机器人。这个机器人将直接响应用户消息。虽然简单，但它将展示使用 LangGraph 构建应用的核心概念。

**步骤 1：创建 StateGraph**  
`StateGraph` 对象定义了聊天机器人作为“状态机”的结构。我们将添加节点来表示 LLM 和机器人可以调用的函数，并添加边来指定机器人如何在函数之间转换。

```python
from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages

class State(TypedDict):
    messages: Annotated[list, add_messages]

graph_builder = StateGraph(State)
```

**步骤 2：添加聊天机器人节点**  
节点代表工作单元，通常是普通的 Python 函数。

```python
from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")

def chatbot(state: State):
    return {"messages": [llm.invoke(state["messages"])]}

graph_builder.add_node("chatbot", chatbot)
```

**步骤 3：添加入口点和结束点**  
入口点告诉图每次运行时从哪里开始，结束点指示图何时可以退出。

```python
graph_builder.add_edge(START, "chatbot")
graph_builder.add_edge("chatbot", END)
```

**步骤 4：编译并运行图**  
调用 `compile()` 方法创建 `CompiledGraph`，然后使用 `invoke` 运行。

```python
graph = graph_builder.compile()
```

**步骤 5：可视化图**  
使用 `get_graph` 方法可视化图。

```python
from IPython.display import Image, display

try:
    display(Image(graph.get_graph().draw_mermaid_png()))
except Exception:
    pass
```

**步骤 6：运行聊天机器人**  
通过循环与用户交互，运行聊天机器人。

```python
def stream_graph_updates(user_input: str):
    for event in graph.stream({"messages": [{"role": "user", "content": user_input}]}):
        for value in event.values():
            print("Assistant:", value["messages"][-1].content)

while True:
    try:
        user_input = input("User: ")
        if user_input.lower() in ["quit", "exit", "q"]:
            print("Goodbye!")
            break
        stream_graph_updates(user_input)
    except:
        user_input = "What do you know about LangGraph?"
        print("User: " + user_input)
        stream_graph_updates(user_input)
        break
```

**恭喜！** 你已经使用 LangGraph 构建了第一个聊天机器人。这个机器人可以通过 LLM 生成响应与用户进行基本对话。

---

#### **第二部分：增强聊天机器人功能**
为了让机器人回答更多问题，我们将集成一个网络搜索工具。

**步骤 1：安装依赖并设置 API 密钥**

```python
%%capture --no-stderr
%pip install -U tavily-python langchain_community
_set_env("TAVILY_API_KEY")
```

**步骤 2：定义搜索工具**

```python
from langchain_community.tools.tavily_search import TavilySearchResults

tool = TavilySearchResults(max_results=2)
tools = [tool]
tool.invoke("What's a 'node' in LangGraph?")
```

**步骤 3：更新图定义**  
在 LLM 上绑定工具，让 LLM 知道如何使用搜索工具。

```python
llm_with_tools = llm.bind_tools(tools)

def chatbot(state: State):
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

graph_builder.add_node("chatbot", chatbot)
```

**步骤 4：运行增强版聊天机器人**  
现在，机器人可以使用搜索工具回答更多问题。

---

#### **第三部分：添加高级功能**
我们将进一步扩展聊天机器人的功能，包括：
- **维护对话状态**：在多次调用中保留上下文。
- **路由复杂查询**：将复杂问题路由给人工审核。
- **自定义状态控制**：使用自定义状态控制机器人行为。
- **回滚和探索**：支持回滚并探索替代对话路径。

---

#### **总结**
通过本教程，你学会了如何使用 LangGraph 构建一个支持聊天机器人，并逐步添加高级功能。LangGraph 的强大功能使得构建复杂的 AI 应用变得更加简单和灵活。继续探索 LangGraph 的更多功能，构建更强大的应用吧！

---

**下一步**  
- 探索 [LangGraph 服务器快速入门](https://langgraph.ai/server-quickstart)。
- 部署你的 LangGraph 应用到 [LangGraph Cloud](https://langgraph.ai/cloud-quickstart)。
- 深入学习 [LangGraph 概念](https://langgraph.ai/concepts) 和 [操作指南](https://langgraph.ai/how-to-guides)。

