用 Rust 构建 LLM 应用的高性能框架

langchainrust：用 Rust 构建 LLM 应用的高性能框架

一个受 LangChain 启发的 Rust 实现，提供 Agent、Chain、Memory、RAG 等核心组件，完全异步、类型安全、零成本抽象。

🎯 项目简介

随着大语言模型（LLM）的爆发式发展，Python 版的 LangChain 已成为构建 AI 应用的事实标准。但对于追求高性能、类型安全和内存安全的开发者来说，Rust 才是更合适的选择。

langchainrust 是一个用 Rust 实现的 LangChain 框架，保留了 LangChain 的核心设计理念，同时充分发挥 Rust 的优势：

🚀 完全异步 - 基于 Tokio 的 async/await，高并发低延迟
🔒 类型安全 - 编译期捕获错误，告别运行时崩溃
📦 零成本抽象 - 高性能设计，无额外运行开销
🔌 易于扩展 - 清晰的 trait 设计，方便自定义组件

GitHub 地址：https://github.com/atliliw/langchainrust

✨ 核心特性

1. LLM 集成（OpenAI 兼容）

支持 OpenAI API 及兼容接口（如 Azure、国内代理），支持流式和非流式输出：

rust 复制代码

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = OpenAIConfig {
        api_key: std::env::var("OPENAI_API_KEY")?,
        base_url: "https://api.openai.com/v1".to_string(),
        model: "gpt-3.5-turbo".to_string(),
        streaming: false,
        temperature: Some(0.7),
        max_tokens: Some(500),
        ..Default::default()
    };
    
    let llm = OpenAIChat::new(config);
    
    let messages = vec![
        Message::system("你是一个 Rust 专家。"),
        Message::human("解释 Rust 的所有权机制。"),
    ];
    
    let response = llm.chat(messages, None).await?;
    println!("{}", response.content);
    
    Ok(())
}

2. Agent 与工具调用

实现 ReActAgent（Reasoning + Acting），支持工具调用、多步推理、错误重试：

rust 复制代码

use langchainrust::{
    ReActAgent, AgentExecutor, BaseAgent, BaseTool,
    Calculator, DateTimeTool, SimpleMathTool,
};
use std::sync::Arc;

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

// 创建 Agent
let agent = ReActAgent::new(llm, tools.clone(), None);
let executor = AgentExecutor::new(Arc::new(agent) as Arc<dyn BaseAgent>, tools)
    .with_max_iterations(5);

// 执行任务
let result = executor.invoke("计算 37 + 48，然后告诉我今天是星期几".to_string()).await?;
println!("结果: {}", result);

内置工具：

Calculator - 数学计算
DateTimeTool - 日期时间查询
SimpleMathTool - 基础数学运算（sin, sqrt, factorial 等）
URLFetch - URL 抓取和解析

3. 提示词模板

支持字符串模板和聊天模板，变量替换、模板组合：

rust 复制代码

use langchainrust::prompts::{PromptTemplate, ChatPromptTemplate};
use langchainrust::schema::Message;
use std::collections::HashMap;

// 字符串模板
let template = PromptTemplate::new("你好，{name}！今天是{day}。");
let mut vars = HashMap::new();
vars.insert("name", "开发者");
vars.insert("day", "周一");
let prompt = template.format(&vars)?;

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

4. 对话记忆

三种记忆管理策略：

rust 复制代码

use langchainrust::{ChatMessageHistory, ConversationBufferMemory};

// 简单历史记录
let mut history = ChatMessageHistory::new();
history.add_message(Message::human("你好！"));
history.add_message(Message::ai("你好！很高兴见到你！"));

// 缓冲记忆（保留所有历史）
let memory = ConversationBufferMemory::new();

// 窗口记忆（保留最近 K 条）
let window_memory = ConversationBufferWindowMemory::new(5);

5. Chain 工作流

支持 LLMChain（单步）和 SequentialChain（多步流水线）：

rust 复制代码

use langchainrust::{LLMChain, SequentialChain, BaseChain};
use std::sync::Arc;
use std::collections::HashMap;
use serde_json::Value;

// 单步 Chain
let chain1 = LLMChain::new(llm1, "分析以下主题: {topic}");

// 多步顺序 Chain（流水线）
let chain2 = LLMChain::new(llm2, "根据分析生成总结: {analysis}");

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

// 执行
let mut inputs = HashMap::new();
inputs.insert("topic".to_string(), Value::String("2024年AI发展".to_string()));
let results = pipeline.invoke(inputs).await?;

6. RAG 检索增强生成

完整的 RAG 组件：文档分割、向量存储、语义检索：

rust 复制代码

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

// 创建文档
let docs = vec![Document::new("Rust 是一门系统编程语言...")];

// 文档分割
let splitter = RecursiveCharacterSplitter::new(200, 50);
let chunks = splitter.split_document(&docs[0]);

// 创建检索器
let store = Arc::new(InMemoryVectorStore::new());
let embeddings = Arc::new(MockEmbeddings::new(128));
let retriever = SimilarityRetriever::new(store.clone(), embeddings);

// 索引文档
retriever.add_documents(chunks).await?;

// 语义检索
let relevant_docs = retriever.retrieve("什么是 Rust？", 3).await?;

📦 安装使用

快速安装

在 Cargo.toml 中添加：

toml 复制代码

[dependencies]
langchainrust = "0.2"
tokio = { version = "1.0", features = ["full"] }

环境配置

bash 复制代码

export OPENAI_API_KEY="your-api-key"
export OPENAI_BASE_URL="https://api.openai.com/v1"  # 可选：支持自定义端点

📁 项目结构

复制代码

src/
├── core/                # 核心抽象
│   ├── language_models/ # BaseChatModel trait
│   ├── runnables/       # Runnable trait
│   └── tools/           # BaseTool trait
├── language_models/     # LLM 实现
│   └── openai/          # OpenAI 客户端
├── agents/              # Agent 框架
│   └── react/           # ReActAgent
├── prompts/             # 提示词模板
├── memory/              # 记忆管理
├── chains/              # Chain 工作流
├── retrieval/           # RAG 组件
├── embeddings/          # 文本嵌入
├── vector_stores/       # 向量存储
├── tools/               # 内置工具
└── schema/              # 数据结构（Message 等）

复制代码

### 示例代码

查看 `examples/` 目录：

- **基础示例**：`hello_llm`, `streaming`, `prompt_template`, `tools`
- **中级示例**：`agent_with_tools`, `memory_conversation`, `chain_pipeline`
- **高级示例**：`rag_demo`, `multi_tool_agent`, `full_pipeline`

运行示例：

```bash
# 无需 API Key
cargo run --example prompt_template
cargo run --example tools

# 需要 API Key
export OPENAI_API_KEY="your-key"
cargo run --example hello_llm
cargo run --example agent_with_tools

1. Trait 驱动设计

所有核心组件基于 trait，方便扩展：

rust 复制代码

// 自定义 LLM
impl BaseChatModel for MyLLM {
    async fn chat(&self, messages: Vec<Message>, ...) -> Result<Message, Error>;
}

// 自定义工具
impl BaseTool for MyTool {
    fn name(&self) -> &str;
    fn run(&self, input: &str) -> Result<String, Error>;
}

// 自定义 Chain
impl BaseChain for MyChain {
    async fn invoke(&self, inputs: HashMap<String, Value>) -> Result<...>;
}

2. 异步优先

所有 I/O 操作都是异步，充分利用 Tokio：

rust 复制代码

// 流式输出
let stream = llm.stream(messages).await?;
while let Some(token) = stream.next().await {
    print!("{}", token?);
}

// 并发检索
let results = futures::future::join_all(
    retrievers.map(|r| r.retrieve(query, 5))
).await;

3. 错误处理

使用 Result<T, Box<dyn Error>> 统一错误传播：

rust 复制代码

fn process() -> Result<(), Box<dyn std::error::Error>> {
    let response = llm.chat(messages, None).await?;
    let result = agent.invoke(query).await?;
    Ok(())
}

📊 性能对比

指标	Python LangChain	langchainrust
类型安全	❌ 运行时错误	✅ 编译期检查
并发性能	有限（GIL）	✅ 真正并行
内存安全	❌ 可能崩溃	✅ 编译保证
部署体积	大（Python 环境）	小（单一二进制）
启动速度	秒级	毫秒级

🚀 Roadmap

当前版本 0.2.0 已实现：

✅ OpenAI 集成（流式 + 非流式）
✅ ReActAgent + 工具调用
✅ PromptTemplate + ChatPromptTemplate
✅ Memory（Buffer、Window）
✅ Chain（LLMChain、SequentialChain）
✅ RAG（Splitter、VectorStore、Retriever）
✅ 内置工具（Calculator、DateTime、Math、URLFetch）

未来规划：

🔜 更多 LLM 支持（Claude、Gemini、本地模型）
🔜 结构化输出（JSON Schema）
🔜 更多向量数据库集成
🔜 多模态支持

📄 许可证

双许可证：MIT 或 Apache-2.0，任选其一。

📖 资源链接

GitHub 仓库: https://github.com/atliliw/langchainrust
crates.io: https://crates.io/crates/langchainrust
API 文档: https://docs.rs/langchainrust
示例代码 : examples/ 目录

langchainrust 让 Rust 开发者也能轻松构建 LLM 应用，享受高性能和安全性，欢迎试用和反馈！

如果觉得项目有用，欢迎在 GitHub 给个 ⭐️ Star！