LangChain: 大语言模型的新篇章

最新推荐文章于 2024-10-31 17:05:07 发布

鸡腿爱学习

最新推荐文章于 2024-10-31 17:05:07 发布

阅读量1.1k

点赞数 13

文章标签： langchain 语言模型人工智能 pdf transformer 架构自然语言处理

本文链接：https://blog.csdn.net/2401_84206094/article/details/142653243

版权

本文介绍了LangChain框架，它能够将大型语言模型与其他计算或知识来源相结合，从而实现功能更加强大的应用。接着，对LangChain的关键概念进行了详细说明，并基于该框架进行了一些案例尝试，旨在帮助读者更轻松地理解LangChain的工作原理。

引言

近期，大型语言模型(LLM)如GPT系列模型引领了人工智能领域的一场技术革命。开发者们都在利用这些LLM进行各种尝试，虽然已经产生了许多有趣的应用，但是单独使用这些LLM往往难以构建功能强大的实用应用。

LangChain通过将大型语言模型与其他知识库、计算逻辑相结合，实现了功能更加强大的人工智能应用。简单来说，个人理解LangChain可以被视为开源版的GPT插件，它提供了丰富的大语言模型工具，可以在开源模型的基础上快速增强模型的能力。

在此，我总结了最近对LangChain的学习内容，欢迎各位同学前来交流。LangChain使得语言技术的运用更加活跃多元，它有望在人工智能领域发挥重要作用，推动我们工作效率的变革。我们正处在人工智能爆发的前夜，积极拥抱新技术将会带来全新的体验。

LangChain主要概念与示例

LangChain提供了一系列的工具帮助我们更好的使用大语言模型(LLM)。可以认为主要有6种不同类型的工具：

模型(Models)

LangChain的一个核心价值就是它提供了标准的模型接口；然后我们可以自由的切换不同的模型，当前主要有两种类型的模型，但是考虑到使用场景，对我们一般用户来说就是使用一种模型即文本生成模型。

说到模型，大家就理解模型就是ChatGPT就可以。单纯的模型只能生成文本内容。

语言模型(Language Models)

用于文本生成，文字作为输入，输出也是文字。

1. 普通LLM：接收文本字符串作为输入，并返回文本字符串作为输出。

2. 聊天模型：将聊天消息列表作为输入，并返回一个聊天消息。

代码案例：

from langchain.schema import HumanMessage``from langchain.llms import OpenAI``from langchain.chat_models import ChatOpenAI``llm = OpenAI()``chat_model = ChatOpenAI()``print(llm("say hi!"))``print(chat_model.predict("say hi!"))

文本嵌入模型(Text Embedding Models)

把文字转换为浮点数形式的描述：

这些模型接收文本作为输入并返回一组浮点数。这些浮点数通常用于表示文本的语义信息，以便进行文本相似性计算、聚类分析等任务。文本嵌入模型可以帮助开发者在文本之间建立更丰富的联系，提高基于大型语言模型的应用的性能。

from langchain.embeddings import OpenAIEmbeddings``embeddings = OpenAIEmbeddings()``text = "This is a test document."``query_result = embeddings.embed_query(text)``doc_result = embeddings.embed_documents([text])``print(doc_result)

提示词(Prompts)

提示词是我们与模型交互的方式，或者是模型的输入，通过提示词可以让模型返回我们期望的内容，比如让模型按照一定的格式返回数据给我们。

LangChain提供了一些工具，可以方便我们更容易的构建出我们想要的提示词，主要工具如下：

了解这些工具都是更方便的让我们构造提示词就行了。

PromptTemplates

语言模型提示词模板PromptTemplates，提示模板可以让我们重复的生成提示，复用我们的提示。它包含一个文本字符串（“模板”），从用户那里获取一组参数并生成提示，包含：

1. 对语言模型的说明，应该扮演什么角色。

2. 一组少量示例，以帮助LLM生成更好的响应。

3. 具体的问题。

代码案例：

from langchain import PromptTemplate``   ``   ``template = """``I want you to act as a naming consultant for new companies.``What is a good name for a company that makes {product}?``"""``   ``prompt = PromptTemplate(`    `input_variables=["product"],`    `template=template,``)``prompt.format(product="colorful socks")``# -> I want you to act as a naming consultant for new companies.``# -> What is a good name for a company that makes colorful socks?

ChatPrompt Templates

聊天模型提示词模板ChatPrompt Templates，ChatModels接受聊天消息列表作为输入。列表一般是不同的提示，并且每个列表消息一般都会有一个角色。

from langchain.prompts import (`    `ChatPromptTemplate,`    `PromptTemplate,`    `SystemMessagePromptTemplate,`    `AIMessagePromptTemplate,`    `HumanMessagePromptTemplate,``)``from langchain.schema import (`    `AIMessage,`    `HumanMessage,`    `SystemMessage``)``template="You are a helpful assistant that translates {input_language} to {output_language}."``system_message_prompt = SystemMessagePromptTemplate.from_template(template)``human_template="{text}"``human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)``   ``chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])``   ``# get a chat completion from the formatted messages``print(chat_prompt.format_prompt(input_language="English", output_language="French", text="I love programming.").to_messages())

Example Selectors

示例选择器Example Selectors，如果有多个案例的时候，使用ExampleSelectors选择一个案例让提示词使用：

1. 自定义的案例选择器。

2. 基于长度的案例选择器，输入长的时候按理会少一点，输入多的时候，案例会多一些。

3. 相关性选择器，选择一个和输入最相关的案例。

from langchain.prompts.example_selector.base import BaseExampleSelector``from typing import Dict, List``import numpy as np``   ``   ``class CustomExampleSelector(BaseExampleSelector):``   `    `def __init__(self, examples: List[Dict[str, str]]):`        `self.examples = examples``   `    `def add_example(self, example: Dict[str, str]) -> None:`        `"""Add new example to store for a key."""`        `self.examples.append(example)``   `    `def select_examples(self, input_variables: Dict[str, str]) -> List[dict]:`        `"""Select which examples to use based on the inputs."""`        `return np.random.choice(self.examples, size=2, replace=False)``   ``   ``examples = [`    `{"foo": "1"},`    `{"foo": "2"},`    `{"foo": "3"}``]``   ``# Initialize example selector.``example_selector = CustomExampleSelector(examples)``# Select examples``print(example_selector.select_examples({"foo": "foo"}))``# -> array([{'foo': '2'}, {'foo': '3'}], dtype=object)``# Add new example to the set of examples``example_selector.add_example({"foo": "4"})``print(example_selector.examples)``# -> [{'foo': '1'}, {'foo': '2'}, {'foo': '3'}, {'foo': '4'}]``# Select examples``print(example_selector.select_examples({"foo": "foo"}))``# -> array([{'foo': '1'}, {'foo': '4'}], dtype=object)``

OutputParsers

输出解析器OutputParsers，可以让LLM输出更加结构化的信息：

1. 指示模型如何格式化输出：get_format_instructions

2. 输出解析为所需的格式：parse(str)

主要的Parsers：

1. CommaSeparatedListOutputParser，让LLM按照逗号分隔的形式返回。[‘Vanilla’, ‘Chocolate’, ‘Strawberry’, ‘Mint Chocolate Chip’, ‘Cookies and Cream’]

2. StructuredOutputParser 无需定义对象，直接生成结构化的内容。和PydanticOutputParser比较像，但是不用定义对象。

3. PydanticOutputParser定义一个对象模型，让LLM按照这个模型返回数据。

可以看到我们定义了Joke类，然后PydanticOutputParser可以让LLM按照我们定义对象的格式返回数据给我们。

from langchain.prompts import PromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate``from langchain.llms import OpenAI``from langchain.chat_models import ChatOpenAI``   ``from langchain.output_parsers import PydanticOutputParser``from pydantic import BaseModel, Field, validator``from typing import List``model_name = 'text-davinci-003'``temperature = 0.0``model = OpenAI(model_name=model_name, temperature=temperature)``   ``   ``# Define your desired data structure.``class Joke(BaseModel):`    `setup: str = Field(description="question to set up a joke")`    `punchline: str = Field(description="answer to resolve the joke")``   `    `# You can add custom validation logic easily with Pydantic.`    `@validator('setup')`    `def question_ends_with_question_mark(cls, field):`        `if field[-1] != '?':`            `raise ValueError("Badly formed question!")`        `return field``   ``parser = PydanticOutputParser(pydantic_object=Joke)``prompt = PromptTemplate(`    `template="Answer the user query.\n{format_instructions}\n{query}\n",`    `input_variables=["query"],`    `partial_variables={"format_instructions": parser.get_format_instructions()}``)``joke_query = "Tell me a joke."``_input = prompt.format_prompt(query=joke_query)``output = model(_input.to_string())``print(parser.get_format_instructions())``print(output)``print(parser.parse(output))

索引（Indexs）

索引可以让文档结构化，从而LLM可以直接更好的和文档交互；比如用于答疑，知识库等，LLM先从文档中获取答案。

LangChain在索引这块也提供了许多有用的函数和工具，方便我们从外部加载与检索不同的文档数据。

在数据索引这块，LangChain提供的主要工具：

1. Document Loaders：从不同的数据源加载文档，当使用loader加载器读取到数据源后，数据源需要转换成 Document 对象后，后续才能进行使用。

2. Text Splitters：实现文本分割，我们每次不管是做把文本当作 prompt 发给 openai api ，还是还是使用 openai api embedding 功能都是有字符限制的。比如我们将一份300页的 pdf 发给 openai api，让他进行总结，他肯定会报超过最大 Token 错。所以这里就需要使用文本分割器去分割我们 loader 进来的 Document。

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

4. Retrievers：用于检索文档的数据。

图中的FAISS是一种向量存储的服务；

给一个案例，了解下不同工具的用法：

1. 首先加载文档；

2. 然后分隔文档为不同区块；

3. 然后转换为向量存储；

4. 将向量存储转换为检索器，交给LangChain，用于问答；

import os``from langchain.chains import RetrievalQA``from langchain.document_loaders import TextLoader``from langchain.embeddings import OpenAIEmbeddings``from langchain.indexes import VectorstoreIndexCreator``from langchain.text_splitter import CharacterTextSplitter``from langchain.vectorstores import Chroma``from langchain.llms import OpenAI``   ``# 设置代理``os.environ['HTTP_PROXY'] = 'socks5h://127.0.0.1:13659'``os.environ['HTTPS_PROXY'] = 'socks5h://127.0.0.1:13659'``   ``# 创建文本加载器``loader = TextLoader('/Users/aihe/Downloads/demo.txt', encoding='utf8')``   ``# 加载文档``documents = loader.load()``   ``# 文本分块``text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)``texts = text_splitter.split_documents(documents)``   ``# 计算嵌入向量``embeddings = OpenAIEmbeddings()``   ``# 创建向量库``db = Chroma.from_documents(texts, embeddings)``   ``# 将向量库转换为检索器``retriever = db.as_retriever()``   ``# 创建检索问答系统``qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=retriever)``   ``# 运行问题答案检索``query = "如何申请租户?"``print(qa.run(query))``   ``print(qa.run("能否说明下你可以提供的功能？"))

存储（Memory）

默认情况下Agent和Chain都是无状态的，也就是用完之后不知道上次的对话内容是什么。每次的query都是独立的。

但是在有些应用中，记住上一次的会话内容是比较重要的，比如聊天，LangChain对于也提供了一些相关的工具类。

from langchain import ConversationChain, OpenAI``from langchain.memory import ConversationBufferMemory``   ``memory = ConversationBufferMemory()``memory.chat_memory.add_user_message("你好!")``memory.chat_memory.add_ai_message("你好吗?")``llm = OpenAI(temperature=0)``chain = ConversationChain(llm=llm,`                          `verbose=True,`                          `memory=memory)``chain.predict(input="最近怎么样!")``print(chain.predict(input="感觉很不错，刚和AI做了场对话."))

链（Chains）

链可以让我们把多个组件组合成一个应用，比如我们创建一个链，这个链可以接受用户的输入，然后通过PromptTemplate格式化用户的输入为提示词，然后把这个提示词输入给LLM。

我们也可以把一些链组合在一起，构建更复杂的链。

一个简单的案例：

# 引入所需模块和类``from langchain.chains import LLMChain``from langchain.chat_models import ChatOpenAI``from langchain import PromptTemplate``from langchain.prompts.chat import (`    `ChatPromptTemplate,  # 引入对话模板类`    `HumanMessagePromptTemplate,  # 引入人类消息模板类``)``   ``# 创建人类消息模板类``human_message_prompt = HumanMessagePromptTemplate(`        `prompt=PromptTemplate(`            `template="给我一个制作{product}的好公司名字?",  # 输入模板，其中product为占位符`            `input_variables=["product"],  # 指定输入变量为product`        `)`    `)``   ``# 创建对话模板类``chat_prompt_template = ChatPromptTemplate.from_messages([human_message_prompt])``   ``# 创建OpenAI聊天模型对象``chat = ChatOpenAI(temperature=0.9)``   ``# 创建LLMChain对象，将聊天模型和对话模板传入``chain = LLMChain(llm=chat, prompt=chat_prompt_template)``   ``# 运行LLMChain对象，并输出结果``print(chain.run("袜子"))

代理（Agents）

代理是使用LLM作为思考工具，决定当前要做什么。我们会给代理一系列的工具，代理根据我们的输入判断用哪些工具可以完成这个目标，然后不断的运行工具，来完成目标。

代理可以看做是增强版的Chain，不仅绑定模板、LLM，还可以给代理添加一些工具。

Agent是一个智能代理，它负责根据用户输入和应用场景，在一系列可用工具中选择合适的工具进行操作。Agent可以根据任务的复杂性，采用不同的策略来决定如何执行操作。

有两种类型的Agent：

1. 动作代理（Action Agents）：这种代理一次执行一个动作，然后根据结果决定下一步的操作。

2. 计划-执行代理（Plan-and-Execute Agents）：这种代理首先决定一系列要执行的操作，然后根据上面判断的列表逐个执行这些操作。

对于简单的任务，动作代理更为常见且易于实现。对于更复杂或长期运行的任务，计划-执行代理的初始规划步骤有助于维持长期目标并保持关注。但这会以更多调用和较高延迟为代价。这两种代理并非互斥，可以让动作代理负责执行计划-执行代理的计划。

Agent内部涉及的核心概念如下：

1. 代理（Agent）：这是应用程序主要逻辑。代理暴露一个接口，接受用户输入和代理已执行的操作列表，并返回AgentAction或AgentFinish。

2. 工具（Tools）：这是代理可以采取的动作。比如发起HTTP请求，发邮件，执行命令。

3. 工具包（Toolkits）：这些是为特定用例设计的一组工具。例如，为了让代理以最佳方式与SQL数据库交互，它可能需要一个执行查询的工具和另一个查看表格的工具。可以看做是工具的集合。

4. 代理执行器（Agent Executor）：这将代理与一系列工具包装在一起。它负责迭代运行代理，直到满足停止条件。

代理的执行流程：

一个案例：

# 引入所需模块和类``from langchain.agents import load_tools  # 引入加载工具函数``from langchain.agents import initialize_agent  # 引入初始化代理函数``from langchain.agents import AgentType  # 引入代理类型类``from langchain.llms import OpenAI  # 引入OpenAI语言模型类``import os  # 引入os模块``   ``# 创建OpenAI语言模型对象，设定temperature为0，即关闭随机性``llm = OpenAI(temperature=0)``   ``# 加载所需工具，包括serpapi和llm-math``tools = load_tools(["serpapi", "llm-math"], llm=llm)``   ``# 初始化代理对象，设定代理类型为ZERO_SHOT_REACT_DESCRIPTION，输出详细信息``agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)``   ``# 运行代理对象，向其提问特朗普的年龄和年龄除以2的结果``agent.run("特朗普今年多少岁? 他的年龄除以2是多少?")

代理初始化类型

上述代码中关于Agent有个初始化的阶段，agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION，代理类型决定了代理如何使用工具、处理输入以及与用户进行交互。从而为用户提供有针对性的服务。其中可以选择的类型如下：

initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

1. zero-shot-react-description：该代理使用ReAct框架仅根据工具的描述来确定要使用哪个工具，可以提供任意数量的工具。要求为每个工具提供一个描述。

2. react-docstore：该代理使用ReAct框架与文档存储（docstore）进行交互。必须提供两个工具：一个搜索工具和一个查找工具（它们必须确切地命名为Search和Lookup）。搜索工具应该用于搜索文档，而查找工具应该在最近找到的文档中查找术语。该代理等同于原始的ReAct论文，特别是维基百科的示例。

3. self-ask-with-search：该代理使用一个名为Intermediate Answer的单一工具。这个工具应该能够查找问题的事实性答案。这个代理等同于原始的自问自答（self-ask）与搜索论文，其中提供了作为工具的谷歌搜索API。

4. conversational-react-description：该代理旨在用于对话设置中。提示让代理在对话中变得有帮助。它使用ReAct框架来决定使用哪个工具，并使用内存来记住之前的对话互动。

5. structured-chat-zero-shot-react-description: 在对话中可以使用任意的工具，并且能够记住对话的上下文。

Tools 工具

官方已经默认提供了一系列的工具箱，发Gmail邮件，数据库查询，JSON处理等；还有一些单个的工具列表，都可以在文档中看到：

https://python.langchain.com/en/latest/modules/agents/tools/getting_started.html

我们通过一个自定义的工具，了解下工具怎么用，因为后面再使用LangChain的时候我们做的也就是不断的自定义工具。

编写工具的时候，要准备：

1. 名称。

2. 工具描述：说明你的工具是做什么的？

3. 参数结构：当前工具需要的入参是什么结构？

LangChain应用案例

假设我们需要构建一个基于LLM的问答系统，该系统需要从指定的数据源中提取信息以回答用户的问题。我们可以使用LangChain中的数据增强生成功能与外部数据源进行交互，获取所需的数据。然后，将数据输入到LLM中，生成回答。记忆功能可以帮助我们在多次调用之间保持相关状态，从而提高问答系统的性能。此外，我们还可以使用智能代理功能实现系统的自动优化。最后，通过LangChain提供的评估提示和链实现，我们可以对问答系统的性能进行评估和优化。

LangChain生成图片

实现了一个基于语言模型的文本生成图片工具，调用不同的工具函数来最终生成图片。主要提供了以下几个工具：

1. random_poem：随机返回中文的诗词。

2. prompt_generate：根据中文提示词生成对应的英文提示词。

3. generate_image：根据英文提示词生成对应的图片。

import base64``import json``import os``from io import BytesIO``   ``import requests``from PIL import Image``from pydantic import BaseModel, Field``   ``from langchain.agents import AgentType, initialize_agent, load_tools``from langchain.chat_models import ChatOpenAI``from langchain.llms import OpenAI``from langchain.tools import BaseTool, StructuredTool, Tool, tool``from langchain import LLMMathChain, SerpAPIWrapper``   ``   ``def generate_image(prompt: str) -> str:`    `"""`    `根据提示词生成对应的图片``   `    `Args:`        `prompt (str): 英文提示词``   `    `Returns:`        `str: 图片的路径`    `"""`    `url = "http://127.0.0.1:7860/sdapi/v1/txt2img"`    `headers = {`        `"accept": "application/json",`        `"Content-Type": "application/json"`    `}`    `data = {`        `"prompt": prompt,`        `"negative_prompt": "(worst quality:2), (low quality:2),disfigured, ugly, old, wrong finger",`        `"steps": 20,`        `"sampler_index": "Euler a",`        `"sd_model_checkpoint": "cheeseDaddys_35.safetensors [98084dd1db]",`        `# "sd_model_checkpoint": "anything-v3-fp16-pruned.safetensors [d1facd9a2b]",`        `"batch_size": 1,`        `"restore_faces": True`    `}``   `    `response = requests.post(url, headers=headers, data=json.dumps(data))``   `    `if response.status_code == 200:`        `response_data = response.json()`        `images = response_data['images']``   `        `for index, image_data in enumerate(images):`            `img_data = base64.b64decode(image_data)`            `img = Image.open(BytesIO(img_data))`            `file_name = f"image_{index}.png"`            `file_path = os.path.join(os.getcwd(), file_name)`            `img.save(file_path)`            `print(f"Generated image saved at {file_path}")`            `return file_path`    `else:`        `print(f"Request failed with status code {response.status_code}")``   ``   ``def random_poem(arg: str) -> str:`    `"""`    `随机返回中文的诗词``   `    `Returns:`        `str: 随机的中文诗词`    `"""`    `llm = OpenAI(temperature=0.9)`    `text = """`        `能否帮我从中国的诗词数据库中随机挑选一首诗给我，希望是有风景，有画面的诗：`        `比如：山重水复疑无路，柳暗花明又一村。`    `"""`    `return llm(text)``   ``   ``def prompt_generate(idea: str) -> str:`    `"""`    `生成图片需要对应的英文提示词``   `    `Args:`        `idea (str): 中文提示词``   `    `Returns:`        `str: 英文提示词`    `"""`    `llm = OpenAI(temperature=0, max_tokens=2048)`    `res = llm(f"""`    `Stable Diffusion is an AI art generation model similar to DALLE-2.`    `Below is a list of prompts that can be used to generate images with Stable Diffusion:``   `    `- portait of a homer simpson archer shooting arrow at forest monster, front game card, drark, marvel comics, dark, intricate, highly detailed, smooth, artstation, digital illustration by ruan jia and mandy jurgens and artgerm and wayne barlowe and greg rutkowski and zdislav beksinski`    `- pirate, concept art, deep focus, fantasy, intricate, highly detailed, digital painting, artstation, matte, sharp focus, illustration, art by magali villeneuve, chippy, ryan yee, rk post, clint cearley, daniel ljunggren, zoltan boros, gabor szikszai, howard lyon, steve argyle, winona nelson`    `- ghost inside a hunted room, art by lois van baarle and loish and ross tran and rossdraws and sam yang and samdoesarts and artgerm, digital art, highly detailed, intricate, sharp focus, Trending on Artstation HQ, deviantart, unreal engine 5, 4K UHD image`    `- red dead redemption 2, cinematic view, epic sky, detailed, concept art, low angle, high detail, warm lighting, volumetric, godrays, vivid, beautiful, trending on artstation, by jordan grimmer, huge scene, grass, art greg rutkowski`    `- a fantasy style portrait painting of rachel lane / alison brie hybrid in the style of francois boucher oil painting unreal 5 daz. rpg portrait, extremely detailed artgerm greg rutkowski alphonse mucha greg hildebrandt tim hildebrandt`    `- athena, greek goddess, claudia black, art by artgerm and greg rutkowski and magali villeneuve, bronze greek armor, owl crown, d & d, fantasy, intricate, portrait, highly detailed, headshot, digital painting, trending on artstation, concept art, sharp focus, illustration`    `- closeup portrait shot of a large strong female biomechanic woman in a scenic scifi environment, intricate, elegant, highly detailed, centered, digital painting, artstation, concept art, smooth, sharp focus, warframe, illustration, thomas kinkade, tomasz alen kopera, peter mohrbacher, donato giancola, leyendecker, boris vallejo`    `- ultra realistic illustration of steve urkle as the hulk, intricate, elegant, highly detailed, digital painting, artstation, concept art, smooth, sharp focus, illustration, art by artgerm and greg rutkowski and alphonse mucha``   `    `I want you to write me a list of detailed prompts exactly about the idea written after IDEA. Follow the structure of the example prompts. This means a very short description of the scene, followed by modifiers divided by commas to alter the mood, style, lighting, and more.``   `    `IDEA: {idea}""")`    `return res``   ``   ``class PromptGenerateInput(BaseModel):`    `"""`    `生成英文提示词所需的输入模型类`    `"""`    `idea: str = Field()``   ``   ``class GenerateImageInput(BaseModel):`    `"""`    `生成图片所需的输入模型类`    `"""`    `prompt: str = Field(description="英文提示词")``   ``   ``tools = [`    `Tool.from_function(`        `func=random_poem,`        `name="诗歌获取",`        `description="随机返回中文的诗词"`    `),`    `Tool.from_function(`        `func=prompt_generate,`        `name="提示词生成",`        `description="生成图片需要对应的英文提示词，当前工具可以将输入转换为英文提示词，以便方便生成",`        `args_schema=PromptGenerateInput`    `),`    `Tool.from_function(`        `func=generate_image,`        `name="图片生成",`        `description="根据提示词生成对应的图片，提示词需要是英文的，返回是图片的路径",`        `args_schema=GenerateImageInput`    `),``]``   ``   ``def main():`    `"""`    `主函数，初始化代理并执行对话`    `"""`    `llm = OpenAI(temperature=0)`    `agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)`    `agent.run("帮我生成一张诗词的图片?")``   ``   ``if __name__ == '__main__':`    `main()``

LangChain做答疑

参考上面的索引部分：

import os``from langchain.chains import RetrievalQA``from langchain.document_loaders import TextLoader``from langchain.embeddings import OpenAIEmbeddings``from langchain.indexes import VectorstoreIndexCreator``from langchain.text_splitter import CharacterTextSplitter``from langchain.vectorstores import Chroma``from langchain.llms import OpenAI``   ``# 设置代理``os.environ['HTTP_PROXY'] = 'socks5h://127.0.0.1:13659'``os.environ['HTTPS_PROXY'] = 'socks5h://127.0.0.1:13659'``   ``# 创建文本加载器``loader = TextLoader('/Users/aihe/Downloads/demo.txt', encoding='utf8')``   ``# 加载文档``documents = loader.load()``   ``# 文本分块``text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)``texts = text_splitter.split_documents(documents)``   ``# 计算嵌入向量``embeddings = OpenAIEmbeddings()``   ``# 创建向量库``db = Chroma.from_documents(texts, embeddings)``   ``# 将向量库转换为检索器``retriever = db.as_retriever()``   ``# 创建检索问答系统``qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=retriever)``   ``# 运行问题答案检索``query = "如何申请租户?"``print(qa.run(query))``   ``print(qa.run("能否说明下你可以提供的功能？"))

Langchain输出结构化JSON数据

参考上述概念，提示词工具中提供了OutputParser可以把我们的对象转换为提示词，告诉LLM要返回什么结构的内容。

import requests``from langchain.agents import AgentType, initialize_agent``from langchain.chat_models import ChatOpenAI``from langchain.tools import StructuredTool``from pydantic import BaseModel, Field``   ``   ``def post_message(type: str, param: dict) -> str:`    `"""`     `当需要生成人群、分析画像、咨询问题时，使用如下的指示：url 固定为：http://localhost:3001/`     `如果请求是生成人群，请求的type为crowd; 如果请求是分析画像，请求的type为analyze; 如果是其他或者答疑，请求的type为question;`     `请求body的param把用户指定的条件传进来即可`     `"""`    `result = requests.post("http://localhost:3001/", json={"type": type, "param": param})`    `return f"Status: {result.status_code} - {result.text}"``   ``   ``class PostInput(BaseModel):`    `# body: dict = Field(description="""格式:{"type":"","param":{}}""")`    `type: str = Field(description="请求的类型，人群为crowd,画像为analyze")`    `param: dict = Field(description="请求的具体描述")``   ``   ``llm = ChatOpenAI(temperature=0)``tools = [`    `StructuredTool.from_function(post_message)``]``agent = initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)``agent.run("我想生成一个性别为男并且在180天访问过淘特的人群?")

LangChain做一款自己的聊天机器人

原本做聊天机器人，需要一些前端代码，但是已经有相应的开源工具，帮我们把LangChian的各种组件做了可视化，直接拖拽即可，我们直接使用LangFlow；

pip install langflow

然后运行命令：

langfow

如果和本地的LangChain有冲突，可以使用Docker运行langfow：

FROM python:3.10-slim``   ``RUN apt-get update && apt-get install gcc g++ git make -y``RUN useradd -m -u 1000 user``USER user``ENV HOME=/home/user \`    `PATH=/home/user/.local/bin:$PATH``   ``WORKDIR $HOME/app``   ``COPY --chown=user . $HOME/app``   ``RUN pip install langflow>==0.0.71 -U --user``CMD ["langflow", "--host", "0.0.0.0", "--port", "7860"]

在界面上配置LangChain的三个组件：在最右下角是对应的聊天窗口，输入下openai的key。