LangChainRust：用 Rust 构建高性能 LLM 应用的完整指南

LangChainRust：用 Rust 构建高性能 LLM 应用的完整指南

LangChainRust 是 LangChain 的 Rust 实现，提供了 Agents、Chains、Memory、Tools、RAG 等核心模块，让你用 Rust 构建高性能的 AI 应用。

前言

随着大语言模型（LLM）的普及，如何高效地构建 AI 应用成为开发者关注的焦点。LangChain 作为最流行的 LLM 应用框架，其 Python 版本已被广泛使用。但对于追求高性能的开发者，Rust 版本的 LangChainRust 是更好的选择。

本文将全面介绍 LangChainRust 的七大核心模块，帮助你快速上手 Rust AI 开发。

---

目录

1. [Agents - 智能代理](#Agents - 智能代理)
2. [Chains - 链式调用](#Chains - 链式调用)
3. [Memory - 对话记忆](#Memory - 对话记忆)
4. [Tools - 工具系统](#Tools - 工具系统)
5. [RAG - 检索增强生成](#RAG - 检索增强生成)
6. [Prompts - 提示词模板](#Prompts - 提示词模板)
7. [LLM - 语言模型接口](#LLM - 语言模型接口)
8. 最佳实践

---

1. Agents - 智能代理

什么是 Agent？

Agent 是 LangChainRust 的核心组件，它让 LLM 能够自主决策、调用工具、执行多步骤任务，最终给出答案。

核心价值：

• 将复杂问题分解为步骤
• 自动选择合适工具
• 迭代执行直到完成任务

FunctionCallingAgent（推荐）

使用 OpenAI 原生 Function Calling API，类型安全，可靠性高。适用于 GPT-4、Claude、Gemini 等支持 FC 的模型。

use langchainrust::{
    FunctionCallingAgent, AgentExecutor, BaseAgent, BaseTool,
    OpenAIChat, OpenAIConfig, Calculator, DateTimeTool,
};
use std::sync::Arc;

// 创建 LLM
let config = OpenAIConfig {
    api_key: std::env::var("OPENAI_API_KEY")?,
    model: "gpt-4".to_string(),
    ..Default::default()
};
let llm = OpenAIChat::new(config);

// 创建工具列表
let tools: Vec<Arc<dyn BaseTool>> = vec![
    Arc::new(Calculator::new()),
    Arc::new(DateTimeTool::new()),
];

// 创建 Agent（自动绑定工具）
let agent = FunctionCallingAgent::new(llm, tools.clone(), None);

// 创建执行器
let executor = AgentExecutor::new(Arc::new(agent), tools)
    .with_max_iterations(5);

let result = executor.invoke("计算 37 + 48".to_string()).await?;

ReActAgent（兼容旧模型）

基于 ReAct 论文，使用文本解析方式提取工具调用。适用于不支持 FC 的模型。

use langchainrust::{ReActAgent, AgentExecutor, BaseAgent, BaseTool, SimpleMathTool};

let tools: Vec<Arc<dyn BaseTool>> = vec![
    Arc::new(Calculator::new()),
    Arc::new(DateTimeTool::new()),
    Arc::new(SimpleMathTool::new()),
];

let agent = ReActAgent::new(llm, tools.clone(), None);
let executor = AgentExecutor::new(Arc::new(agent), tools).with_max_iterations(5);

两种 Agent 对比

维度	FunctionCallingAgent	ReActAgent
工具调用方式	原生 Function Calling	文本解析（正则）
可靠性	高（类型安全）	中（依赖 Prompt 格式）
Token 消耗	低	高
适用模型	GPT-4、Claude、Gemini	所有模型
推荐指数	★★★★★	★★★

选择建议：

• 使用 OpenAI GPT-4/Claude/Gemini → FunctionCallingAgent
• 使用本地部署模型/开源模型 → ReActAgent

---

2. Chains - 铁式调用

什么是 Chain？

Chain 是 LangChain 的核心抽象，代表一系列操作的组合。通过 Chain，你可以将 Prompt 模板、LLM 调用、Memory 管理等组件串联成一个处理管道。

LLMChain

最基础的 Chain，组合 Prompt 模板和 LLM：

use langchainrust::{LLMChain, OpenAIChat, BaseChain};
use std::collections::HashMap;
use serde_json::Value;

// 创建 LLMChain
let chain = LLMChain::new(llm, "请用一句话解释：{topic}");

// 执行
let inputs = HashMap::from([
    ("topic".to_string(), Value::String("Rust 语言".to_string()))
]);

let result = chain.invoke(inputs).await?;
println!("{}", result.get("text").unwrap());

SequentialChain

顺序执行多个 Chain，前一个 Chain 的输出可以作为后一个 Chain 的输入：

use langchainrust::{SequentialChain, LLMChain, BaseChain};
use std::sync::Arc;

// 第一步：分析主题
let chain1 = LLMChain::new(llm1, "分析以下主题，提取关键词: {topic}")
    .with_output_key("keywords");

// 第二步：根据关键词生成总结
let chain2 = LLMChain::new(llm2, "根据关键词 {keywords} 写一段总结")
    .with_output_key("summary");

// 创建 SequentialChain
let pipeline = SequentialChain::new()
    .add_chain(Arc::new(chain1), vec!["topic"], vec!["keywords"])
    .add_chain(Arc::new(chain2), vec!["keywords"], vec!["summary"]);

let result = pipeline.invoke(inputs).await?;
println!("关键词: {:?}", result.get("keywords"));
println!("总结: {:?}", result.get("summary"));

ConversationChain

带有 Memory 的对话 Chain，支持多轮对话：

use langchainrust::{ConversationChain, ConversationBufferMemory, BaseMemory};

// 创建 Memory
let memory = ConversationBufferMemory::new().with_return_messages(true);

// 创建 ConversationChain
let chain = ConversationChainBuilder::new(llm)
    .memory(memory)
    .prompt("以下是与用户的对话历史：\n{history}\n\n用户: {input}\nAI:")
    .build();

// 第一轮对话
let result1 = chain.invoke(HashMap::from([("input", "我叫张三")])).await?;

// 第二轮对话（AI 会记住"张三"）
let result2 = chain.invoke(HashMap::from([("input", "我叫什么名字？")])).await?;

---

3. Memory - 对话记忆

什么是 Memory？

Memory 管理 Agent 或 Chain 的对话历史，解决多轮对话的上下文传递问题，同时控制 Token 消耗。

Memory 类型对比

Memory 类型	压缩方式	Token 管理	适用场景
BufferMemory	无压缩	无限制	短对话、需要完整历史
WindowMemory	窗口截断	固定 k 轮	简单控制、接受丢失
SummaryMemory	LLM 摘要	智能压缩	长对话、节省 token
SummaryBufferMemory	摘要 + 保留最近	动态压缩	平衡方案（推荐）

ConversationBufferMemory

保存全部对话历史：

use langchainrust::{ConversationBufferMemory, BaseMemory};
use std::collections::HashMap;

let mut memory = ConversationBufferMemory::new();

// 保存对话
let inputs = HashMap::from([("input".to_string(), "我叫张三".to_string())]);
let outputs = HashMap::from([("output".to_string(), "你好张三！".to_string())]);
memory.save_context(&inputs, &outputs).await?;

// 加载历史
let vars = memory.load_memory_variables(&HashMap::new()).await?;
// 输出: "Human: 我叫张三\nAI: 你好张三！"

ConversationSummaryBufferMemory（推荐）

摘要 + 保留最近对话的混合策略：

use langchainrust::{ConversationSummaryBufferMemory, OpenAIChat};

let llm = OpenAIChat::new(config);

// max_token_limit = 100，超过时触发压缩
let mut memory = ConversationSummaryBufferMemory::new(llm, 100);

for i in 1..=10 {
    memory.save_context(&inputs, &outputs).await?;
}

// 返回: "摘要: 用户讨论了...\n\nHuman: 最近消息\nAI: 回复"

⚠️ 注意：SummaryMemory 每轮对话都会调用 LLM 生成摘要，100 轮对话 = 100 次 LLM 调用，需评估成本。

---

4. Tools - 工具系统

什么是 Tool？

Tool 是 Agent 可以调用的外部函数，用于执行具体操作（计算、查询、抓取等）。

内置工具一览

工具名	描述	参数	示例
Calculator	数学表达式计算	expression	{"expression": "37 + 48"}
DateTimeTool	日期时间查询	operation, datetime	{"operation": "now"}
SimpleMathTool	高级数学运算	operation, value	{"operation": "power", "value": 2}
URLFetchTool	网页抓取	operation, url	{"operation": "fetch"}

使用工具

use langchainrust::{Calculator, BaseTool};
use std::sync::Arc;

let calculator = Calculator::new();

// 直接调用
let result = calculator.run(
    r#"{"expression": "37 + 48"}"#.to_string()
).await?;
println!("{}", result);  // 输出: "37 + 48 = 85"

自定义工具

通过实现 BaseTool trait 创建自定义工具：

use langchainrust::core::tools::{BaseTool, ToolError};
use schemars::JsonSchema;
use serde::Deserialize;

#[derive(JsonSchema, Deserialize)]
struct WeatherInput { city: String }

pub struct WeatherTool;

#[async_trait]
impl BaseTool for WeatherTool {
    fn name(&self) -> &str { "weather" }
    
    fn description(&self) -> &str {
        "查询城市天气。输入城市名称，返回天气信息。"
    }
    
    async fn run(&self, input: String) -> Result<String, ToolError> {
        let args: WeatherInput = serde_json::from_str(&input)?;
        Ok(format!("{}天气：晴，温度 25°C", args.city))
    }
    
    fn args_schema(&self) -> Option<serde_json::Value> {
        serde_json::to_value(schemars::schema_for!(WeatherInput)).ok()
    }
}

---

5. RAG - 检索增强生成

什么是 RAG？

RAG (Retrieval-Augmented Generation) 先从知识库检索相关文档，再让 LLM 基于检索内容生成答案。让 LLM 访问私有知识库、最新数据，无需重新训练模型。

完整 RAG 流程

use langchainrust::{
    Document, InMemoryVectorStore, MockEmbeddings,
    SimilarityRetriever, RetrieverTrait, RecursiveCharacterSplitter,
    TextSplitter, RetrievalQA, BaseChain,
};
use std::sync::Arc;

// 1. 准备文档
let docs = vec![
    Document::new("Rust 是一门系统编程语言..."),
    Document::new("Python 是一门脚本语言..."),
];

// 2. 分割文档
let splitter = RecursiveCharacterSplitter::new(200, 50);
let chunks = splitter.split_documents(&docs)?;

// 3. 创建检索器
let store = Arc::new(InMemoryVectorStore::new());
let embeddings = Arc::new(MockEmbeddings::new(128));
let retriever = SimilarityRetriever::new(store, embeddings);
retriever.add_documents(chunks).await?;

// 4. 创建 RetrievalQA
let qa_chain = RetrievalQA::new(llm, retriever, 3);

// 5. 执行问答
let result = qa_chain.invoke(HashMap::from([
    ("query".to_string(), Value::String("什么是 Rust？".to_string()))
])).await?;

文档分割配置建议

参数	推荐值	说明
chunk_size	200-500	每个 chunk 的最大字符数
overlap	50-100	相邻 chunk 的重叠字符数，保持上下文连续性

---

6. Prompts - 提示词模板

PromptTemplate（字符串模板）

使用 {variable} 占位符动态生成 Prompt：

use langchainrust::prompts::PromptTemplate;
use std::collections::HashMap;

// 创建模板
let template = PromptTemplate::new("请用{style}风格解释{topic}");

let vars = HashMap::from([
    ("style", "简洁"),
    ("topic", "Rust的所有权机制"),
]);

let prompt = template.format(&vars)?;
// 结果: "请用简洁风格解释Rust的所有权机制"

ChatPromptTemplate（多消息模板）

支持多条消息模板，包含 System、Human、AI 等不同角色：

use langchainrust::prompts::ChatPromptTemplate;
use langchainrust::schema::Message;

let template = ChatPromptTemplate::new(vec![
    Message::system("你是一个{role}，专精于{domain}。"),
    Message::human("你好，我是{name}。"),
    Message::human("{question}"),
]);

let vars = HashMap::from([
    ("role", "Rust 专家"),
    ("domain", "系统编程"),
    ("name", "张三"),
    ("question", "解释所有权机制"),
]);

let messages = template.format(&vars)?;

消息类型

消息类型	创建方法	用途
System	Message::system(content)	设定 AI 角色、行为规范
Human	Message::human(content)	用户输入、问题
AI	Message::ai(content)	AI 响应、历史记录
Tool	Message::tool(id, content)	工具返回结果

---

7. LLM - 语言模型接口

OpenAIConfig 配置

字段	类型	说明
api_key	String	OpenAI API 密钥
base_url	String	API 端点（支持代理）
model	String	模型名称（gpt-4/gpt-3.5-turbo）
streaming	bool	是否启用流式输出
temperature	Option	采样温度 (0.0-2.0)
max_tokens	Option	最大生成 token 数

基础对话

use langchainrust::{OpenAIChat, OpenAIConfig, BaseChatModel};
use langchainrust::schema::Message;

let config = OpenAIConfig {
    api_key: std::env::var("OPENAI_API_KEY")?,
    model: "gpt-4".to_string(),
    ..Default::default()
};

let llm = OpenAIChat::new(config);

let messages = vec![
    Message::system("你是一个友好的助手。"),
    Message::human("什么是 Rust？"),
];

let response = llm.chat(messages, None).await?;
println!("{}", response.content);

流式输出

use futures_util::StreamExt;

let config = OpenAIConfig { streaming: true, ..Default::default() };
let llm = OpenAIChat::new(config);

let mut stream = llm.stream_chat(messages, None).await?;

while let Some(chunk) = stream.next().await {
    if let Ok(token) = chunk {
        print!("{}", token);  // 打字机效果
    }
}

Function Calling

use langchainrust::{ToolDefinition, BaseChatModel};
use schemars::JsonSchema;
use serde::Deserialize;

#[derive(JsonSchema, Deserialize)]
struct CalculatorInput { expression: String }

let tool = ToolDefinition::from_type::<CalculatorInput>(
    "calculator", "计算数学表达式"
);

let llm_with_tools = llm.bind_tools(vec![tool]);

let response = llm_with_tools.chat(messages, None).await?;

if let Some(tool_calls) = &response.tool_calls {
    println!("工具: {}", tool_calls[0].function.name);
}

---

8. 最佳实践

01. Agent 选择

优先使用 FunctionCallingAgent（更可靠），本地模型用 ReActAgent。

02. 模型选择

Agent 推荐 gpt-4，简单对话用 gpt-3.5-turbo。

03. Memory 选择

长对话用 SummaryBufferMemory，短对话用 BufferMemory。

04. RAG 配置

chunk_size=200-500，overlap=50-100，top_k=3-10。

05. 流式输出

交互场景使用 stream_chat()，降低感知延迟。

06. 安全提示

API Key 使用环境变量，不要硬编码在代码中。

---

总结

LangChainRust 提供了构建 AI 应用的完整工具链：

模块	核心功能
Agents	智能决策、工具调用、多步骤任务执行
Chains	组件串联、管道处理、流程编排
Memory	对话历史管理、Token 消耗控制
Tools	外部函数调用、能力扩展
RAG	知识库问答、文档检索、向量存储
Prompts	动态模板构建、变量替换
LLM	统一接口、流式输出、Function Calling

如果你追求高性能、内存安全的 AI 应用，LangChainRust 是 Python 版本的最佳替代方案。

---

参考资料

• LangChainRust GitHub
• LangChain 官方文档
• Rust 官方网站

---

📌 原创声明：本文为原创内容，转载请注明出处。如有问题，欢迎评论区交流！