LangChain 入门教程：从零开始构建AI应用

LangChain 是一个用于构建基于大型语言模型（LLM）的应用程序的开源框架。它提供了构建 LLM 应用程序所需的基本抽象，包括提示模板、链式调用、代理、记忆、工具和检索等功能。

一、LangChain 简介

什么是 LangChain？

LangChain 是一个开源框架，旨在帮助开发者轻松构建基于大型语言模型（LLM）的应用程序。它提供了：

• 提示模板（Prompt Templates）：动态生成提示
• 链式调用（Chains）：将多个步骤组合在一起
• 代理（Agents）：自主决策和执行任务
• 记忆（Memory）：保持对话状态
• 工具（Tools）：连接外部服务和API
• 检索（Retrieval）：集成向量数据库和搜索引擎

主要特性

• 🔧 模块化设计：易于扩展和自定义
• 🤖 多LLM支持：兼容 OpenAI、Anthropic、Hugging Face 等
• 📊 生产就绪：适合企业级应用开发
• 🌐 丰富生态：大量预构建组件和工具

二、环境准备

1. 安装 LangChain

pip install langchain

2. 安装 LLM 集成

# OpenAI 集成
pip install langchain-openai

# Anthropic 集成
pip install langchain-anthropic

# Hugging Face 集成
pip install langchain-huggingface

3. 环境变量配置

import os
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-api-key"

三、基础使用示例

1. 简单聊天机器人

from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# 创建 LLM 实例
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)

# 创建提示模板
prompt = PromptTemplate(
    input_variables=["user_input"],
    template="用户：{user_input}\n\n助手："
)

# 创建链式调用
chain = LLMChain(llm=llm, prompt=prompt)

# 使用聊天机器人
response = chain.invoke({"user_input": "你好，你能介绍一下自己吗？"})
print(response["result"])

2. 文本摘要

from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

llm = ChatOpenAI(model="gpt-3.5-turbo")

# 文本摘要提示模板
summary_prompt = PromptTemplate(
    input_variables=["text"],
    template="""
请为以下文本生成一个简洁的摘要：
{text}

摘要：
"""
)

summary_chain = LLMChain(llm=llm, prompt=summary_prompt)

# 示例文本
long_text = """
随着人工智能技术的快速发展，大型语言模型（LLMs）已经在多个领域展现出强大的能力。
这些模型不仅能够理解和生成自然语言，还能进行复杂的推理和问题解决。
LangChain 作为一个开源框架，为开发者提供了构建基于 LLM 应用程序所需的各种工具和抽象。
通过 LangChain，开发者可以轻松地将 LLM 集成到自己的应用中，实现各种智能化功能。
"""

summary = summary_chain.invoke({"text": long_text})
print("摘要：", summary["result"])

四、高级功能

1. 使用 LangChain Agents

from langchain_openai import ChatOpenAI
from langchain.agents import AgentType, initialize_agent
from langchain.agents import Tool
from langchain_community.utilities import WikipediaAPIWrapper

# 创建 LLM
llm = ChatOpenAI(model="gpt-3.5-turbo")

# 创建工具
tools = [
    Tool(
        name="Wikipedia Search",
        func=WikipediaAPIWrapper().run,
        description="搜索维基百科内容"
    )
]

# 初始化代理
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    memory=True
)

# 使用代理
agent.run("请告诉我关于人工智能的最新发展")

2. 向量数据库集成

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.embeddings import Embeddings
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationalRetrievalChain
from langchain_community.vectorstores import FAISS as CommunityFAISS

# 创建 LLM 和嵌入模型
llm = ChatOpenAI(model="gpt-3.5-turbo")
embeddings = OpenAIEmbeddings()

# 创建示例文档
documents = [
    "LangChain 是一个用于构建基于大型语言模型的应用程序的开源框架。",
    "它提供了构建 LLM 应用程序所需的基本抽象，包括提示模板、链式调用、代理等。",
    "LangChain 支持多种 LLM 提供商，包括 OpenAI、Anthropic、Hugging Face 等。"
]

# 创建向量数据库
vectorstore = CommunityFAISS.from_texts(documents, embeddings)

# 创建检索器
retriever = vectorstore.as_retriever()

# 创建对话检索链
qa_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=retriever
)

# 使用对话检索
result = qa_chain({"question": "LangChain 是什么？"})
print(result["answer"])

3. 记忆功能

from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain

# 创建 LLM
llm = ChatOpenAI(model="gpt-3.5-turbo")

# 创建记忆
memory = ConversationBufferMemory(memory_key="chat_history")

# 创建对话链
conversation_chain = ConversationalRetrievalChain(
    llm=llm,
    memory=memory,
    # retriever=retriever  # 如果需要检索可以加上
)

# 第一次对话
response1 = conversation_chain.invoke({"question": "你叫什么名字？"})
print("LLM:", response1["answer"])

# 第二次对话（LLM 会记住之前的对话）
response2 = conversation_chain.invoke({"question": "你之前告诉我什么了？"})
print("LLM:", response2["answer"])

五、实际应用案例

1. 客服聊天机器人

from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.memory import ConversationBufferMemory

class CustomerServiceBot:
    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.3)
        self.memory = ConversationBufferMemory(memory_key="chat_history")

        # 客服专用提示模板
        self.customer_service_prompt = PromptTemplate(
            input_variables=["chat_history", "user_input"],
            template="""
你是一个专业的客服助手，请根据以下对话历史和用户最新输入来回答问题。
请保持友好、专业的语气，提供准确的信息。

对话历史：
{chat_history}

用户：{user_input}

客服：
"""
        )

        self.chain = LLMChain(llm=self.llm, prompt=self.customer_service_prompt)

    def get_response(self, user_input):
        # 获取当前对话状态
        chat_history = self.memory.load_memory_variables({})["chat_history"]

        # 生成响应
        response = self.chain.invoke({
            "chat_history": chat_history,
            "user_input": user_input
        })

        # 更新记忆
        self.memory.save_context(
            {"input": user_input},
            {"output": response["result"]}
        )

        return response["result"]

# 使用客服机器人
bot = CustomerServiceBot()
print(bot.get_response("你好，我想查询我的订单状态"))
print(bot.get_response("我的订单号是12345"))

2. 智能文档分析器

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.text_splitter import CharacterTextSplitter
from langchain.memory import ConversationBufferMemory
from langchain.chains.conversational_rag import ConversationalRetrievalChain
import os

class DocumentAnalyzer:
    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-3.5-turbo")
        self.embeddings = OpenAIEmbeddings()
        self.memory = ConversationBufferMemory(memory_key="chat_history")

        # 创建文本分割器
        self.text_splitter = CharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=0
        )

        # 创建向量数据库
        self.vectorstore = FAISS.from_texts([], self.embeddings)

    def load_document(self, file_path):
        """加载文档并分割成文本块"""
        with open(file_path, 'r', encoding='utf-8') as f:
            text = f.read()

        # 分割文本
        texts = self.text_splitter.split_text(text)

        # 添加到向量数据库
        self.vectorstore = FAISS.from_texts(texts, self.embeddings)

        print(f"已加载文档，共 {len(texts)} 个文本块")

    def query_document(self, question):
        """查询文档"""
        # 创建检索器
        retriever = self.vectorstore.as_retriever()

        # 创建对话检索链
        chain = ConversationalRetrievalChain(
            llm=self.llm,
            retriever=retriever,
            memory=self.memory
        )

        # 获取回答
        result = chain.invoke({"question": question})
        return result["answer"]

# 使用文档分析器
analyzer = DocumentAnalyzer()
# analyzer.load_document("your_document.txt")
# print(analyzer.query_document("文档中提到了哪些关键技术？"))

六、最佳实践

1. 性能优化

from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import time

# 使用缓存
llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    cache=True,
    temperature=0.3
)

# 批量处理
def batch_process(inputs):
    chain = LLMChain(llm=llm)
    results = []
    for input_text in inputs:
        start_time = time.time()
        result = chain.invoke({"input": input_text})
        end_time = time.time()
        results.append({
            "input": input_text,
            "output": result["result"],
            "processing_time": end_time - start_time
        })
    return results

2. 错误处理

from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
import logging

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class RobustLLMChain:
    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
        self.chain = LLMChain(llm=self.llm)

    def safe_invoke(self, input_data, max_retries=3):
        """安全调用链式调用"""
        for attempt in range(max_retries):
            try:
                result = self.chain.invoke(input_data)
                logger.info(f"调用成功，尝试次数: {attempt + 1}")
                return result
            except Exception as e:
                logger.warning(f"调用失败，尝试次数: {attempt + 1}, 错误: {e}")
                if attempt == max_retries - 1:
                    logger.error("达到最大重试次数，调用失败")
                    raise
                # 可以添加延迟逻辑
                time.sleep(1)

3. 监控和调试

from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain.callbacks import get_openai_callback

# 设置回调函数
def log_callback(data):
    print(f"LLM 调用: {data}")

# 创建 LLM 和链式调用
llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    callbacks=[get_openai_callback(log_callback)]
)
chain = LLMChain(llm=llm)

# 调用时会输出详细信息
result = chain.invoke({"input": "你好，世界！"})

七、常见问题和解决方案

1. API 密钥错误

# 错误处理
try:
    llm = ChatOpenAI(model="gpt-3.5-turbo")
except Exception as e:
    print(f"API 密钥错误: {e}")
    print("请检查环境变量 OPENAI_API_KEY 是否正确设置")

2. 速率限制

from langchain_openai import ChatOpenAI
import time

# 添加延迟
def rate_limited_chain(llm, delay=1):
    def wrapper(chain):
        def invoke(inputs):
            time.sleep(delay)  # 添加延迟
            return chain(inputs)
        return invoke
    return wrapper

# 使用
llm = ChatOpenAI(model="gpt-3.5-turbo")
chain = LLMChain(llm=llm)
rate_limited_chain = rate_limited_chain(llm, delay=2)

3. 提示词优化

# A/B 测试不同提示词
prompts = [
    "请回答这个问题：{question}",
    "作为专家，请回答：{question}",
    "请详细解释：{question}"
]

def test_prompts(question, prompts, llm):
    results = []
    for prompt in prompts:
        chain = LLMChain(llm=llm, prompt=prompt)
        result = chain.invoke({"question": question})
        results.append({
            "prompt": prompt,
            "response": result["result"]
        })
    return results

八、未来发展趋势

1. 更智能的代理

• 自主决策能力
• 多智能体协作
• 长期记忆和规划

2. 更好的集成

• 与现有系统的深度集成
• 多模态支持
• 边缘计算部署

3. 安全和隐私

• 模型微调和个性化
• 隐私保护技术
• 合规性框架

九、资源推荐

官方资源

• LangChain 官网
• LangChain 文档
• GitHub 仓库

学习资源

• LangChain 教程和示例
• 社区论坛和 Discord
• 相关技术博客和文章

工具和库

• LangSmith（LangChain 的开发和监控工具）
• LangChain Expressions（声明式编程接口）
• LangChain Hub（社区共享组件）

结语

LangChain 为构建基于大型语言模型的应用程序提供了强大的工具和框架。通过本文的教程，你已经了解了 LangChain 的基础知识、高级功能、实际应用案例以及最佳实践。

记住，学习 LangChain 还需要不断实践和探索。建议你：

1. 从简单的示例开始
2. 逐步尝试更复杂的功能
3. 参与社区交流和分享
4. 关注 LangChain 的最新发展

随着 AI 技术的不断发展，LangChain 将继续演进，为开发者提供更好的工具和体验。让我们一起期待 LangChain 未来的发展！