AI创想

标题: LangChain 中文入门教程 [打印本页]
作者: admin    时间: 16 小时前
标题: LangChain 中文入门教程
文章目录


LangChain 中文入门教程

colab地址（包含本文所有案例）、gitbook（方便阅读）、github地址
  如果想把 OPENAI API 的请求根路由修改成自己的代理地址，可以通过设置环境变量 “OPENAI\_API\_BASE” 来进行修改，参考代码。或在初始化OpenAI相关模型对象时，传入“openai_api_base” 变量，参考代码。
一、介绍

LangChain官方文档
1.1 背景

  众所周知 OpenAI 的 API 无法联网的，所以如果只使用自己的功能实现联网搜索并给出回答、总结 PDF 文档、基于某个 Youtube 视频进行问答等等的功能肯定是无法实现的。所以，我们来介绍一个非常强大的第三方开源库：LangChain 。
LangChain 是一个用于开发由语言模型驱动的应用程序的框架。他主要拥有 2 个能力：
1.2 基础功能

Prompt管理，支持各种自定义模板
拥有大量的文档加载器，比如 Email、Markdown、PDF、Youtube …
对索引的支持
Chains
二、必知概念

  相信大家看完上面的介绍多半会一脸懵逼。不要担心，上面的概念其实在刚开始学的时候不是很重要，当我们讲完后面的例子之后，在回来看上面的内容会一下明白很多。但是，下面几个概念是必须知道的。
2.1 Loader 加载器

Loader文档
顾名思义，这个就是从指定源进行加载数据的。比如：
上面只是简单的进行列举了几个，官方提供了超级的多的加载器供你使用。
2.2 Document 文档

  当使用loader加载器读取到数据源后，数据源需要转换成 Document 对象后，后续才能进行使用。
2.3 Text Spltters 文本分割

  顾名思义，文本分割就是用来分割文本的。为什么需要分割文本？因为我们每次不管是做把文本当作 prompt 发给 openai api ，还是还是使用 openai api embedding 功能都是有字符限制的。
  比如我们将一份300页的 pdf 发给 openai api，让他进行总结，他肯定会报超过最大 Token 错。所以这里就需要使用文本分割器去分割我们 loader 进来的 Document。
2.4 Vectorstores 向量数据库

Vectorstores文档
  因为数据相关性搜索其实是向量运算。所以，不管我们是使用 openai api embedding 功能还是直接通过向量数据库直接查询，都需要将我们的加载进来的数据 Document 进行向量化，才能进行向量运算搜索。转换成向量也很简单，只需要我们把数据存储到对应的向量数据库中即可完成向量的转换。官方也提供了很多的向量数据库供我们使用。
2.5 Chain（链）

Chains文档
  我们可以把 Chain 理解为任务。一个 Chain 就是一个任务，当然也可以像链条一样，一个一个的执行多个链。
2.6 Agent 代理

  我们可以简单的理解为他可以动态的帮我们选择和调用chain或者已有的工具，执行过程可以参考下面这张图：


2.7 Embedding

  Embedding用于衡量文本的相关性，这个也是 OpenAI API 能实现构建自己知识库的关键所在。相比 fine-tuning 最大的优势就是，不用进行训练，并且可以实时添加新的内容，而不用加一次新的内容就训练一次，并且各方面成本要比 fine-tuning 低很多。具体比较和选择可以参考此视频。
三、实战

  下面使用Open AI 范例进行说明，大家也可以根据自己任务的需要换成自己需要的 LLM 模型。
3.1 单次问答

  在开始之前，我们需要先设置我们的 openai 的 key，这个 key 可以在用户管理里面创建，这里就不细说了。
  1. import os
  2. os.environ["OPENAI_API_KEY"]='你的api key'
复制代码
然后，我们进行导入和执行
  1. from langchain.llms import OpenAI

  3. llm = OpenAI(model_name="text-davinci-003",max_tokens=1024)
  4. llm("怎么评价人工智能")
复制代码


这时，我们就可以看到他给我们的返回结果了，怎么样，是不是很简单。
3.2 通过 Google 搜索并返回答案

  接下来，我们就来搞点有意思的。我们来让我们的 OpenAI api 联网搜索，并返回答案给我们。
  这里我们需要借助 Serpapi 来进行实现，Serpapi 提供了 google 搜索的 api 接口。首先需要我们到 Serpapi官网上注册一个用户，并复制他给我们生成 api key。然后我们需要像上面的 openai api key 一样设置到环境变量里面去。
serpapi 貌似对中文不是很友好，所以提问的 prompt 建议使用英文。
  1. import os
  2. os.environ["OPENAI_API_KEY"]='你的api key'
  3. os.environ["SERPAPI_API_KEY"]='你的api key'
复制代码
然后，开始编写我的代码
  1. from langchain.agents import load_tools
  2. from langchain.agents import initialize_agent
  3. from langchain.llms import OpenAI
  4. from langchain.agents import AgentType

  6. # 加载 OpenAI 模型
  7. llm = OpenAI(temperature=0,max_tokens=2048)# 加载 serpapi 工具
  8. tools = load_tools(["serpapi"])# 如果搜索完想再计算一下可以这么写# tools = load_tools(['serpapi', 'llm-math'], llm=llm)# 如果搜索完想再让他再用python的print做点简单的计算，可以这样写# tools=load_tools(["serpapi","python_repl"])# 工具加载后都需要初始化，verbose 参数为 True，会打印全部的执行详情
  9. agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)# 运行 agent
  10. agent.run("What's the date today? What great events have taken place today in history?")
复制代码


  我们可以看到，他正确的返回了日期（有时差），并且返回了历史上的今天。
  在 chain 和 agent 对象上都会有 verbose 这个参数，这个是个非常有用的参数，开启他后我们可以看到完整的 chain 执行过程。可以在上面返回的结果看到，他将我们的问题拆分成了几个步骤，然后一步一步得到最终的答案。
关于agent type 几个选项的含义（理解不了也不会影响下面的学习，用多了自然理解了）：
LLM 的 ReAct 模式的 Python 实现: https://til.simonwillison.net/llms/python-react-pattern
  当然，官方已经写好了 ChatGPT Plugins 的 agent，未来 chatgpt 能用啥插件，我们在 api 里面也能用插件，想想都美滋滋。不过目前只能使用不用授权的插件，期待未来官方解决这个，感兴趣的可以看此文档。
Chatgpt 只能给官方赚钱，而 Openai API 能给我赚钱
3.3 对超长文本进行总结

  假如我们想要用 openai api 对一段文本进行总结，我们通常的做法就是直接发给 api 让他总结。但是如果文本超过了 api 最大的 token 限制就会报错。
  这时，我们一般会进行对文章进行分段，比如通过 tiktoken 计算并分割，然后将各段发送给 api 进行总结，最后将各段的总结再进行一个全部的总结。
   LangChain可以很好的帮我们处理这个过程，代码也很简单。
  1. from langchain.document_loaders import UnstructuredFileLoader
  2. from langchain.chains.summarize import load_summarize_chain
  3. from langchain.text_splitter import RecursiveCharacterTextSplitter
  4. from langchain import OpenAI

  6. # 导入文本
  7. loader = UnstructuredFileLoader("/content/sample_data/data/lg_test.txt")# 将文本转成 Document 对象
  8. document = loader.load()print(f'documents:{len(document)}')# 初始化文本分割器
  9. text_splitter = RecursiveCharacterTextSplitter(
  10.     chunk_size =500,
  11.     chunk_overlap =0)# 切分文本
  12. split_documents = text_splitter.split_documents(document)print(f'documents:{len(split_documents)}')# 加载 llm 模型
  13. llm = OpenAI(model_name="text-davinci-003", max_tokens=1500)# 创建总结链
  14. chain = load_summarize_chain(llm, chain_type="refine", verbose=True)# 执行总结链，（为了快速演示，只总结前5段）
  15. chain.run(split_documents[:5])
复制代码
  首先我们对切割前和切割后的 document 个数进行了打印，我们可以看到，切割前就是只有整篇的一个 document，切割完成后，会把上面一个 document 切成 317 个 document。


最终输出了对前 5 个 document 的总结。


这里有几个参数需要注意：
1. 文本分割器的 chunk_overlap 参数
  这个是指切割后的每个 document 里包含几个上一个 document 结尾的内容，主要作用是为了增加每个 document 的上下文关联。比如，chunk_overlap=0时， 第一个 document 为 aaaaaa，第二个为 bbbbbb；当 chunk_overlap=2 时，第一个 document 为 aaaaaa，第二个为 aabbbbbb。不过，这个也不是绝对的，要看所使用的那个文本分割模型内部的具体算法。
文本分割器参考此文档
2. chain 的 chain_type 参数
这个参数主要控制了将 document 传递给 llm 模型的方式，一共有 4 种方式：




3.4 构建本地知识库问答机器人

Openai embeddings文档
  在这个例子中，我们会介绍如何从我们本地读取多个文档构建知识库，并且使用 Openai API 在知识库中进行搜索并给出答案。这个是个很有用的教程，比如可以很方便的做一个可以介绍公司业务的机器人，或是介绍一个产品的机器人。
  1. from langchain.embeddings.openai import OpenAIEmbeddings
  2. from langchain.vectorstores import Chroma
  3. from langchain.text_splitter import CharacterTextSplitter
  4. from langchain import OpenAI,VectorDBQA
  5. from langchain.document_loaders import DirectoryLoader
  6. from langchain.chains import RetrievalQA

  8. # 加载文件夹中的所有txt类型的文件
  9. loader = DirectoryLoader('/content/sample_data/data/', glob='**/*.txt')# 将数据转成 document 对象，每个文件会作为一个 document
  10. documents = loader.load()# 初始化加载器
  11. text_splitter = CharacterTextSplitter(chunk_size=100, chunk_overlap=0)# 切割加载的 document
  12. split_docs = text_splitter.split_documents(documents)# 初始化 openai 的 embeddings 对象
  13. embeddings = OpenAIEmbeddings()# 将 document 通过 openai 的 embeddings 对象计算 embedding 向量信息并临时存入 Chroma 向量数据库，用于后续匹配查询
  14. docsearch = Chroma.from_documents(split_docs, embeddings)# 创建问答对象
  15. qa = VectorDBQA.from_chain_type(llm=OpenAI(), chain_type="stuff", vectorstore=docsearch,return_source_documents=True)# 进行问答
  16. result = qa({"query":"科大讯飞今年第一季度收入是多少？"})print(result)
复制代码


我们可以通过结果看到，他成功的从我们的给到的数据中获取了正确的答案。
3.5 构建向量索引数据库

  我们上个案例里面有一步是将 document 信息转换成向量信息，和embeddings的信息并临时存入 Chroma 数据库。因为是临时存入，所以当我们上面的代码执行完成后，上面的向量化后的数据将会丢失。如果想下次使用，那么就还需要再计算一次embeddings，这肯定不是我们想要的。
  本案例，我们通过 Chroma 和 Pinecone 这两个数据库，来讲一下如何做向量数据持久化。更多 LangChain 数据库，参考此文档。
1. Chroma
  chroma 是个本地的向量数据库，他提供的一个 persist_directory 来设置持久化目录进行持久化。读取时，只需要调取 from_document 方法加载即可。
  1. from langchain.vectorstores import Chroma

  3. # 持久化数据
  4. docsearch = Chroma.from_documents(documents, embeddings, persist_directory="D:/vector_store")
  5. docsearch.persist()# 加载数据
  6. docsearch = Chroma(persist_directory="D:/vector_store", embedding_function=embeddings)
复制代码
2. Pinecone
  Pinecone是一个在线的向量数据库。所以，我可以第一步依旧是注册，然后拿到对应的 api key。（免费版如果索引14天不使用会被自动清除。）
然后创建我们的数据库：
持久化数据和加载数据代码如下
  1. # 持久化数据
  2. docsearch = Pinecone.from_texts([t.page_content for t in split_docs], embeddings, index_name=index_name)# 加载数据
  3. docsearch = Pinecone.from_existing_index(index_name, embeddings)
复制代码
一个简单从数据库获取 embeddings并回答的代码如下
  1. from langchain.text_splitter import CharacterTextSplitter
  2. from langchain.document_loaders import DirectoryLoader
  3. from langchain.vectorstores import Chroma, Pinecone
  4. from langchain.embeddings.openai import OpenAIEmbeddings
  5. from langchain.llms import OpenAI
  6. from langchain.chains.question_answering import load_qa_chain

  8. import pinecone

  10. # 初始化 pinecone
  11. pinecone.init(
  12.   api_key="你的api key",
  13.   environment="你的Environment")

  15. loader = DirectoryLoader('/content/sample_data/data/', glob='**/*.txt')# 将数据转成 document 对象，每个文件会作为一个 document
  16. documents = loader.load()# 初始化加载器
  17. text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=0)# 切割加载的 document
  18. split_docs = text_splitter.split_documents(documents)

  20. index_name="liaokong-test"# 持久化数据# docsearch = Pinecone.from_texts([t.page_content for t in split_docs], embeddings, index_name=index_name)# 加载数据
  21. docsearch = Pinecone.from_existing_index(index_name,embeddings)

  23. query ="科大讯飞今年第一季度收入是多少？"
  24. docs = docsearch.similarity_search(query, include_metadata=True)

  26. llm = OpenAI(temperature=0)
  27. chain = load_qa_chain(llm, chain_type="stuff", verbose=True)
  28. chain.run(input_documents=docs, question=query)
复制代码


3.6 使用GPT3.5模型构建油管频道问答机器人

  在 chatgpt api（也就是 GPT-3.5-Turbo）模型出来后，因钱少活好深受大家喜爱，所以 LangChain 也加入了专属的链和模型，我们来跟着这个例子看下如何使用他。
  1. import os

  3. from langchain.document_loaders import YoutubeLoader
  4. from langchain.embeddings.openai import OpenAIEmbeddings
  5. from langchain.vectorstores import Chroma
  6. from langchain.text_splitter import RecursiveCharacterTextSplitter
  7. from langchain.chains import ChatVectorDBChain, ConversationalRetrievalChain

  9. from langchain.chat_models import ChatOpenAI
  10. from langchain.prompts.chat import(
  11.   ChatPromptTemplate,
  12.   SystemMessagePromptTemplate,
  13.   HumanMessagePromptTemplate
  14. )# 加载 youtube 频道
  15. loader = YoutubeLoader.from_youtube_url('https://www.youtube.com/watch?v=Dj60HHy-Kqk')# 将数据转成 document
  16. documents = loader.load()# 初始化文本分割器
  17. text_splitter = RecursiveCharacterTextSplitter(
  18.   chunk_size=1000,
  19.   chunk_overlap=20)# 分割 youtube documents
  20. documents = text_splitter.split_documents(documents)# 初始化 openai embeddings
  21. embeddings = OpenAIEmbeddings()# 将数据存入向量存储
  22. vector_store = Chroma.from_documents(documents, embeddings)# 通过向量存储初始化检索器
  23. retriever = vector_store.as_retriever()

  25. system_template ="""
  26. Use the following context to answer the user's question.
  27. If you don't know the answer, say you don't, don't try to make it up. And answer in Chinese.
  28. -----------
  29. {context}
  30. -----------
  31. {chat_history}
  32. """# 构建初始 messages 列表，这里可以理解为是 openai 传入的 messages 参数
  33. messages =[
  34.   SystemMessagePromptTemplate.from_template(system_template),
  35.   HumanMessagePromptTemplate.from_template('{question}')]# 初始化 prompt 对象
  36. prompt = ChatPromptTemplate.from_messages(messages)# 初始化问答链
  37. qa = ConversationalRetrievalChain.from_llm(ChatOpenAI(temperature=0.1,max_tokens=2048),retriever,condense_question_prompt=prompt)


  40. chat_history =[]whileTrue:
  41.   question =input('问题：')# 开始发送问题 chat_history 为必须参数,用于存储对话历史
  42.   result = qa({'question': question,'chat_history': chat_history})
  43.   chat_history.append((question, result['answer']))print(result['answer'])
复制代码
我们可以看到他能很准确的围绕这个油管视频进行问答


使用流式回答也很方便
  1. from langchain.callbacks.base import CallbackManager
  2. from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

  4. chat = ChatOpenAI(streaming=True, callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]), verbose=True, temperature=0)
  5. resp = chat(chat_prompt_with_values.to_messages())
复制代码
3.7 用 OpenAI 连接万种工具

  我们主要是结合使用 zapier来实现将万种工具连接起来。所以我们第一步依旧是需要申请账号和他的自然语言 api key。zapier api key 填入基础信息后，基本可以秒在邮箱里看到审核通过的邮件。
  然后，我们通过右键里面的连接打开我们的api 配置页面。我们点击右侧的 Manage Actions 来配置我们要使用哪些应用。我在这里配置了 Gmail 读取和发邮件的 action，并且所有字段都选的是通过 AI 猜。




配置好后，我们开始写代码
  1. import os
  2. os.environ["ZAPIER_NLA_API_KEY"]=''
复制代码
  1. from langchain.llms import OpenAI
  2. from langchain.agents import initialize_agent
  3. from langchain.agents.agent_toolkits import ZapierToolkit
  4. from langchain.utilities.zapier import ZapierNLAWrapper


  7. llm = OpenAI(temperature=.3)
  8. zapier = ZapierNLAWrapper()
  9. toolkit = ZapierToolkit.from_zapier_nla_wrapper(zapier)
  10. agent = initialize_agent(toolkit.get_tools(), llm, agent="zero-shot-react-description", verbose=True)# 我们可以通过打印的方式看到我们都在 Zapier 里面配置了哪些可以用的工具for tool in toolkit.get_tools():print(tool.name)print(tool.description)print("\n\n")

  12. agent.run('请用中文总结最后一封"******@qq.com"发给我的邮件。并将总结发送给"******@qq.com"')
复制代码


  我们可以看到他成功读取了******@qq.com给他发送的最后一封邮件，并将总结的内容又发送给了******@qq.com。这是我发送给 Gmail 的邮件：


这是他发送给 QQ 邮箱的邮件：



  这只是个小例子，因为 zapier 有数以千计的应用，所以我们可以轻松结合 openai api 搭建自己的工作流。
  主要知识点已经讲完了，下面用一些比较有趣的小例子，当作拓展延伸。
四、小例子

4.1 执行多个chain

LangChain是链式的，所以他也可以按顺序依次去执行多个 chain：
  1. from langchain.llms import OpenAI
  2. from langchain.chains import LLMChain
  3. from langchain.prompts import PromptTemplate
  4. from langchain.chains import SimpleSequentialChain

  6. # location 链
  7. llm = OpenAI(temperature=1)
  8. template ="""Your job is to come up with a classic dish from the area that the users suggests.
  9. % USER LOCATION
  10. {user_location}

  12. YOUR RESPONSE:
  13. """
  14. prompt_template = PromptTemplate(input_variables=["user_location"], template=template)
  15. location_chain = LLMChain(llm=llm, prompt=prompt_template)# meal 链
  16. template ="""Given a meal, give a short and simple recipe on how to make that dish at home.
  17. % MEAL
  18. {user_meal}

  20. YOUR RESPONSE:
  21. """
  22. prompt_template = PromptTemplate(input_variables=["user_meal"], template=template)
  23. meal_chain = LLMChain(llm=llm, prompt=prompt_template)# 通过 SimpleSequentialChain 串联起来，第一个答案会被替换第二个中的user_meal，然后再进行询问
  24. overall_chain = SimpleSequentialChain(chains=[location_chain, meal_chain], verbose=True)
  25. review = overall_chain.run("Rome")
复制代码


4.2 结构化输出

有时候我们希望输出的内容不是文本，而是像 json 那样结构化的数据。
  1. from langchain.output_parsers import StructuredOutputParser, ResponseSchema
  2. from langchain.prompts import PromptTemplate
  3. from langchain.llms import OpenAI

  5. llm = OpenAI(model_name="text-davinci-003")# 告诉他我们生成的内容需要哪些字段，每个字段类型式啥
  6. response_schemas =[
  7.     ResponseSchema(name="bad_string", description="This a poorly formatted user input string"),
  8.     ResponseSchema(name="good_string", description="This is your response, a reformatted response")]# 初始化解析器
  9. output_parser = StructuredOutputParser.from_response_schemas(response_schemas)# 生成的格式提示符# {#        "bad_string": string  // This a poorly formatted user input string#        "good_string": string  // This is your response, a reformatted response#}
  10. format_instructions = output_parser.get_format_instructions()

  12. template ="""
  13. You will be given a poorly formatted string from a user.
  14. Reformat it and make sure all the words are spelled correctly

  16. {format_instructions}

  18. % USER INPUT:
  19. {user_input}

  21. YOUR RESPONSE:
  22. """# 将我们的格式描述嵌入到 prompt 中去，告诉 llm 我们需要他输出什么样格式的内容
  23. prompt = PromptTemplate(
  24.     input_variables=["user_input"],
  25.     partial_variables={"format_instructions": format_instructions},
  26.     template=template
  27. )

  29. promptValue = prompt.format(user_input="welcom to califonya!")
  30. llm_output = llm(promptValue)# 使用解析器进行解析生成的内容
  31. output_parser.parse(llm_output)
复制代码


4.3 爬取网页并输出JSON数据

  有些时候我们需要爬取一些结构性比较强的网页，并且需要将网页中的信息以JSON的方式返回回来。我们就可以使用 LLMRequestsChain 类去实现，具体可以参考下面代码
为了方便理解，我在例子中直接使用了Prompt的方法去格式化输出结果，而没用使用上个案例中用到的 StructuredOutputParser去格式化，也算是提供了另外一种格式化的思路
  1. from langchain.prompts import PromptTemplate
  2. from langchain.llms import OpenAI
  3. from langchain.chains import LLMRequestsChain, LLMChain

  5. llm = OpenAI(model_name="gpt-3.5-turbo", temperature=0)

  7. template ="""在 >>> 和 <<< 之间是网页的返回的HTML内容。
  8. 网页是新浪财经A股上市公司的公司简介。
  9. 请抽取参数请求的信息。

  11. >>> {requests_result} <<<
  12. 请使用如下的JSON格式返回数据
  13. {{
  14.   "company_name":"a",
  15.   "company_english_name":"b",
  16.   "issue_price":"c",
  17.   "date_of_establishment":"d",
  18.   "registered_capital":"e",
  19.   "office_address":"f",
  20.   "Company_profile":"g"

  22. }}
  23. Extracted:"""

  25. prompt = PromptTemplate(
  26.     input_variables=["requests_result"],
  27.     template=template
  28. )

  30. chain = LLMRequestsChain(llm_chain=LLMChain(llm=llm, prompt=prompt))
  31. inputs ={"url":"https://vip.stock.finance.sina.com.cn/corp/go.php/vCI_CorpInfo/stockid/600519.phtml"}

  33. response = chain(inputs)print(response['output'])
复制代码
我们可以看到，他很好的将格式化后的结果输出了出来


4.4 自定义agent中所使用的工具

  1. from langchain.agents import initialize_agent, Tool
  2. from langchain.agents import AgentType
  3. from langchain.tools import BaseTool
  4. from langchain.llms import OpenAI
  5. from langchain import LLMMathChain, SerpAPIWrapper

  7. llm = OpenAI(temperature=0)# 初始化搜索链和计算链
  8. search = SerpAPIWrapper()
  9. llm_math_chain = LLMMathChain(llm=llm, verbose=True)# 创建一个功能列表，指明这个 agent 里面都有哪些可用工具，agent 执行过程可以看必知概念里的 Agent 那张图
  10. tools =[
  11.     Tool(
  12.         name ="Search",
  13.         func=search.run,
  14.         description="useful for when you need to answer questions about current events"),
  15.     Tool(
  16.         name="Calculator",
  17.         func=llm_math_chain.run,
  18.         description="useful for when you need to answer questions about math")]# 初始化 agent
  19. agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)# 执行 agent
  20. agent.run("Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?")
复制代码


  自定义工具里面有个比较有意思的地方，使用哪个工具的权重是靠 工具中描述内容 来实现的，和我们之前编程靠数值来控制权重完全不同。
  比如 Calculator 在描述里面写到，如果你问关于数学的问题就用他这个工具。我们就可以在上面的执行过程中看到，他在我们请求的 prompt 中数学的部分，就选用了Calculator 这个工具进行计算。
4.5 使用Memory实现一个带记忆的对话机器人

  上一个例子我们使用的是通过自定义一个列表来存储对话的方式来保存历史的。当然，你也可以使用自带的 memory 对象来实现这一点。
  1. from langchain.memory import ChatMessageHistory
  2. from langchain.chat_models import ChatOpenAI

  4. chat = ChatOpenAI(temperature=0)# 初始化 MessageHistory 对象
  5. history = ChatMessageHistory()# 给 MessageHistory 对象添加对话内容
  6. history.add_ai_message("你好！")
  7. history.add_user_message("中国的首都是哪里？")# 执行对话
  8. ai_response = chat(history.messages)print(ai_response)
复制代码
4.6 使用 Hugging Face 模型

使用 Hugging Face 模型之前，需要先设置环境变量
  1. import os
  2. os.environ['HUGGINGFACEHUB_API_TOKEN']=''
复制代码
使用在线的 Hugging Face 模型
  1. from langchain import PromptTemplate, HuggingFaceHub, LLMChain

  3. template ="""Question: {question}
  4. Answer: Let's think step by step."""

  6. prompt = PromptTemplate(template=template, input_variables=["question"])
  7. llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature":0,"max_length":64})
  8. llm_chain = LLMChain(prompt=prompt, llm=llm)

  10. question ="What NFL team won the Super Bowl in the year Justin Beiber was born?"print(llm_chain.run(question))
复制代码
将 Hugging Face 模型直接拉到本地使用
  1. from langchain import PromptTemplate, LLMChain
  2. from langchain.llms import HuggingFacePipeline
  3. from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, AutoModelForSeq2SeqLM

  5. model_id ='google/flan-t5-large'
  6. tokenizer = AutoTokenizer.from_pretrained(model_id)
  7. model = AutoModelForSeq2SeqLM.from_pretrained(model_id)

  9. pipe = pipeline("text2text-generation",
  10.     model=model,
  11.     tokenizer=tokenizer,
  12.     max_length=100)

  14. local_llm = HuggingFacePipeline(pipeline=pipe)print(local_llm('What is the capital of France? '))


  17. template ="""Question: {question} Answer: Let's think step by step."""
  18. prompt = PromptTemplate(template=template, input_variables=["question"])

  20. llm_chain = LLMChain(prompt=prompt, llm=local_llm)
  21. question ="What is the capital of England?"print(llm_chain.run(question))
复制代码
将模型拉到本地使用的好处：
4.7 通过自然语言执行SQL命令

参考教程《Spark SQL Agent》、《SQL Database Agent》
我们通过 SQLDatabaseToolkit 或者 SQLDatabaseChain 都可以实现执行SQL命令的操作
  1. from langchain.agents import create_sql_agent
  2. from langchain.agents.agent_toolkits import SQLDatabaseToolkit
  3. from langchain.sql_database import SQLDatabase
  4. from langchain.llms.openai import OpenAI

  6. db = SQLDatabase.from_uri("sqlite:///../notebooks/Chinook.db")
  7. toolkit = SQLDatabaseToolkit(db=db)

  9. agent_executor = create_sql_agent(
  10.     llm=OpenAI(temperature=0),
  11.     toolkit=toolkit,
  12.     verbose=True)

  14. agent_executor.run("Describe the playlisttrack table")
复制代码
  1. from langchain import OpenAI, SQLDatabase, SQLDatabaseChain

  3. db = SQLDatabase.from_uri("mysql+pymysql://root:root@127.0.0.1/chinook")
  4. llm = OpenAI(temperature=0)

  6. db_chain = SQLDatabaseChain(llm=llm, database=db, verbose=True)
  7. db_chain.run("How many employees are there?")
复制代码
五、总结

  所有的案例都基本已经结束了，希望大家能通过这篇文章的学习有所收获。这篇文章只是对 LangChain 一个初级的讲解，高级的功能希望大家继续探索。希望大家能结合 LangChain 开发出更有创意的产品，而不仅仅只搞一堆各种一键搭建chatgpt聊天客户端的那种产品。

原文链接：https://github.com/liaokongVFX/LangChain-Chinese-Getting-Started-Guide




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