LangChain

概述

LangChain是一个基于大语言模型用于构建端到端语言模型应用的框架，它提供了一系列工具、套件和接口，让开发者使用语言模型来实现各种复杂的任务，如文本到图像的生成、文档问答、聊天机器人等。

LangChain简化了LLM应用程序生命周期的各个阶段：

开发阶段：使用LangChain的开源构建块和组件构建应用程序，利用第三方集成和模板快速启动。

生产化阶段：使用LangSmith检查、监控和评估您的链，从而可以自信地持续优化和部署。

部署阶段：使用LangServe将任何链转化为API。

参考文档：https://python.langchain.com

六大组件

LangChain具有六大组件,它们是LangChain的基石，它们相互协作，形成一个强大而灵活的系统。

模型（Models）：包含各大语言模型的LangChain接口和调用细节，以及输出解析机制。

提示模板（Prompts）：使提示工程流线化，进一步激发大语言模型的潜力。

数据检索（Indexes）：构建并操作文档的方法，接受用户的查询并返回最相关的文档，轻松搭建本地知识库。

记忆（Memory）：通过短时记忆和长时记忆，在对话过程中存储和检索数据，让ChatBot记住你。

链（Chains）：LangChain中的核心机制，以特定方式封装各种功能，并通过一系列的组合，自动而灵活地完成任务。

代理（Agents）：另一个LangChain中的核心机制，通过“代理”让大模型自主调用外部工具和内部工具，使智能Agent成为可能。

表格快速预览

开源库组成

LangChain框架由以下开源库组成：

langchain-core ：基础抽象和LangChain表达式语言

langchain-community ：第三方集成。合作伙伴包（如langchain-openai、langchain-anthropic等），一些集成已经进一步拆分为自己的轻量级包，只依赖于langchain-core

langchain ：构成应用程序认知架构的链、代理和检索策略

langgraph：通过将步骤建模为图中的边和节点，使用 LLMs 构建健壮且有状态的多参与者应用程序

langserve：将 LangChain 链部署为 REST API

LangSmith：一个开发者平台，可让您调试、测试、评估和监控LLM应用程序，并与LangChain无缝集成

LangChain基本使用

构建一个 LangChain应用程序来熟悉该框架。

安装LangChain

安装指定版本的LangChain，这里安装截止目前的最新版本

pip install langchain==0.1.7

执行安装LangChain命令后，会自动安装以下相关组件

Installing collected packages: langsmith, langchain-core, langchain-text-splitters, langchain-community, langchain

更新LangChain

pip install --upgrade langchain

克隆LangChain存储库从源代码安装

pip install -e

安装LangChain时包括常用的开源LLM（大语言模型） 库

pip install langchain[llms]

配置环境变量

安装第三方集成库，以使用OpenAI

pip install langchain langchain_openai

设置OpenAI环境变量

import os

os.environ["OPENAI_BASE_URL"] = "https://xxx.com/v1"
os.environ["OPENAI_API_KEY"] = "sk-fDqouTlU62yjkBhF46284543Dc8f42438a9529Df74B4Ce65"

基本使用

# 初始化模型
from langchain_openai import ChatOpenAI

llm = ChatOpenAI()

# 安装并初始化选择的LLM，就可以尝试使用它
llm.invoke(" LangSmith 是什么?")

AIMessage(content='LangSmith是一个虚构的名字，没有具体的定义或含义。它可能是一个人的名字、一个公司的名称或者一种产品的品牌。', response_metadata={
   
   'token_usage': {
   
   'completion_tokens': 44, 'prompt_tokens': 14, 'total_tokens': 58}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-f39ca76e-06ef-4815-ba7e-4a4924ef8e48-0')

使用提示模板

使用提示模板来指导其响应。 提示模板将原始用户输入转换为更好的 LLM 输入

# 初始化模型
from langchain_openai import ChatOpenAI

llm = ChatOpenAI()

# 创建提示模板
from langchain_core.prompts import ChatPromptTemplate
prompt = ChatPromptTemplate.from_messages([
    ("system", "您是世界级的技术文档编写者。"),
    ("user", "{input}")
])

# 组合成一个简单的 LLM 链
chain = prompt | llm 

# 使用LLM链
chain.invoke({
   
   "input": "Langsmith 如何帮助进行测试?"})

虽然它依然不知道答案，但对于技术作者来说，它使用了更恰当的语气给予回应。

AIMessage(content='Langsmith 可以帮助测试团队进行测试的文档编写工作。作为一名世界级的技术文档编写者，我可以为您提供以下帮助：\n\n1. 编写测试计划：根据项目需求，我可以帮助您编写详细的测试计划，包括测试目标、测试范围、测试资源、测试策略等内容。\n\n2. 编写测试用例：我可以帮助您编写全面的测试用例，覆盖各种功能、场景和边界条件。测试用例将详细描述每个测试步骤、预期结果和实际结果。\n\n3. 编写测试报告：在测试完成后，我可以帮助您编写清晰、详细的测试报告，包括测试执行情况、发现的缺陷、测试总结等内容。\n\n4. 优化测试文档：如果您已经有测试文档，但希望对其进行优化，使其更加规范、易读、易理解，我也可以提供帮助。\n\n无论您需要哪方面的帮助，我都可以根据您的具体需求提供定制化的服务。请告诉我您的具体要求，我将尽力满足您的需求。', response_metadata={
   
   'token_usage': {
   
   'completion_tokens': 355, 'prompt_tokens': 39, 'total_tokens': 394}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-b2ed1dbe-b57e-4472-ab19-61536a238c8d-0')

使用输出解析器

添加一个简单的输出解析器，将聊天消息转换为字符串。

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 初始化模型
llm = ChatOpenAI()

# 创建提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "您是世界级的技术文档编写者。"),
    ("user", "{input}")
])

# 使用输出解析器
output_parser = StrOutputParser()

# 将其添加到上一个链中
chain = prompt | llm | output_parser

# 调用它并提出同样的问题。答案是一个字符串，而不是ChatMessage
chain.invoke({
   
   "input": "Langsmith 如何帮助进行测试?"})

'Langsmith 可以帮助测试团队进行测试的文档编写工作。作为一名世界级的技术文档编写者，我可以为您提供以下帮助：\n\n1. 编写测试计划：根据项目需求，我可以帮助您编写详细的测试计划，包括测试目标、测试范围、测试资源、测试策略等内容。\n\n2. 编写测试用例：我可以帮助您编写全面的测试用例，覆盖各种功能、场景和边界条件。测试用例将详细描述每个测试步骤、预期结果和实际结果。\n\n3. 编写测试报告：在测试完成后，我可以帮助您编写清晰、详细的测试报告，包括测试执行情况、发现的缺陷、测试总结等内容。\n\n4. 优化测试文档：如果您已经有测试文档，但希望对其进行优化，使其更加规范、易读、易理解，我也可以提供帮助。\n\n无论您需要哪方面的帮助，我都可以根据您的具体需求提供定制化的服务。请告诉我您的具体要求，我将尽力满足您的需求。'

向量存储

加载要索引的数据,需要安装BeautifulSoup

pip install beautifulsoup4

将其索引到向量存储中。这需要一些组件，即嵌入模型和向量存储。

使用一个简单的本地向量存储 FAISS，首先需要安装它

pip install faiss-cpu

# 导入和使用 WebBaseLoader
from langchain_community.document_loaders import WebBaseLoader

loader = WebBaseLoader("https://docs.smith.langchain.com/user_guide")
docs = loader.load()

# 对于嵌入模型，这里通过 API调用
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()

#使用此嵌入模型将文档摄取到矢量存储中
from langchain_community.vectorstores import FAISS
from langchain_text_splitters import RecursiveCharacterTextSplitter

# 使用分割器分割文档
text_splitter = RecursiveCharacterTextSplitter()
documents = text_splitter.split_documents(docs)
# 向量存储
vector = FAISS.from_documents(documents, embeddings)

检索链

已在向量存储中索引了这些数据，接下来要创建一个检索链。该链将接收一个传入的问题，查找相关文档，然后将这些文档与原始问题一起传递给LLM，要求它回答原始问题。

创建一个链，该链接受一个问题和检索到的文档并生成一个答案。

from langchain.chains.combine_documents import create_stuff_documents_chain

prompt = ChatPromptTemplate.from_template("""仅根据提供的上下文回答以下问题:

<context>
{context}
</context>

Question: {input}""")

# 创建链，该链获取文档列表并将它们全部格式化为提示，然后将该提示传递给LLM。它传递所有文档，因此应该确保它适合正在使用的 LLM 上下文窗口
document_chain = create_stuff_documents_chain(llm, prompt)

# 可以直接通过传入文档来运行它
from langchain_core.documents import Document

text ="langsmith can let you visualize test results"
document_chain.invoke({
   
   
    "input": "Langsmith 如何帮助进行测试?",
    "context": [Document(page_content=text)]
})

'LangSmith 提供了多种方式来帮助进行测试。\n\n首先，LangSmith 支持开发人员创建数据集，这些数据集是输入和参考输出的集合，并使用这些数据集在他们的 LLM 应用程序上运行测试。开发人员可以批量上传、动态创建或从应用程序跟踪中导出测试用例。此外，LangSmith 还可以轻松运行自定义评估来对测试结果进行评分。\n\n其次，LangSmith 提供比较视图，可以并排查看同一数据点上不同配置的结果。这对于对应用程序的不同版本进行原型设计和更改时非常有用，可以帮助开发人员了解哪个变体的性能更好。\n\n此外，LangSmith 还提供了一个 Playground 环境，可以用于快速迭代和实验。开发人员可以在 Playground 中快速测试不同的提示和模型，并将每次运行记录在系统中以供后续创建测试用例或与其他运行进行比较。\n\n最后，LangSmith 还支持自动化，可以近乎实时地对跟踪执行操作。开发人员可以定义自动化操作，包括评分、发送到注释队列或添加到数据集等。这对于在生产规模上处理跟踪非常有用。'

还可以让文档首先来自刚刚设置的检索器。 这样，可以使用检索器动态选择最相关的文档，并将其传递给给定的问题。

from langchain.chains import create_retrieval_chain

# 创建向量存储检索器
retriever = vector.as_retriever()
# 创建链，该链接收用户查询，然后将其传递给检索器以获取相关文档。然后将这些文档（和原始输入）传递到 LLM 以生成响应
retrieval_chain = create_retrieval_chain(retriever, document_chain)
# 执行检索 这将返回一个字典
response = retrieval_chain.invoke({
   
   "input": "how can langsmith help with testing?"})
print(response["answer"])

答案应该更准确

LangSmith can help with testing in several ways. 

1. LangSmith allows developers to create datasets, which are collections of inputs and reference outputs, and use these to run tests on their LLM applications. Test cases can be uploaded in bulk, created on the fly, or exported from application traces.

2. LangSmith provides a user-friendly comparison view for test runs. This allows developers to compare the results of different configurations on the same datapoints side-by-side, helping them identify any regressions or improvements.

3. LangSmith supports custom evaluations, both LLM-based and heuristic-based, to score test results.

Overall, LangSmith enables developers to perform test-driven development and evaluate the performance of their LLM applications during the prototyping and beta testing phases.

对话检索链

上面创建的链只能回答单个问题。现在创建一个新链。该链将接收最新的输入和对话历史记录，并使用 LLM 生成搜索查询。

from langchain.chains import create_history_aware_retriever
from langchain_core.prompts import MessagesPlaceholder

# First we need a prompt that we can pass into an LLM to generate this search query

prompt = ChatPromptTemplate.from_messages([
    MessagesPlaceholder(variable_name="chat_history"),
    ("user", "{input}"),
    ("user", "鉴于上述对话，生成一个搜索查询以查找以获取与对话相关的信息")
])
retriever_chain = create_history_aware_retriever(llm, retriever, prompt)

# 通过传入用户提出后续问题来测试
from langchain_core.messages import HumanMessage, AIMessage

chat_history = [HumanMessage(content="LangSmith 可以帮助测试我的 LLM 应用程序吗?"), AIMessage(content="Yes!")]
retriever_chain.invoke({
   
   
    "chat_history": chat_history,
    "input": "告诉我怎么做"
})

还可以创建一个新的链来继续对话，并牢记这些检索到的文档。

prompt = ChatPromptTemplate.from_messages([
    ("system", "根据以下上下文回答用户的问题:\n\n{context}"),
    MessagesPlaceholder(variable_name="chat_history"),
    ("user", "{input}"),
])

document_chain = create_stuff_documents_chain(llm, prompt)
retrieval_chain = create_retrieval_chain(retriever_chain, document_chain)

# 测试
chat_history = [HumanMessage(content="LangSmith 可以帮助测试我的 LLM 应用程序吗?"), AIMessage(content="Yes!")]
retrieval_chain.invoke({
   
   
    "chat_history": chat_history,
    "input": "Tell me how"
})

代理的使用

构建代理时要做的第一件事是确定它应该有权访问哪些工具。这里授予代理访问两个工具的权限：

使用创建的检索器，以便代理能够回答有关LangSmith的问题。

一个搜索工具，以使代理能够回答需要最新信息的问题。

检索器工具

from langchain.tools.retriever import create_retriever_tool

retriever = vector.as_retriever()
retriever_tool = create_retriever_tool(
    retriever,
    "langsmith_search",
    "搜索有关 LangSmith 的信息。对于有关LangSmith的任何问题，您必须使用此工具!",
)

创建搜索工具

访问Tavily，注册账号登录并创建API秘钥，然后配置环境变量

import os

os.environ["TAVILY_API_KEY"] = 'tvly-ScxxxxxxxM8'

安装tavily-python库

pip install -U langchain-community tavily-python

创建工具

from langchain_community.tools.tavily_search import TavilySearchResults

search = TavilySearchResults()

创建代理

创建使用工具的列表

tools = [retriever_tool, search]

创建一个代理来使用工具

from langchain_openai import ChatOpenAI
from langchain import hub
from langchain.agents import create_openai_functions_agent
from langchain.agents import AgentExecutor

# 获取使用提示 可以修改它
prompt = hub.pull("hwchase17/openai-functions-agent")
# 初始化大模型
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
# 创建一个openai_functions_agent代理
agent = create_openai_functions_agent(llm, tools, prompt)
# 创建代理执行器
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

使用Agent代理

# 执行Agent
agent_executor.invoke({
   
   "input": "Langsmith 如何帮助进行测试?"})

询问天气情况

# 执行Agent
agent_executor.invoke({
   
   "input": "成都今天天气情况?"})

> Entering new AgentExecutor chain...

Invoking: `tavily_search_results_json` with `{
   
   'query': '成都今天天气情况'}`

[{
   
   'url': 'http://www.nmc.cn/publish/forecast/ASC/chengdu.html', 'content': '成都天气预报 ; 省份： 城市： ... 制作维护：国家气象中心预报系统开放实验室 地址：北京市中关村南大街46号 邮编：100081 . 京公网安备 11040102700100 ...'},
{
   
   'url': 'http://www.weather.com.cn/weather/101270101.shtml', 'content': '涂擦SPF大于15、PA+防晒护肤品。\n天凉，湿度大，较易感冒。\n天气凉，在户外运动请注意增减衣物。\n无需担心过敏，可放心外出，享受生活。\n建议着厚外套加毛衣等服装。\n天气较好，适合擦洗汽车。\n辐射弱，涂擦

根据天气预报，成都今天的天气情况为晴，气温为0℃，风力小于3级。明天将转为多云，最高气温12℃，最低气温0℃，风力小于3级。

> Finished chain.

进行对话

from langchain_core.messages import SystemMessage, HumanMessage, AIMessage

chat_history = [HumanMessage(content="LangSmith 可以帮助测试我的 LLM 应用程序吗?"), AIMessage(content="Yes!")]
agent_executor.invoke({
   
   
    "chat_history": chat_history,
    "input": "告诉我怎么做"
})

LangServe提供服务

概述

LangServe可以帮助开发人员将LangChain应用程序部署为REST API。使用LangChain时不是必定使用LangServe。

安装langserve

pip install "langserve[all]"

创建服务

创建一个serve.py文件。包含为应用程序提供服务的逻辑。由三部分组成：

构建的链的定义

FastAPI应用程序

为链提供服务的路由的定义，由langserve.add_routes命令完成

import os
from typing import List

from fastapi import FastAPI
from langchain import hub
from langchain.agents import AgentExecutor
from langchain.agents import create_openai_functions_agent
from langchain.pydantic_v1 import BaseModel, Field
from langchain.tools.retriever import create_retriever_tool
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_community.vectorstores import FAISS
from langchain_core.messages import BaseMessage
from langchain_openai import ChatOpenAI
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langserve import add_routes

os.environ["TAVILY_API_KEY"] = 'tvly-Scx77MxxxxIM8'
os.environ["OPENAI_BASE_URL"] = "https://xxx.com/v1"
os.environ["OPENAI_API_KEY"] = "sk-BGFnOL9Q4c99B378B66cT3BlBKFJ28839b4813bc437B82c2"

# 1. 获取检索器
# 创建一个 WebBaseLoader 对象，加载给定 URL 的网页内容
loader = WebBaseLoader("https://docs.smith.langchain.com/user_guide")
# 载入网页内容
docs = loader.load()

# 初始化 RecursiveCharacterTextSplitter 对象用于文本拆分
text_splitter = RecursiveCharacterTextSplitter()
# 使用文本拆分器将文档分成段落
documents = text_splitter.split_documents(docs)

# 初始化 OpenAIEmbeddings 对象，用于获取文本嵌入
embeddings = OpenAIEmbeddings()
# 从文档中获取嵌入向量并存储
vector = FAISS.from_documents(documents, embeddings)

# 将向量对象转换为检索器
retriever = vector.as_retriever()

# 2. 创建工具
# 检索器工具
retriever_tool = create_retriever_tool(
    retriever,
    "langsmith_search",
    "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",
)

# 搜索工具
search = TavilySearchResults()
tools = [retriever_tool, search]

# 3.创建代理
# 从指定的 Hub 拉取提示模板
prompt = hub.pull("hwchase17/openai-functions-agent")

# 初始化 ChatOpenAI 对象，选择模型为"gpt-3.5-turbo"，设置温度为0
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# 使用提供的模型、工具和提示创建 OpenAI 函数代理器
agent = create_openai_functions_agent(llm, tools, prompt)

# 初始化 AgentExecutor，传入代理器、工具对象和 verbose 标记为 True
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 4. 应用定义
app = FastAPI(
    title="LangChain Server",
    version="1.0",
    description="A simple API server using LangChain's Runnable interfaces",
)


# 5. 添加路由
class Input(BaseModel):
    # 定义输入 BaseModel 包含字段 input 和 chat_history
    input: str
    chat_history: List[BaseMessage] = Field(
        ...,
        # 为 chat_history 字段添加额外属性，设置 type 为 "chat"，input 为 "location"
        extra={
   
   "widget": {
   
   "type": "chat", "input": "location"}}
    )


class Output(BaseModel):
    # 定义输出 BaseModel 包含字段 output
    output: str


# 将该配置的agent_executor添加到应用程序app的路由中，路径为 "/agent"
add_routes(
    app,
    # agent_executor配置为使用特定的输入和输出类型
    agent_executor.with_types(input_type=Input, output_type=Output),
    path="/agent",
)

if __name__ == "__main__":
    # 导入 uvicorn 模块
    # uvicorn是用于 ASGI 应用程序的轻量级 Web 服务器
    import uvicorn

    # 运行主应用程序 app，指定主机为 localhost，端口为 8000
    uvicorn.run(app, host="localhost", port=8000)

启动服务

执行这个文件启动服务，并在localhost:8000上提供服务

python serve.py

INFO:     Started server process [18352]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://localhost:8000 (Press CTRL+C to quit)

 __          ___      .__   __.   _______      _______. _______ .______     ____    ____  _______
|  |        /   \     |  \ |  |  /  _____|    /       ||   ____||   _  \    \   \  /   / |   ____|
|  |       /  ^  \    |   \|  | |  |  __     |   (----`|  |__   |  |_)  |    \   \/   /  |  |__
|  |      /  /_\  \   |  . `  | |  | |_ |     \   \    |   __|  |      /      \      /   |   __|
|  `----./  _____  \  |  |\   | |  |__| | .----)   |   |  |____ |  |\  \----.  \    /    |  |____
|_______/__/     \__\ |__| \__|  \______| |_______/    |_______|| _| `._____|   \__/     |_______|

LANGSERVE: Playground for chain "/agent/" is live at:
LANGSERVE:  │
LANGSERVE:  └──> /agent/playground/
LANGSERVE:
LANGSERVE: See all available routes at /docs/

服务交互

每个 LangServe 服务都带有一个简单的内置 UI，用于配置和调用具有流输出和中间步骤可见性的应用程序。

访问：http://localhost:8000/agent/playground/

设置一个客户端，以便以编程方式与我们的服务进行交互。

from langserve import RemoteRunnable

remote_chain = RemoteRunnable("http://localhost:8000/agent/")
res = remote_chain.invoke({
   
   
    "input": "成都今天天气情况怎样?",
    "chat_history": []
})
print(res)