openai api key 有甚么用的进一步展开说明

# 构建知识库的问答机器人 – LangChain 入门指南

## 介绍
在本篇指南中，我们将为大家介绍如何构建一个知识库的问答机器人，让机器人能够根据用户提出的问题从知识库中搜索并给出答案。我们将使用一个强大的第三方开源库——LangChain。

LangChain是一个用于开发语言模型驱动利用程序的框架，具有以下两个主要功能：

1. 可以将语言模型与外部数据源进行连接。
2. 允许与语言模型进行交互。

语言模型（LLM）：Large Language Model，大型语言模型。

## 基础功能
LangChain提供了一系列基础功能，包括：

1. LLM调用：支持多种模型接口，如OpenAI、HuggingFace、AzureOpenAI等。
2. 支持摹拟LLM，用于测试。
3. 支持缓存，如in-mem（内存）、SQLite、Redis、SQL等。
4. 用量记录。
5. 支持流模式，可以逐字返回结果，类似打字效果。
6. Prompt管理，支持各种自定义模板。
7. 提供大量的文档加载器，如Email、Markdown、PDF、Youtube等。
8. 支持对索引的操作。
9. 文档分割器。
10. 向量化。
11. 支持向量存储和搜索，如Chroma、Pinecone、Qdrand等。
12. Chains：包括LLMChain、各种工具Chain、LangChainHub等。

## 必知概念
在浏览上述介绍时，可能会有点摸不着头脑。但是不用担心，这些概念在后续的例子中会有更加详细的解释。

但是，这里有几个概念是一定要知道的：
1. Loader 加载器：用于从指定源加载数据。LangChain提供了多种加载器供您使用，如文件夹加载器、Azure存储加载器、CSV文件加载器、EverNote加载器、Google Drive加载器、任意网页加载器、PDF加载器、S3加载器、Youtube加载器等。
2. Document 文档：在使用加载器加载数据源后，数据源需要转换为Document对象，以便进行后续处理。
3. Text Splitters 文本分割器：用于分割文本。由于在进行一些操作时，文本常常有字符限制，所以需要对文本进行分割。
4. Vectorstores 向量数据库：由于数据相关性搜索实际上是向量运算，所以不管是使用OpenAI的embedding功能或者直接通过向量数据库进行查询，都需要将加载的数据转换为向量进行运算。LangChain提供了多种矢量数据库供您选择，如Chroma、Pinecone、Qdrand等。
5. Chain 链：将Chain视为任务。一个Chain就是一个任务，可以像链条一样顺次履行多个链。
6. Agent 代理：代理可以动态地帮助我们选择和调用chain或已有的工具。

## 完成一次问答
让我们从一个简单的例子开始，使用LangChain加载OpenAI模型，并完成一次问答。

在开始之前，我们需要设置OpenAI的API密钥，您可以在用户管理中创建API密钥。

“`python
import os
os.environ[“OPENAI_API_KEY”] = ‘YOUR API KEY’
“`

然后，我们导入所需的库并履行代码：

“`python
from langchain.llms import OpenAI

llm = OpenAI(model_name=”text-davinci-003″, max_tokens=1024)
llm(“What’s your evaluation of artificial intelligence?”)
“`

通过以上代码，我们可以获得到答案。这很简单吧。

## 通过Google搜索并返回答案
接下来，我们尝试一些有趣的功能。让我们让OpenAI API联网搜索，并将搜索结果返回给我们。

为了实现这个功能，我们借助了Serpapi来进行实现，Serpapi提供了Google搜索的API接口。

首先，我们需要注册一个Serpapi帐号，并复制生成的API密钥。

然后，我们将API密钥设置为环境变量，与上面的OpenAI API密钥设置相同。

“`python
import os
os.environ[“OPENAI_API_KEY”] = ‘YOUR OPENAI API KEY’
os.environ[“SERPAPI_API_KEY”] = ‘YOUR SERPAPI API KEY’
“`

接下来，我们开始编写我们的代码：

“`python
from langchain.agents import load_tools, initialize_agent
from langchain.llms import OpenAI
from langchain.agents import AgentType

# 加载 OpenAI 模型
llm = OpenAI(temperature=0, max_tokens=2048)

# 加载 serpapi 工具
tools = load_tools([“serpapi”])

# 工具加载后需要初始化，verbose 参数为 True，会打印全部的履行详情
agent = initialize_agent(tools, llm, agent=AgentType.SELF_ASK_WITH_SEARCH, verbose=True)

# 运行 agent
agent.run(“What’s the date today? What great events have taken place today in history?”)
“`

我们可以看到，它正确地返回了日期（可能有时差），并返回了历史上的今天的重大事件。

对agent类型的几个选项的含义（如果不能理解也不会影响后续学习，随着使用的次数增多，自然就会理解）：

– zero-shot-react-description: 根据工具的描写和要求内容来决定使用哪一个工具（最经常使用）
– react-docstore: 使用ReAct框架和docstore交互, 使用Search和Lookup工具, 前者用来搜索, 后者用来寻觅term, 例如Wikipedia工具
– self-ask-with-search:此代理只使用一个工具，Intermediate Answer，它会为问题查找事实答案（即非由GPT生成的答案，而是文本中已存在的答案），例如Google搜索API工具
– conversational-react-description: 为会话设置而设计的代理，其提示被设计为具有会话性，同时使用ReAct框架来决定使用哪一个工具，并将过去的对话交互存储在内存中。

固然，官方已为ChatGPT Plugins编写了agent，将来ChatGPT可使用哪些插件，我们在API中也能够使用插件，一想到这个，我就开心。

不过目前只能使用无需授权的插件，希望官方以后能解决这个问题。

如果你感兴趣，可以看一下这个文档：https://python.langchain.com/en/latest/modules/agents/tools/examples/chatgpt_plugins.html

Chatgpt只能让Openai赚钱，而Openai API可让我们赚钱。

## 对超长文本进行总结
假定我们想要使用Openai API对一个段落文本进行总结，我们通常会直接将文本发送给API进行总结。但是，如果文本超过API的最大token限制，就会报错。

这时候，我们通常会将文章分段，比如使用tiktoken计算并切割，然后将每段文本发送给API进行总结，最后将每段的总结再进行整体总结。

但是，如果你使用LangChain，它可以帮助我们很好地处理这个进程，使我们编写代码变得非常简单。

空话不多说，直接上代码：

“`python
from langchain.document_loaders import UnstructuredFileLoader
from langchain.chains.summarize import load_summarize_chain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain import OpenAI, VectorDBQA

# 加载文件夹中的所有txt类型的文件
loader = UnstructuredFileLoader(“/content/sample_data/data/lg_test.txt”)

# 将文本转成 Document 对象
document = loader.load()
print(f’documents:{len(document)}’)

# 初始化文本分割器
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)

# 切割文本
split_documents = text_splitter.split_documents(document)
print(f’documents:{len(split_documents)}’)

# 加载 llm 模型
llm = OpenAI(model_name=”text-davinci-003″, max_tokens=1500)

# 创建总结链
chain = load_summarize_chain(llm, chain_type=”refine”, verbose=True)

# 履行总结链，（为了快速演示，只总结前5段）
chain.run(split_documents[:5])
“`

首先，我们打印了分割前后的document数量，可以看到分割前只有一个完全的document，分割后共切割出了317个document。

最后，我们展现了对前5个document进行的总结。

在结果中，可以看到它成功地在我们提供的数据中找到正确的答案。

## 构建本地知识库问答机器人
在本例中，我们将展现怎么从本地读取多个文档构建知识库，并使用Openai API在知识库中进行搜索并给出答案。

这是一个非常实用的教程，比如可以很方便地构建一个能介绍公司业务的机器人，或介绍一个产品的机器人。

“`python
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain.document_loaders import DirectoryLoader

# 加载文件夹中的所有txt类型的文件
loader = DirectoryLoader(‘/content/sample_data/data/’, glob=’**/*.txt’)

# 将数据转成 document 对象，每一个文件会作为一个 document
documents = loader.load()

# 初始化文本分割器
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=0)

# 切割加载的 document
split_docs = text_splitter.split_documents(documents)

index_name = “knowledge-base”

# 持久化数据
# docsearch = Pinecone.from_texts([t.page_content for t in split_docs], embeddings, index_name=index_name)

# 加载数据
docsearch = Pinecone.from_existing_index(index_name, embeddings)

# 获得用户的问题
query = “科大讯飞今年第一季度收入是多少？”

# 在知识库中进行检索
docs = docsearch.similarity_search(query, include_metadata=True)

llm = OpenAI(temperature=0)

# 创建问答对象
qa = RetrievalQA(llm, vectorstore=docsearch, return_source_documents=True)

# 进行问答
result = qa({“query”: query})

print(result)
“`

我们可以从结果中看到，它成功地从我们提供的数据中获得了正确的答案。

## 构建向量索引数据库
在上一个例子中，我们通过Chroma和Pinecone这两个数据库来展现了如何持久化向量化的数据。

由于Chroma是一个本地的向量数据库，所以很合适进行数据持久化。

对Pinecone，它是一个在线的向量数据库。所以我们需要先注册，并取得相应的API密钥。
接下来我们就能够创建数据库了：

“`python
# 持久化数据
docsearch = Pinecone.from_texts([t.page_content for t in split_docs], embeddings, index_name=index_name)

# 加载数据
docsearch = Pinecone.from_existing_index(index_name, embeddings)
“`

我们还可以以以下方式使用Pinecone：

“`python
import pinecone

# 初始化Pinecone
pinecone.init(api_key=”YOUR_API_KEY”, environment=”YOUR_ENVIRONMENT”)

# 持久化数据
docsearch = Pinecone.from_texts([t.page_content for t in split_docs], embeddings, index_name=index_name)

# 加载数据
docsearch = Pinecone.from_existing_index(index_name, embeddings)
“`

## 使用GPT3.5模型构建YouTube频道问答机器人
在ChatGPT API（也就是GPT⑶.5-Turbo）模型出来后，因其价格更低，而且表现优秀，深受大家爱好。因此LangChain也为其提供了特定的链和模型，让我们结合这个例子看看怎样使用它。

“`python
import os
from langchain.document_loaders import YoutubeLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import ChatVectorDBChain, ConversationalRetrievalChain
from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (
ChatPromptTemplate,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
)

# 加载 youtube 频道
loader = YoutubeLoader.from_youtube_channel(‘https://www.youtube.com/watch?v=Dj60HHy-Kqk’)

# 将数据转成 document 对象，每一个文件会作为一个 document
documents = loader.load()

# 初始化文本分割器
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=20)

# 分割 YouTube documents
split_docs = text_splitter.split_documents(documents)

# 初始化 openai embeddings
embeddings = OpenAIEmbeddings()

# 将数据存入向量存储
vector_store = Chroma.from_documents(split_docs, embeddings)

# 初始化对话向量检索器
retriever = vector_store.as_retriever()

# 构建初始 messages 列表
messages = [
SystemMessagePromptTemplate.from_template(system_template),
HumanMessagePromptTemplate.from_template(‘{question}’)
]

# 初始化提示符模板
prompt = ChatPromptTemplate.from_messages(messages)

# 通过向量存储初始化对话
qa = ConversationalRetrievalChain.from_llm(
ChatOpenAI(temperature=0.1, max_tokens=2048),
retriever,
qa_prompt=prompt
)

chat_history = []
while True:
question = input(‘问题：’)

# 开始发送问题
result = qa({‘question’: question, ‘chat_history’: chat_history})

chat_history.append((question, result[‘answer’]))
print(result[‘answer’])
“`

通过上面的代码，我们验证了它可以根据YouTube视频进行问答。

## 使用OpenAI连接各种工具
由于OpenAI API可以连接许多工具，我们可以很方便地使用它来搭建自己的工作流程。我们主要结合使用Zapier来实现连接。

首先，与上面的OpenAI API一样，您需要申请一个Zapier账号和自然语言Actions的API密钥。

“`python
import os
os.environ[“ZAPIER_NLA_API_KEY”] = ”

from langchain.llms import OpenAI
from langchain.agents import initialize_agent
from langchain.agents.agent_toolkits import ZapierToolkit
from langchain.utilities.zapier import ZapierNLAWrapper

llm = OpenAI(temperature=0)
zapier = ZapierNLAWrapper()
toolkit = ZapierToolkit.from_zapier_nla_wrapper(zapier)
agent = initialize_agent(tools=toolkit.get_tools(), llm=llm, agent=”zero-shot-react-description”, verbose=True)

# 查看工具列表
for tool in toolkit.get_tools():
print(tool.name)
print(tool.description)
print(“ ”)

agent.run(‘Who is Leo DiCaprio’s girlfriend? What is her current age raised to the 0.43 power?’)
“`

我们可以看到，它成功地发送了最后一封邮件给QQ邮箱，并将总结的内容发送给了另外一个QQ邮箱。

这只是一个小例子，由于Zapier具有数千个利用程序，所以我们可以很容易地结合OpenAI API来构建我们自己的工作流程。

一些有趣的技能

– 履行多个chain：我们可以按顺序履行多个chain，完成多个任务。
– 结构化输出：有时候，我们希望输出的结果不单单是文本，还包括结构化的数据。LangChain提供了输出解析器，可以将结果解析为结构化数据。

使用HuggingFace模型

在使用HuggingFace模型之前，我们需要设置环境变量。

“`python
import os
os.environ[‘HUGGINGFACEHUB_API_TOKEN’] = ”
“`

使用在线HuggingFace模型：
“`python
from langchain import PromptTemplate, HuggingFaceHub, LLMChain

template = “Question: {question} Answer: Let’s think step by step.”
prompt = PromptTemplate(template=template, input_variables=[“question”])

llm = HuggingFaceHub(repo_id=”google/flan-t5-xl”, model_kwargs={“temperature”: 0, “max_length”: 64})
llm_chain = LLMChain(prompt=prompt, llm=llm)

question = “What NFL team won the Super Bowl in the year Justin Beiber was born?”
print(llm_chain.run(question))
“`

将HuggingFace模型拉到本地使用：
“`python
from langchain.llms import HuggingFacePipeline
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, AutoModelForSeq2SeqLM

model_id = ‘google/flan-t5-large’
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForSeq2SeqLM.from_pretrained(model_id, load_in_8bit=True)
pipe = pipeline(“text2text-generation”, model=model, tokenizer=tokenizer, max_length=100)
local_llm = HuggingFacePipeline(pipeline=pipe)

print(local_llm(‘What is the capital of France? ‘))

llm_chain = LLMChain(prompt=prompt, llm=local_llm)
question = “What is the capital of England?”
print(llm_chain.run(question))
“`

将模型拉到本地使用的好处：
– 训练模型
– 利用本地GPU
– 一些模型在HuggingFace上没法运行

使用内存实现具有记忆的对话机器人

在上一个例子中，我们使用了自定义列表来保存对话历史。

但是，您也能够使用内存（memory）对象来实现。

“`python
from langchain.memory import ChatMessageHistory
from langchain.chat_models import ChatOpenAI

chat = ChatOpenAI(temperature=0)

# 初始化ChatMessageHistory对象
history = ChatMessageHistory()

# 添加对话内容到ChatMessageHistory对象
history.add_ai_message(“你好！”)
history.add_user_message(“中国的首都是哪里？”)

# 履行对话
ai_response = chat(history.messages)
print(ai_response)
“`

使用HuggingFace模型

“`python
from langchain import PromptTemplate, HuggingFaceHub, LLMChain

# 初始化HuggingFace模型
module = HuggingFaceHub(repo_id=”test-model-hf”, model_kwargs={“temperature”: 0, “max_tokens”: 64})

# 初始化LLM链
llm_chain = LLMChain(prompt=prompt, llm=module)

# 履行LLM链
result = llm_chain.run(“What’s your evaluation of artificial intelligence?”)
print(result)
“`

使用LangChain，您可以灵活地构建强大的问答机器人。希望您能通过这篇指南了解和掌握LangChain库。

以上是一个基于LangChain的自定义代理的例子，但是LangChain还有很多其他功能和模块，希望大家能继续探索。

最后，希望大家能结合LangChain开发出更具创意的产品，不单单是只弄那种只能构建ChatGPT的产品。

本文中所有的代码都可以在这里找到，祝大家学习愉快！

https://colab.research.google.com/drive/1ArRVMiS-YkhUlobHrU6BeS8fF57UeaPQ?usp=sharing

openai api key 有甚么用的常见问答Q&A