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

一个受 LangChain 启发的 Rust 实现，提供 LLM、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 及兼容接口（如 Qwen、Azure、国内代理），支持流式和非流式输出：

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

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);

2. 向量数据库集成

提供两种向量数据库支持，覆盖开发测试和生产环境：

InMemoryVectorStore - 开发测试首选

内存向量存储，零配置，适合快速原型开发：

use langchainrust::{
    Document, InMemoryVectorStore, OpenAIEmbeddings,
    SimilarityRetriever, RetrieverTrait,
};
use std::sync::Arc;

// 创建 Embeddings（真实 AI 向量生成）
let embeddings = Arc::new(OpenAIEmbeddings::new(
    OpenAIEmbeddingsConfig::default()
));

// 创建内存向量库
let store = Arc::new(InMemoryVectorStore::new());
let retriever = SimilarityRetriever::new(store.clone(), embeddings);

// 添加文档（自动生成向量）
let docs = vec![
    Document::new("Rust 是一门系统编程语言。"),
    Document::new("向量数据库用于存储和检索向量。"),
];
retriever.add_documents(docs).await?;

// 语义搜索
let results = retriever.retrieve_with_scores("什么是向量存储？", 3).await?;

QdrantVectorStore - 生产级方案

高性能分布式向量数据库，支持百万级向量：

use langchainrust::vector_stores::{
    QdrantVectorStore, QdrantConfig, QdrantDistance
};

let config = QdrantConfig::new("http://localhost:6334", "knowledge_base")
    .with_vector_size(1536)
    .with_distance(QdrantDistance::Cosine);

let store = Arc::new(QdrantVectorStore::new(config).await?);
let retriever = SimilarityRetriever::new(store.clone(), embeddings);

// 使用方式与 InMemoryVectorStore 完全相同
retriever.add_documents(docs).await?;
let results = retriever.retrieve("查询问题", 5).await?;

向量数据库对比

特性	InMemoryVectorStore	QdrantVectorStore
适用场景	开发测试	生产环境
持久化	内存	磁盘/云存储
容量	受内存限制	百万级+
性能	极快	快
分布式	不支持	支持
配置	零配置	需部署服务

OpenAI Embeddings

支持 OpenAI 的文本嵌入模型，自动生成高质量向量：

模型	维度	特点
text-embedding-ada-002	1536	性价比最优
text-embedding-3-small	1536	新一代，性能更好
text-embedding-3-large	3072	最高质量

3. RAG 检索增强生成

完整的 RAG 流程：索引 -> 检索 -> 生成

use langchainrust::{
    Document, InMemoryVectorStore, OpenAIEmbeddings,
    OpenAIChat, OpenAIConfig, SimilarityRetriever,
    RetrieverTrait, BaseChatModel,
};
use langchainrust::schema::Message;
use std::sync::Arc;

async fn rag_example() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 初始化组件
    let embeddings = Arc::new(OpenAIEmbeddings::new(
        OpenAIEmbeddingsConfig::default()
    ));
    let llm = OpenAIChat::new(OpenAIConfig::default());
    let store = Arc::new(InMemoryVectorStore::new());
    let retriever = SimilarityRetriever::new(store.clone(), embeddings);

    // 2. 构建知识库
    let knowledge = vec![
        Document::new("Rust 由 Mozilla 研发，2015 年发布 1.0。"),
        Document::new("Rust 的所有权系统确保内存安全。"),
        Document::new("Cargo 是 Rust 的包管理器。"),
    ];
    retriever.add_documents(knowledge).await?;

    // 3. 检索相关文档
    let question = "Rust 什么时候发布的？";
    let relevant = retriever.retrieve_with_scores(question, 3).await?;

    // 4. 构建上下文
    let context = relevant.iter()
        .map(|r| r.document.content.as_str())
        .collect::<Vec<_>>()
        .join("\n");

    // 5. LLM 生成答案
    let messages = vec![
        Message::system("根据上下文回答问题。"),
        Message::human(&format!("上下文:\n{}\n\n问题: {}", context, question)),
    ];
    let response = llm.chat(messages, None).await?;

    println!("{}", response.content);
    // 输出: Rust 于 2015 年发布 1.0 版本。

    Ok(())
}

向量自动生成机制

add_documents() 内部实现批量向量生成：

pub async fn add_documents(&self, documents: Vec<Document>) -> Result<()> {
    // 1. 提取文本
    let texts: Vec<&str> = documents.iter()
        .map(|d| d.content.as_str())
        .collect();

    // 2. 批量生成向量（一次 API 调用）
    let embeddings = self.embeddings.embed_documents(&texts).await?;

    // 3. 存储
    self.store.add_documents(documents, embeddings).await?;

    Ok(())
}

批量生成优化：一次 API 调用处理多个文档，节省时间和成本。

4. Agent 与工具调用

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

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 抓取和解析

5. 提示词模板

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

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}"),
]);

6. 对话记忆

三种记忆管理策略：

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);

7. Chain 工作流

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

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?;

---

安装使用

快速安装

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

# 启用 Qdrant 向量数据库
# langchainrust = { version = "0.2.1", features = ["qdrant-integration"] }

环境配置

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

启动 Qdrant（可选）

docker run -p 6333:6333 -p 6334:6334 \
    -v $(pwd)/qdrant_storage:/qdrant/storage \
    qdrant/qdrant

---

项目结构

src/
├── core/                # 核心抽象
│   ├── language_models/ # BaseChatModel trait
│   ├── runnables/       # Runnable trait (LCEL)
│   └── tools/           # BaseTool trait
├── language_models/     # LLM 实现
│   └── openai/          # OpenAI 客户端
├── embeddings/          # 文本嵌入
│   ├── openai.rs        # OpenAI Embeddings
│   └── mock.rs          # Mock Embeddings
├── vector_stores/       # 向量数据库
│   ├── memory.rs        # InMemoryVectorStore
│   ├── qdrant.rs        # QdrantVectorStore
│   └── mod.rs           # VectorStore trait
├── retrieval/           # RAG 组件
│   ├── retriever.rs     # SimilarityRetriever
│   ├── splitter.rs      # 文档分割器
│   └── loaders/         # PDF/CSV 加载器
├── agents/              # Agent 框架
│   └── react/           # ReActAgent
├── prompts/             # 提示词模板
├── memory/              # 记忆管理
├── chains/              # Chain 工作流
├── tools/               # 内置工具
└── schema/              # 数据结构（Message 等）

---

测试

运行测试

# 运行所有测试
cargo test

# 显示测试输出
cargo test -- --nocapture

# RAG 测试（InMemory）
cargo test test_rag_inmemory_full_pipeline -- --nocapture --include-ignored

# RAG 测试（Qdrant）
cargo test test_rag_qdrant_full_pipeline --features qdrant-integration -- --nocapture --include-ignored

3. 错误处理

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

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

---

---

资源链接

• GitHub 仓库: https://github.com/atliliw/langchainrust
• crates.io: https://crates.io/crates/langchainrust
• API 文档: https://docs.rs/langchainrust

---

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