文章目录

www.aidoczh.com已经系统的将LangChain官网文档翻译成中文，您可以去http://www.aidoczh.com/langchain/v0.2/docs/introduction/ 查看文档，该网站www.aidoczh.com主要是将AI工具官方文档翻译成中文，还有其他工具文档可以看。

在本快速入门中，我们将向您展示如何：

  • 配置 LangChain、LangSmith 和 LangServe
  • 使用 LangChain 的最基本和常见组件：提示模板、模型和输出解析器
  • 使用 LangChain 表达语言，这是 LangChain 构建的协议，有助于组件链接
  • 使用 LangChain 构建一个简单的应用程序
  • 使用 LangSmith 跟踪您的应用程序
  • 使用 LangServe 提供您的应用程序

这是一个相当多的内容要涵盖！让我们开始吧。

设置

Jupyter Notebook

本指南（以及文档中的大多数其他指南）使用 Jupyter 笔记本，并假定读者也在使用。Jupyter 笔记本非常适合学习如何使用 LLM 系统，因为通常会出现一些问题（意外输出、API 崩溃等），在交互式环境中阅读指南是更好地理解它们的好方法。

您不一定需要在 Jupyter Notebook 中阅读本指南，但建议这样做。请参阅 此处 以获取安装说明。

安装

要安装 LangChain，请运行：

pip install langchain

有关更多详细信息，请参阅我们的安装指南。

LangSmith

您使用 LangChain 构建的许多应用程序将包含多个步骤，涉及多次调用 LLM 调用。
随着这些应用程序变得越来越复杂，能够检查链或代理内部发生的情况变得至关重要。
最好的方法是使用 LangSmith。

请注意，LangSmith 不是必需的，但它很有帮助。
如果您想使用 LangSmith，在上面的链接注册后，请确保设置您的环境变量以开始记录跟踪：

export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="..."

使用 LangChain 构建

LangChain 可以构建将外部数据源和计算连接到 LLM 的应用程序。
在本快速入门中，我们将介绍几种不同的方法。
我们将从一个简单的 LLM 链开始，该链仅依赖于提示模板中的信息来回复。
接下来，我们将构建一个检索链，该链从单独的数据库中获取数据并将其传递到提示模板中。
然后，我们将添加聊天记录，创建一个对话检索链。这使您可以以聊天方式与此 LLM 互动，因此它会记住以前的问题。
最后，我们将构建一个代理 - 该代理利用 LLM 来确定是否需要获取数据来回答问题。
我们将对这些内容进行概述，但这些内容都有很多细节！我们将链接到相关文档。

LLM 链

我们将展示如何使用通过 API 提供的模型，如 OpenAI，以及本地开源模型，使用像 Ollama 这样的集成。

OpenAI

首先，我们需要导入 LangChain x OpenAI 集成包。

pip install langchain-openai

访问 API 需要一个 API 密钥，您可以通过创建帐户并转到 此处 获取。一旦我们有了密钥，我们将希望通过运行以下命令将其设置为环境变量：

export OPENAI_API_KEY="..."

然后，我们可以初始化模型：

from langchain_openai import ChatOpenAI

llm = ChatOpenAI()

如果您不想设置环境变量，可以在初始化 OpenAI LLM 类时通过 openai_api_key 命名参数直接传递密钥：

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(openai_api_key="...")

Ollama

Ollama 允许您在本地运行开源大型语言模型，例如 Llama 2。

首先，请按照 这些说明 设置并运行本地 Ollama 实例：

  • 下载
  • 通过 ollama pull llama2 获取模型

然后，确保 Ollama 服务器正在运行。之后，您可以执行以下操作：

from langchain_community.llms import Ollama
llm = Ollama(model="llama2")

Anthropic

首先，我们需要导入 LangChain x Anthropic 包。

pip install langchain-anthropic

访问 API 需要一个 API 密钥，您可以通过在 此处 创建帐户获取。一旦我们有了密钥，我们将希望通过运行以下命令将其设置为环境变量：

export ANTHROPIC_API_KEY="..."

然后，我们可以初始化模型：

from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(model="claude-3-sonnet-20240229", temperature=0.2, max_tokens=1024)

如果您不想设置环境变量，可以在初始化 Anthropic Chat Model 类时通过 anthropic_api_key 命名参数直接传递密钥：

llm = ChatAnthropic(anthropic_api_key="...")

Cohere

首先，我们需要导入 Cohere SDK 包。

pip install cohere

访问 API 需要一个 API 密钥，您可以通过创建帐户并转到 此处 获取。一旦我们有了密钥，我们将希望通过运行以下命令将其设置为环境变量：

export COHERE_API_KEY="..."

然后，我们可以初始化模型：

from langchain_community.chat_models import ChatCohere

llm = ChatCohere()

如果您不想设置环境变量，可以在初始化 Cohere LLM 类时通过 cohere_api_key 命名参数直接传递密钥：

from langchain_community.chat_models import ChatCohere

llm = ChatCohere(cohere_api_key="...")

安装并初始化您选择的 LLM 后，我们可以尝试使用它！
让我们询问它 LangSmith 是什么 - 这是训练数据中没有的内容，所以它不应该有一个非常好的回应。

llm.invoke("how can langsmith help with testing?")

我们还可以通过提示模板引导它的回应。
提示模板用于将原始用户输入转换为更好的输入以供 LLM 使用。

from langchain_core.prompts import ChatPromptTemplate
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are world class technical documentation writer."),
    ("user", "{input}")
])

现在，我们可以将这些组合成一个简单的 LLM 链：

chain = prompt | llm

现在，我们可以调用它并询问相同的问题。它仍然不会知道答案，但应该以更适合技术作者的方式回应！

chain.invoke({"input": "how can langsmith help with testing?"})

ChatModel 的输出（因此也是此链的输出）是一条消息。但是，使用字符串更方便。让我们添加一个简单的输出解析器，将聊天消息转换为字符串。

from langchain_core.output_parsers import StrOutputParser

output_parser = StrOutputParser()

现在，我们可以将其添加到之前的链中：

chain = prompt | llm | output_parser

现在，我们可以调用它并询问相同的问题。答案现在将是一个字符串（而不是 ChatMessage）。

chain.invoke({"input": "how can langsmith help with testing?"})

深入了解

我们现在已经成功设置了一个基本的 LLM 链。我们仅涉及了提示、模型和输出解析器的基础知识 - 要深入了解这里提到的所有内容，请参阅文档的此部分。

检索链

为了正确回答最初的问题（“LangSmith 如何帮助测试？”），我们需要为 LLM 提供额外的上下文。
我们可以通过检索来实现这一点。
当您有太多数据要直接传递给 LLM 时，检索非常有用。
然后，您可以使用检索器仅获取最相关的部分并将其传递进去。

在此过程中，我们将从检索器中查找相关文档，然后将其传递到提示中。
检索器可以由任何内容支持 - SQL 表、互联网等 - 但在此示例中，我们将填充一个向量存储并将其用作检索器。有关向量存储的更多信息，请参阅此文档。

首先，我们需要加载要索引的数据。为此，我们将使用 WebBaseLoader。这需要安装 BeautifulSoup：

pip install beautifulsoup4

之后，我们可以导入并使用 WebBaseLoader。

from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://docs.smith.langchain.com/user_guide")

docs = loader.load()

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

对于嵌入模型，我们再次提供通过 API 访问或通过运行本地模型的示例。

OpenAI

确保您已安装 langchain_openai 包并设置了适当的环境变量（这些与 LLM 需要的相同）。

from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()

Ollama

确保 Ollama 正在运行（与 LLM 的设置相同）。

from langchain_community.embeddings import OllamaEmbeddings

embeddings = OllamaEmbeddings()

Cohere

确保已安装 cohere 包并设置了适当的环境变量（这些与 LLM 需要的相同）。

from langchain_community.embeddings import CohereEmbeddings

embeddings = CohereEmbeddings()

现在，我们可以使用这个嵌入模型将文档导入向量存储中。
为了简单起见，我们将使用一个简单的本地向量存储，FAISS。

首先，我们需要安装所需的软件包：

pip install faiss-cpu

然后我们可以构建我们的索引：

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("""Answer the following question based only on the provided context:

<context>
{context}
</context>

Question: {input}""")

document_chain = create_stuff_documents_chain(llm, prompt)

如果我们愿意，我们可以通过直接传入文档来运行这个链：

from langchain_core.documents import Document

document_chain.invoke({
    "input": "how can langsmith help with testing?",
    "context": [Document(page_content="langsmith can let you visualize test results")]
})

然而，我们希望文档首先来自我们刚刚设置的检索器。
这样，对于给定的问题，我们可以使用检索器动态选择最相关的文档并传递它们。

from langchain.chains import create_retrieval_chain

retriever = vector.as_retriever()
retrieval_chain = create_retrieval_chain(retriever, document_chain)

现在我们可以调用这个链。这将返回一个字典 - LLM 的响应在 answer 键中。

response = retrieval_chain.invoke({"input": "how can langsmith help with testing?"})
print(response["answer"])

# LangSmith 提供了几个可以帮助测试的功能：...

这个答案应该更加准确！

深入探讨

我们现在成功地建立了一个基本的检索链。我们只是简单介绍了检索的基础知识 - 想要深入了解这里提到的所有内容，请参阅文档的这一部分。

对话检索链

到目前为止，我们创建的链只能回答单个问题。人们正在构建的 LLM 应用程序中的主要类型之一是聊天机器人。那么我们如何将这个链转变为一个可以回答后续问题的链呢？

我们仍然可以使用 create_retrieval_chain 函数，但需要更改两个方面：

  1. 检索方法现在不仅应该仅适用于最近的输入，而是应该考虑整个历史记录。
  2. 最终的 LLM 链也应该考虑整个历史记录

更新检索

为了更新检索，我们将创建一个新的链。这个链将接收最近的输入 (input) 和对话历史 (chat_history)，并使用一个 LLM 生成一个搜索查询。

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

# 首先，我们需要一个提示，可以传递给 LLM 以生成这个搜索查询

prompt = ChatPromptTemplate.from_messages([
    MessagesPlaceholder(variable_name="chat_history"),
    ("user", "{input}"),
    ("user", "Given the above conversation, generate a search query to look up in order to get information relevant to the conversation")
])
retriever_chain = create_history_aware_retriever(llm, retriever, prompt)

我们可以通过传入一个用户正在问一个后续问题的实例来测试这个功能。

from langchain_core.messages import HumanMessage, AIMessage

chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
retriever_chain.invoke({
    "chat_history": chat_history,
    "input": "Tell me how"
})

您应该看到这返回了关于在 LangSmith 进行测试的文档。这是因为 LLM 生成了一个新的查询，将对话历史与后续问题结合起来。

现在我们有了这个新的检索器，我们可以创建一个新的链，以在考虑这些检索到的文档的情况下继续对话。

prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer the user's questions based on the below context:\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="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
retrieval_chain.invoke({
    "chat_history": chat_history,
    "input": "Tell me how"
})

我们可以看到这给出了一个连贯的答案 - 我们成功地将我们的检索链转变为了一个聊天机器人！

代理

到目前为止，我们创建了链的示例 - 每一步都是事先知道的。
我们将要创建的最后一件事是代理 - 其中 LLM 决定要采取哪些步骤。

注意：对于这个示例，我们将只展示如何使用 OpenAI 模型创建代理，因为本地模型目前还不够可靠。

构建代理时的第一件事是决定它应该具有哪些工具。
对于这个示例，我们将给代理访问两个工具：

  1. 我们刚刚创建的检索器。这将让它轻松回答关于 LangSmith 的问题
  2. 一个搜索工具。这将让它轻松回答需要最新信息的问题。

首先，让我们为我们刚刚创建的检索器设置一个工具：

from langchain.tools.retriever import create_retriever_tool

retriever_tool = create_retriever_tool(
    retriever,
    "langsmith_search",
    "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",
)

我们将使用的搜索工具是 Tavily。这将需要一个 API 密钥（它们有慷慨的免费套餐）。在他们的平台上创建完毕后，您需要将其设置为环境变量：

export TAVILY_API_KEY=...

如果您不想设置 API 密钥，您可以跳过创建这个工具。

from langchain_community.tools.tavily_search import TavilySearchResults

search = TavilySearchResults()

现在我们可以创建一个我们想要使用的工具列表：

tools = [retriever_tool, search]

现在我们有了这些工具，我们可以创建一个代理来使用它们。我们将快速地介绍这个过程 - 想要深入了解正在发生的事情，请查看代理入门文档

首先安装 langchain hub

pip install langchainhub

现在我们可以使用它来获取一个预定义的提示

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

# Get the prompt to use - you can modify this!
prompt = hub.pull("hwchase17/openai-functions-agent")
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

我们现在可以调用代理并查看它的响应！我们可以问它关于 LangSmith 的问题：

agent_executor.invoke({"input": "how can langsmith help with testing?"})

我们可以问它关于天气：

agent_executor.invoke({"input": "what is the weather in SF?"})

我们可以与它进行对话：

chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
agent_executor.invoke({
    "chat_history": chat_history,
    "input": "Tell me how"
})

深入探讨

我们现在成功地建立了一个基本的代理。我们只是简单介绍了代理的基础知识 - 想要深入了解这里提到的所有内容，请参阅文档的这一部分。

使用 LangServe 进行服务

现在我们已经构建了一个应用程序，我们需要对其进行服务。这就是 LangServe 的作用。
LangServe 帮助开发人员将 LangChain 链部署为 REST API。您不需要使用 LangServe 来使用 LangChain，但在本指南中，我们将展示如何使用 LangServe 部署您的应用程序。

虽然本指南的第一部分旨在在 Jupyter Notebook 中运行，但我们现在将移出那里。我们将创建一个 Python 文件，然后从命令行与之交互。

安装：

pip install "langserve[all]"

服务器

为了为我们的应用程序创建一个服务器，我们将制作一个 serve.py 文件。这将包含我们为服务应用程序提供的逻辑。它包括三个部分：

  1. 我们刚刚构建的链的定义
  2. 我们的 FastAPI 应用程序
  3. 一个用于服务链的路由的定义，这是通过 langserve.add_routes 完成的
#!/usr/bin/env python
from typing import List

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

# 1. Load Retriever
loader = WebBaseLoader("https://docs.smith.langchain.com/user_guide")
docs = loader.load()
text_splitter = RecursiveCharacterTextSplitter()
documents = text_splitter.split_documents(docs)
embeddings = OpenAIEmbeddings()
vector = FAISS.from_documents(documents, embeddings)
retriever = vector.as_retriever()

# 2. Create Tools
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. Create Agent
prompt = hub.pull("hwchase17/openai-functions-agent")
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)


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

# 5. Adding chain route

# We need to add these input/output schemas because the current AgentExecutor
# is lacking in schemas.

class Input(BaseModel):
    input: str
    chat_history: List[BaseMessage] = Field(
        ...,
        extra={"widget": {"type": "chat", "input": "location"}},
    )


class Output(BaseModel):
    output: str

add_routes(
    app,
    agent_executor.with_types(input_type=Input, output_type=Output),
    path="/agent",
)

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="localhost", port=8000)

到此为止！如果我们执行这个文件：

python serve.py

我们应该可以在 localhost:8000 看到我们的链正在提供服务。

游乐场

每个 LangServe 服务都配备了一个简单的内置用户界面，用于配置和调用应用程序，具有流式输出和查看中间步骤的功能。
前往 http://localhost:8000/agent/playground/ 试一下吧！输入与之前相同的问题 - “how can langsmith help with testing?” - 它应该会像之前一样做出回应。

客户端

现在让我们为与我们的服务进行程序化交互设置一个客户端。我们可以很容易地使用 langserve.RemoteRunnable 来实现这一点。
使用这个，我们可以像在客户端运行一样与提供的链进行交互。

from langserve import RemoteRunnable

remote_chain = RemoteRunnable("http://localhost:8000/agent/")
remote_chain.invoke({
    "input": "how can langsmith help with testing?",
    "chat_history": []  # 提供一个空列表，因为这是第一次调用
})

要了解更多关于 LangServe 的其他功能，请点击这里。

下一步

我们已经介绍了如何使用 LangChain 构建应用程序，如何使用 LangSmith 追踪它，以及如何使用 LangServe 提供服务。
这三者中都有比我们在这里介绍的更多功能。
要继续你的学习之旅，我们建议你按照以下顺序阅读：

  • 所有这些功能都由LangChain 表达语言 (LCEL)支持 - 这是一种将这些组件链接在一起的方法。查阅该文档以更好地理解如何创建自定义链。
  • 模型输入输出涵盖了有关提示、LLM 和输出解析器的更多细节。
  • 检索涵盖了与检索相关的一切更多细节
  • 代理涵盖了与代理相关的一切细节
  • 探索常见的端到端用例和模板应用程序
  • 阅读关于 LangSmith，这是用于调试、测试、监控等的平台
  • 了解如何使用LangServe为您的应用程序提供服务ÒÒ
# 语言模型 # 人工智能
Logo
开放原子开发者工作坊

开放原子开发者工作坊旨在鼓励更多人参与开源活动，与志同道合的开发者们相互交流开发经验、分享开发心得、获取前沿技术趋势。工作坊有多种形式的开发者活动，如meetup、训练营等，主打技术交流，干货满满，真诚地邀请各位开发者共同参与！

更多推荐

第二届开放原子大赛首批创新成果集结武汉，诚邀广大开发者共鉴开源技术盛宴

第二届开放原子大赛首批创新成果集结武汉，诚邀广大开发者共鉴开源技术盛宴

avatar 开放原子开发者工作坊

诚邀报名 | 开源基础设施能力建设分论坛：打造开源生态的“心脏”

诚邀报名 | 开源基础设施能力建设分论坛：打造开源生态的“心脏”

avatar 开放原子开发者工作坊

诚邀报名 | 编程语言分论坛：AI时代的技术革新与开源实践

诚邀报名 | 编程语言分论坛：AI时代的技术革新与开源实践

avatar 开放原子开发者工作坊