LangChain基础用法详解

LangChain基础用法详解

LangChain是一个强大的框架，用于开发由大语言模型（LLM）驱动的应用程序。它提供了丰富的工具和抽象，让开发者能够轻松构建复杂的AI应用。本文将详细介绍LangChain的核心概念和基础用法。

1. 安装与环境配置

首先，安装LangChain：

pip install langchain
pip install openai  # 以OpenAI为例

配置环境变量：

import os
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

2. 核心概念

LangChain有以下几个核心组件：

• Models：大语言模型（如GPT-4、Claude等）
• Prompts：提示词模板
• Chains：链式调用组件
• Memory：记忆组件
• Agents：智能代理

3. 基本模型调用

3.1 文本生成模型

from langchain.llms import OpenAI

# 创建模型实例
llm = OpenAI(temperature=0.7, model_name="gpt-3.5-turbo")

# 直接调用
response = llm("介绍一下Python编程语言")
print(response)

3.2 聊天模型

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage

chat = ChatOpenAI(temperature=0)

messages = [
    SystemMessage(content="你是一个Python编程专家"),
    HumanMessage(content="请解释什么是装饰器")
]

response = chat(messages)
print(response.content)

4. 提示词模板

4.1 基础模板

from langchain.prompts import PromptTemplate

template = """
请用{language}写一个{function}函数：
- 功能：{description}
- 输入参数：{inputs}
"""

prompt = PromptTemplate(
    input_variables=["language", "function", "description", "inputs"],
    template=template
)

# 格式化模板
formatted_prompt = prompt.format(
    language="Python",
    function="计算器",
    description="实现基本的加减乘除运算",
    inputs="两个数字和一个运算符"
)

print(formatted_prompt)

4.2 聊天模板

from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
from langchain.schema import SystemMessage

chat_template = ChatPromptTemplate.from_messages([
    SystemMessage(content="你是一个{role}专家"),
    HumanMessagePromptTemplate.from_template("请解释{topic}的概念")
])

messages = chat_template.format_messages(
    role="机器学习",
    topic="决策树"
)

5. 链（Chains）

5.1 简单链

from langchain.chains import LLMChain

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

# 执行链
result = chain.run(
    language="Python",
    function="排序",
    description="对列表进行排序",
    inputs="一个数字列表"
)
print(result)

5.2 顺序链

from langchain.chains import SimpleSequentialChain

# 第一个链：生成问题
chain1 = LLMChain(
    llm=llm,
    prompt=PromptTemplate(
        input_variables=["topic"],
        template="生成一个关于{topic}的问题"
    )
)

# 第二个链：回答问题
chain2 = LLMChain(
    llm=llm,
    prompt=PromptTemplate(
        input_variables=["question"],
        template="请回答这个问题：{question}"
    )
)

# 组合链
overall_chain = SimpleSequentialChain(
    chains=[chain1, chain2],
    verbose=True
)

result = overall_chain.run("人工智能")

6. 记忆组件

6.1 对话记忆

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

memory = ConversationBufferMemory()
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# 多轮对话
conversation.predict(input="你好，我叫张三")
conversation.predict(input="你还记得我叫什么吗？")

6.2 其他记忆类型

from langchain.memory import ConversationSummaryMemory, ConversationBufferWindowMemory

# 摘要记忆
summary_memory = ConversationSummaryMemory(llm=llm)

# 窗口记忆（只保留最近N轮对话）
window_memory = ConversationBufferWindowMemory(k=3)

7. 文档加载与处理

7.1 加载文档

from langchain.document_loaders import TextLoader, PDFLoader, WebBaseLoader

# 加载文本文件
text_loader = TextLoader("example.txt")
documents = text_loader.load()

# 加载PDF文件（需要安装PyPDF2）
# pdf_loader = PDFLoader("document.pdf")

# 加载网页内容
web_loader = WebBaseLoader("https://example.com")

7.2 文本分割

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len
)

chunks = text_splitter.split_documents(documents)

8. 向量存储与检索

8.1 创建向量存储

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

8.2 检索问答

from langchain.chains import RetrievalQA

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

response = qa_chain.run("文档中提到了什么重要概念？")

9. 代理（Agents）

9.1 创建代理

from langchain.agents import create_react_agent, Tool
from langchain.agents import AgentExecutor
from langchain.tools import tool

@tool
def calculate(expression: str) -> str:
    """执行数学计算"""
    return str(eval(expression))

tools = [calculate]

agent = create_react_agent(
    llm=llm,
    tools=tools,
    prompt=...  # 需要合适的提示词模板
)

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True
)

result = agent_executor.run("计算 23 * 45 的结果")

9.2 预构建代理

from langchain.agents import load_tools, initialize_agent, AgentType

tools = load_tools(["serpapi", "llm-math"], llm=llm)

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

response = agent.run("搜索最新的AI新闻并总结")

10. 实践示例：完整的问答系统

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, SimpleSequentialChain
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA

class SimpleQA:
    def __init__(self, llm_api_key=None):
        self.llm = OpenAI(temperature=0)
        self.memory = ConversationBufferMemory()
        
    def load_document(self, file_path):
        loader = TextLoader(file_path)
        documents = loader.load()
        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
        texts = text_splitter.split_documents(documents)
        embeddings = OpenAIEmbeddings()
        self.vectorstore = FAISS.from_documents(texts, embeddings)
        self.qa_chain = RetrievalQA.from_chain_type(
            llm=self.llm,
            chain_type="stuff",
            retriever=self.vectorstore.as_retriever()
        )
    
    def ask(self, question):
        return self.qa_chain.run(question)

# 使用示例
qa_system = SimpleQA()
qa_system.load_document("knowledge_base.txt")
answer = qa_system.ask("这个文档的主要内容是什么？")
print(answer)

11. 最佳实践

1. 提示词设计：清晰的提示词能显著提升模型输出质量
2. 错误处理：添加try-catch处理API调用异常
3. 速率限制：注意API调用频率限制
4. 缓存策略：对重复查询使用缓存
5. 日志记录：记录关键操作和错误信息

结语

LangChain提供了构建LLM应用所需的所有基础组件。从简单的模型调用到复杂的多步骤工作流，它都能很好地支持。掌握这些基础用法后，你可以进一步探索更高级的特性，如流式处理、回调机制、自定义工具等。

记住，好的实践是循序渐进地学习和使用，从简单的链开始，逐步增加复杂性。随着你对LangChain的理解加深，你将能构建出更加智能和强大的AI应用。