AI创想

标题: LangChain系列使用指南：LangChain快速入门 [打印本页]
作者: qinsezaiyu    时间: 昨天 20:49
标题: LangChain系列使用指南：LangChain快速入门
作者：数智笔记
文章目录


www.aidoczh.com已经系统的将LangChain官网文档翻译成中文，您可以去http://www.aidoczh.com/langchain/v0.2/docs/introduction/ 查看文档，该网站www.aidoczh.com主要是将AI工具官方文档翻译成中文，还有其他工具文档可以看。
在本快速入门中，我们将向您展示如何：
这是一个相当多的内容要涵盖！让我们开始吧。
设置

Jupyter Notebook

本指南（以及文档中的大多数其他指南）使用 Jupyter 笔记本，并假定读者也在使用。Jupyter 笔记本非常适合学习如何使用 LLM 系统，因为通常会出现一些问题（意外输出、API 崩溃等），在交互式环境中阅读指南是更好地理解它们的好方法。
您不一定需要在 Jupyter Notebook 中阅读本指南，但建议这样做。请参阅 此处 以获取安装说明。
安装

要安装 LangChain，请运行：
  1. pip install langchain
复制代码
有关更多详细信息，请参阅我们的安装指南。
LangSmith

您使用 LangChain 构建的许多应用程序将包含多个步骤，涉及多次调用 LLM 调用。
随着这些应用程序变得越来越复杂，能够检查链或代理内部发生的情况变得至关重要。
最好的方法是使用 LangSmith。
请注意，LangSmith 不是必需的，但它很有帮助。
如果您想使用 LangSmith，在上面的链接注册后，请确保设置您的环境变量以开始记录跟踪：
  1. exportLANGCHAIN_TRACING_V2="true"exportLANGCHAIN_API_KEY="..."
复制代码
使用 LangChain 构建

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

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

首先，我们需要导入 LangChain x OpenAI 集成包。
  1. pip install langchain-openai
复制代码
访问 API 需要一个 API 密钥，您可以通过创建帐户并转到 此处 获取。一旦我们有了密钥，我们将希望通过运行以下命令将其设置为环境变量：
  1. exportOPENAI_API_KEY="..."
复制代码
然后，我们可以初始化模型：
  1. from langchain_openai import ChatOpenAI
  3. llm = ChatOpenAI()
复制代码
如果您不想设置环境变量，可以在初始化 OpenAI LLM 类时通过 openai_api_key 命名参数直接传递密钥：
  1. from langchain_openai import ChatOpenAI
  3. llm = ChatOpenAI(openai_api_key="...")
复制代码
Ollama

Ollama 允许您在本地运行开源大型语言模型，例如 Llama 2。
首先，请按照 这些说明 设置并运行本地 Ollama 实例：
然后，确保 Ollama 服务器正在运行。之后，您可以执行以下操作：
  1. from langchain_community.llms import Ollama
  2. llm = Ollama(model="llama2")
复制代码
Anthropic

首先，我们需要导入 LangChain x Anthropic 包。
  1. pip install langchain-anthropic
复制代码
访问 API 需要一个 API 密钥，您可以通过在 此处 创建帐户获取。一旦我们有了密钥，我们将希望通过运行以下命令将其设置为环境变量：
  1. exportANTHROPIC_API_KEY="..."
复制代码
然后，我们可以初始化模型：
  1. from langchain_anthropic import ChatAnthropic
  3. llm = ChatAnthropic(model="claude-3-sonnet-20240229", temperature=0.2, max_tokens=1024)
复制代码
如果您不想设置环境变量，可以在初始化 Anthropic Chat Model 类时通过 anthropic_api_key 命名参数直接传递密钥：
  1. llm = ChatAnthropic(anthropic_api_key="...")
复制代码
Cohere

首先，我们需要导入 Cohere SDK 包。
  1. pip install cohere
复制代码
访问 API 需要一个 API 密钥，您可以通过创建帐户并转到 此处 获取。一旦我们有了密钥，我们将希望通过运行以下命令将其设置为环境变量：
  1. exportCOHERE_API_KEY="..."
复制代码
然后，我们可以初始化模型：
  1. from langchain_community.chat_models import ChatCohere
  3. llm = ChatCohere()
复制代码
如果您不想设置环境变量，可以在初始化 Cohere LLM 类时通过 cohere_api_key 命名参数直接传递密钥：
  1. from langchain_community.chat_models import ChatCohere
  3. llm = ChatCohere(cohere_api_key="...")
复制代码
安装并初始化您选择的 LLM 后，我们可以尝试使用它！
让我们询问它 LangSmith 是什么 - 这是训练数据中没有的内容，所以它不应该有一个非常好的回应。
  1. llm.invoke("how can langsmith help with testing?")
复制代码
我们还可以通过提示模板引导它的回应。
提示模板用于将原始用户输入转换为更好的输入以供 LLM 使用。
  1. from langchain_core.prompts import ChatPromptTemplate
  2. prompt = ChatPromptTemplate.from_messages([("system","You are world class technical documentation writer."),("user","{input}")])
复制代码
现在，我们可以将这些组合成一个简单的 LLM 链：
  1. chain = prompt | llm
复制代码
现在，我们可以调用它并询问相同的问题。它仍然不会知道答案，但应该以更适合技术作者的方式回应！
  1. chain.invoke({"input":"how can langsmith help with testing?"})
复制代码
ChatModel 的输出（因此也是此链的输出）是一条消息。但是，使用字符串更方便。让我们添加一个简单的输出解析器，将聊天消息转换为字符串。
  1. from langchain_core.output_parsers import StrOutputParser
  3. output_parser = StrOutputParser()
复制代码
现在，我们可以将其添加到之前的链中：
  1. chain = prompt | llm | output_parser
复制代码
现在，我们可以调用它并询问相同的问题。答案现在将是一个字符串（而不是 ChatMessage）。
  1. chain.invoke({"input":"how can langsmith help with testing?"})
复制代码
深入了解

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

为了正确回答最初的问题（“LangSmith 如何帮助测试？”），我们需要为 LLM 提供额外的上下文。
我们可以通过检索来实现这一点。
当您有太多数据要直接传递给 LLM 时，检索非常有用。
然后，您可以使用检索器仅获取最相关的部分并将其传递进去。
在此过程中，我们将从检索器中查找相关文档，然后将其传递到提示中。
检索器可以由任何内容支持 - SQL 表、互联网等 - 但在此示例中，我们将填充一个向量存储并将其用作检索器。有关向量存储的更多信息，请参阅此文档。
首先，我们需要加载要索引的数据。为此，我们将使用 WebBaseLoader。这需要安装 BeautifulSoup：
  1. pip install beautifulsoup4
复制代码
之后，我们可以导入并使用 WebBaseLoader。
  1. from langchain_community.document_loaders import WebBaseLoader
  2. loader = WebBaseLoader("https://docs.smith.langchain.com/user_guide")
  4. docs = loader.load()
复制代码
接下来，我们需要将其索引到向量存储中。这需要一些组件，即嵌入模型和向量存储。
对于嵌入模型，我们再次提供通过 API 访问或通过运行本地模型的示例。
OpenAI

确保您已安装 langchain_openai 包并设置了适当的环境变量（这些与 LLM 需要的相同）。
  1. from langchain_openai import OpenAIEmbeddings
  3. embeddings = OpenAIEmbeddings()
复制代码
Ollama

确保 Ollama 正在运行（与 LLM 的设置相同）。
  1. from langchain_community.embeddings import OllamaEmbeddings
  3. embeddings = OllamaEmbeddings()
复制代码
Cohere

确保已安装 cohere 包并设置了适当的环境变量（这些与 LLM 需要的相同）。
  1. from langchain_community.embeddings import CohereEmbeddings
  3. embeddings = CohereEmbeddings()
复制代码
现在，我们可以使用这个嵌入模型将文档导入向量存储中。
为了简单起见，我们将使用一个简单的本地向量存储，FAISS。
首先，我们需要安装所需的软件包：
  1. pip install faiss-cpu
复制代码
然后我们可以构建我们的索引：
  1. from langchain_community.vectorstores import FAISS
  2. from langchain_text_splitters import RecursiveCharacterTextSplitter
  4. text_splitter = RecursiveCharacterTextSplitter()
  5. documents = text_splitter.split_documents(docs)
  6. vector = FAISS.from_documents(documents, embeddings)
复制代码
现在我们已经在向量存储中索引了这些数据，我们将创建一个检索链。
这个链将接收一个问题，查找相关文档，然后将这些文档连同原始问题传递给一个 LLM，并要求它回答原始问题。
首先，让我们设置一个链，该链接收一个问题和检索到的文档，并生成一个答案。
  1. from langchain.chains.combine_documents import create_stuff_documents_chain
  3. prompt = ChatPromptTemplate.from_template("""Answer the following question based only on the provided context:
  5. <context>
  6. {context}
  7. </context>
  9. Question: {input}""")
  11. document_chain = create_stuff_documents_chain(llm, prompt)
复制代码
如果我们愿意，我们可以通过直接传入文档来运行这个链：
  1. from langchain_core.documents import Document
  3. document_chain.invoke({"input":"how can langsmith help with testing?","context":[Document(page_content="langsmith can let you visualize test results")]})
复制代码
然而，我们希望文档首先来自我们刚刚设置的检索器。
这样，对于给定的问题，我们可以使用检索器动态选择最相关的文档并传递它们。
  1. from langchain.chains import create_retrieval_chain
  3. retriever = vector.as_retriever()
  4. retrieval_chain = create_retrieval_chain(retriever, document_chain)
复制代码
现在我们可以调用这个链。这将返回一个字典 - LLM 的响应在 answer 键中。
  1. response = retrieval_chain.invoke({"input":"how can langsmith help with testing?"})print(response["answer"])# LangSmith 提供了几个可以帮助测试的功能：...
复制代码
这个答案应该更加准确！
深入探讨

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

到目前为止，我们创建的链只能回答单个问题。人们正在构建的 LLM 应用程序中的主要类型之一是聊天机器人。那么我们如何将这个链转变为一个可以回答后续问题的链呢？
我们仍然可以使用 create_retrieval_chain 函数，但需要更改两个方面：
更新检索
为了更新检索，我们将创建一个新的链。这个链将接收最近的输入 (input) 和对话历史 (chat_history)，并使用一个 LLM 生成一个搜索查询。
  1. from langchain.chains import create_history_aware_retriever
  2. from langchain_core.prompts import MessagesPlaceholder
  4. # 首先，我们需要一个提示，可以传递给 LLM 以生成这个搜索查询
  6. prompt = ChatPromptTemplate.from_messages([
  7.     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")])
  8. retriever_chain = create_history_aware_retriever(llm, retriever, prompt)
复制代码
我们可以通过传入一个用户正在问一个后续问题的实例来测试这个功能。
  1. from langchain_core.messages import HumanMessage, AIMessage
  3. chat_history =[HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
  4. retriever_chain.invoke({"chat_history": chat_history,"input":"Tell me how"})
复制代码
您应该看到这返回了关于在 LangSmith 进行测试的文档。这是因为 LLM 生成了一个新的查询，将对话历史与后续问题结合起来。
现在我们有了这个新的检索器，我们可以创建一个新的链，以在考虑这些检索到的文档的情况下继续对话。
  1. prompt = ChatPromptTemplate.from_messages([("system","Answer the user's questions based on the below context:\n\n{context}"),
  2.     MessagesPlaceholder(variable_name="chat_history"),("user","{input}"),])
  3. document_chain = create_stuff_documents_chain(llm, prompt)
  5. retrieval_chain = create_retrieval_chain(retriever_chain, document_chain)
复制代码
现在我们可以进行端到端的测试：
  1. chat_history =[HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
  2. retrieval_chain.invoke({"chat_history": chat_history,"input":"Tell me how"})
复制代码
我们可以看到这给出了一个连贯的答案 - 我们成功地将我们的检索链转变为了一个聊天机器人！
代理

到目前为止，我们创建了链的示例 - 每一步都是事先知道的。
我们将要创建的最后一件事是代理 - 其中 LLM 决定要采取哪些步骤。
注意：对于这个示例，我们将只展示如何使用 OpenAI 模型创建代理，因为本地模型目前还不够可靠。
构建代理时的第一件事是决定它应该具有哪些工具。
对于这个示例，我们将给代理访问两个工具：
首先，让我们为我们刚刚创建的检索器设置一个工具：
  1. from langchain.tools.retriever import create_retriever_tool
  3. retriever_tool = create_retriever_tool(
  4.     retriever,"langsmith_search","Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",)
复制代码
我们将使用的搜索工具是 Tavily。这将需要一个 API 密钥（它们有慷慨的免费套餐）。在他们的平台上创建完毕后，您需要将其设置为环境变量：
  1. exportTAVILY_API_KEY=...
复制代码
如果您不想设置 API 密钥，您可以跳过创建这个工具。
  1. from langchain_community.tools.tavily_search import TavilySearchResults
  3. search = TavilySearchResults()
复制代码
现在我们可以创建一个我们想要使用的工具列表：
  1. tools =[retriever_tool, search]
复制代码
现在我们有了这些工具，我们可以创建一个代理来使用它们。我们将快速地介绍这个过程 - 想要深入了解正在发生的事情，请查看代理入门文档
首先安装 langchain hub
  1. pip install langchainhub
复制代码
现在我们可以使用它来获取一个预定义的提示
  1. from langchain_openai import ChatOpenAI
  2. from langchain import hub
  3. from langchain.agents import create_openai_functions_agent
  4. from langchain.agents import AgentExecutor
  6. # Get the prompt to use - you can modify this!
  7. prompt = hub.pull("hwchase17/openai-functions-agent")
  8. llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
  9. agent = create_openai_functions_agent(llm, tools, prompt)
  10. agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
复制代码
我们现在可以调用代理并查看它的响应！我们可以问它关于 LangSmith 的问题：
  1. agent_executor.invoke({"input":"how can langsmith help with testing?"})
复制代码
我们可以问它关于天气：
  1. agent_executor.invoke({"input":"what is the weather in SF?"})
复制代码
我们可以与它进行对话：
  1. chat_history =[HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
  2. agent_executor.invoke({"chat_history": chat_history,"input":"Tell me how"})
复制代码
深入探讨

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

现在我们已经构建了一个应用程序，我们需要对其进行服务。这就是 LangServe 的作用。
LangServe 帮助开发人员将 LangChain 链部署为 REST API。您不需要使用 LangServe 来使用 LangChain，但在本指南中，我们将展示如何使用 LangServe 部署您的应用程序。
虽然本指南的第一部分旨在在 Jupyter Notebook 中运行，但我们现在将移出那里。我们将创建一个 Python 文件，然后从命令行与之交互。
安装：
  1. pip install"langserve[all]"
复制代码
服务器

为了为我们的应用程序创建一个服务器，我们将制作一个 serve.py 文件。这将包含我们为服务应用程序提供的逻辑。它包括三个部分：
  1. #!/usr/bin/env pythonfrom typing import List
  3. from fastapi import FastAPI
  4. from langchain_core.prompts import ChatPromptTemplate
  5. from langchain_openai import ChatOpenAI
  6. from langchain_community.document_loaders import WebBaseLoader
  7. from langchain_openai import OpenAIEmbeddings
  8. from langchain_community.vectorstores import FAISS
  9. from langchain_text_splitters import RecursiveCharacterTextSplitter
  10. from langchain.tools.retriever import create_retriever_tool
  11. from langchain_community.tools.tavily_search import TavilySearchResults
  12. from langchain_openai import ChatOpenAI
  13. from langchain import hub
  14. from langchain.agents import create_openai_functions_agent
  15. from langchain.agents import AgentExecutor
  16. from langchain.pydantic_v1 import BaseModel, Field
  17. from langchain_core.messages import BaseMessage
  18. from langserve import add_routes
  20. # 1. Load Retriever
  21. loader = WebBaseLoader("https://docs.smith.langchain.com/user_guide")
  22. docs = loader.load()
  23. text_splitter = RecursiveCharacterTextSplitter()
  24. documents = text_splitter.split_documents(docs)
  25. embeddings = OpenAIEmbeddings()
  26. vector = FAISS.from_documents(documents, embeddings)
  27. retriever = vector.as_retriever()# 2. Create Tools
  28. retriever_tool = create_retriever_tool(
  29.     retriever,"langsmith_search","Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",)
  30. search = TavilySearchResults()
  31. tools =[retriever_tool, search]# 3. Create Agent
  32. prompt = hub.pull("hwchase17/openai-functions-agent")
  33. llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
  34. agent = create_openai_functions_agent(llm, tools, prompt)
  35. agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)# 4. App definition
  36. app = FastAPI(
  37.   title="LangChain Server",
  38.   version="1.0",
  39.   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.classInput(BaseModel):input:str
  40.     chat_history: List[BaseMessage]= Field(...,
  41.         extra={"widget":{"type":"chat","input":"location"}},)classOutput(BaseModel):
  42.     output:str
  44. add_routes(
  45.     app,
  46.     agent_executor.with_types(input_type=Input, output_type=Output),
  47.     path="/agent",)if __name__ =="__main__":import uvicorn
  49.     uvicorn.run(app, host="localhost", port=8000)
复制代码
到此为止！如果我们执行这个文件：
  1. python serve.py
复制代码
我们应该可以在 localhost:8000 看到我们的链正在提供服务。
游乐场

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

现在让我们为与我们的服务进行程序化交互设置一个客户端。我们可以很容易地使用 langserve.RemoteRunnable 来实现这一点。
使用这个，我们可以像在客户端运行一样与提供的链进行交互。
  1. from langserve import RemoteRunnable
  3. remote_chain = RemoteRunnable("http://localhost:8000/agent/")
  4. remote_chain.invoke({"input":"how can langsmith help with testing?","chat_history":[]# 提供一个空列表，因为这是第一次调用})
复制代码
要了解更多关于 LangServe 的其他功能，请点击这里。
下一步

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

原文地址：https://blog.csdn.net/wjjc1017/article/details/136770349



欢迎光临 AI创想 (https://llms-ai.com/) Powered by Discuz! X3.4