LangChain 是基于大语言模型的应用开发框架，通过集成外部数据和 Agent 交互简化 LLM 使用。核心组件包括 Model I/O（Language Model, Prompts, Output Parser）、Data Connection（Document loaders, transformers, Vector stores, Retrievers）、Chains（Router, Sequential, Map-reduce）、Memory 和 Agent。文章提供了 Python 代码示例展示各组件用法，涵盖文本加载、向量化存储、检索增强生成及对话链构建，帮助开发者快速实现 LLM 应用。
LangChain 已成为当前 LLM 应用框架的事实标准。本文整理 LangChain 的基本概念及具体使用场景。
LangChain是一个基于大语言模型的应用开发框架，它主要通过两种方式规范和简化了使用 LLM 的方式：
LLM 中；LLM 通过决策与特定的环境交互，并由 LLM 协助决定下一步的操作。LangChain 的优点包括：
Chains 的同时，支持自行继承 BaseChain 并实现相关逻辑以及各个阶段的 callback handler 等；LangChain 团队迭代速度非常快，能快速使用最新的语言模型特性，该团队也有 langsmith, auto-evaluator 等其它优秀项目，并且开源社区也有相当多的支持。
这是一张 LangChain 的组件与架构图（langchain python 和 langchain JS/TS 的架构基本一致，本文中以 langchain python 来完成相关介绍），基本完整描述了 LangChain 的组件与抽象层（callback 不在这张图中，在下方我们会另外介绍），以及它们之间的相关联系。
首先我们从最基本面的部分讲起，Model I/O 指的是和 LLM 直接进行交互的过程。
在 Model I/O 这一流程中，LangChain 抽象的组件主要有三个：Language Model、Prompts、Output Parser。
下面展开介绍一下。
⚠️ 注：下面涉及的所有代码示例中的 OPENAI_API_KEY 和 OPENAI_BASE_URL 需要提前配置好，OPENAI_API_KEY 指 OpenAI/OpenAI 代理服务的 API Key，OPENAI_BASE_URL 指 OpenAI 代理服务的 Base Url。
Language Model 是真正与 LLM / ChatModel 进行交互的组件，它可以直接被当作普通的 openai client 来使用，在 LangChain 中，主要使用到的是 LLM，Chat Model 和 Embedding 三类 Language Model。
LLM: 最基础的通过'text in ➡️ text out'模式来使用的 Language Model，另一方面，LangChain 也收录了大量的相关模型。
from langchain.llms import OpenAI
llm = OpenAI(model_name="text-ada-001", openai_api_key=OPENAI_API_KEY, openai_api_base=OPENAI_BASE_URL)
llm("What day comes after Friday?")
# '\n\nSaturday.'
Chat Model: LLM 的变体，抽象了 Chat 这一场景下的使用模式，由'text in ➡️ text out'变成了'chat messages in ➡️ chat message out'，chat message 是指 text + message type(System, Human, AI)。
from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage
chat = ChatOpenAI(model_name="gpt-4-0613", temperature=1, openai_api_key=OPENAI_API_KEY, openai_api_base=OPENAI_BASE_URL)
chat(
[
SystemMessage(content="You are an expert on large language models and can answer any questions related to large language models."),
HumanMessage(content="What's the difference between Generic Language Models, Instruction Tuned Models and Dialog Tuned Models")
]
)
# AIMessage(content='Generic Language Models, Instruction-Tuned Models, and Dialog-Tuned Models are all various types of language models that have been trained according to different datasets and methodologies...')
另一方面，LangChain 也收录了大量的消息类型：
Embedding: Embedding 将一段文字向量化为一个定长的向量，有了文本的向量化表示我们就可以做一些像语义搜索，聚类选择等来选择需要的文本片段，如下是将一个 embed 任意字符串的示例：
from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY, openai_api_base=OPENAI_BASE_URL)
text_embedding = embeddings.embed_query("To embed text(it can have any length)")
print (f"Your embedding's length: {len(text_embedding)}")
print (f"Here's a sample: {text_embedding[:5]}...")
'''
Your embedding's length: 1536
Here's a sample: [-0.03194352, 0.009228715, 0.00807182, 0.0077545005, 0.008256923]...
'''
Prompt 指用户的一系列指令和输入，是决定 Language Model 输出内容的唯一输入，主要用于帮助模型理解上下文并生成相关和连贯的输出，如回答问题、拓写句子和总结问题。在 LangChain 中的相关组件主要有 Prompt Template 和 Example selectors，以及后面会提到的辅助/补充 Prompt 的一些其它组件。
Prompt Template: 预定义的一系列指令和输入参数的 prompt 模版，支持更加灵活的输入，如支持 output instruction(输出格式指令), partial input(提前指定部分输入参数), examples(输入输出示例) 等；LangChain 提供了大量方法来创建 Prompt Template，有了这一层组件就可以在不同 Language Model 和不同 Chain 下大量复用 Prompt Template 了，Prompt Template 中也会有下面将提到的 Example selectors, Output Parser 的参与。
Example selectors: 在很多场景下，单纯的 instruction + input 的 prompt 不足以让 LLM 完成高质量的推理回答，这时候我们就还需要为 prompt 补充一些针对具体问题的示例，LangChain 将这一功能抽象为了 Example selectors 这一组件，我们可以基于关键字，相似度 (通常使用 MMR/cosine similarity/ngram 来计算相似度，在后面的向量数据库章节中会提到)。为了让最终的 prompt 不超过 Language Model 的 token 上限（各个模型的 token 上限见下表），LangChain 还提供了 LengthBasedExampleSelector，根据长度来限制 example 数量，对于较长的输入，它会选择包含较少示例的提示，而对于较短的输入，它会选择包含更多示例。
通常我们希望 Language Model 的输出是固定的格式，以支持我们解析其输出为结构化数据，LangChain 将这一诉求所需的功能抽象成了 Output Parser 这一组件，并提供了一系列的预定义 Output Parser，如最常用的 Structured output parser, List parser，以及在 LLM 输出无法解析时发挥作用的 Auto-fixing parser 和 Retry parser。
Output Parser 需要和 Prompt Template, Chain 组合使用：
Prompt Template 中通过指定 partial_variables 为 Output Parser 的 format，即可在 prompt 中补充让模型输出所需格式内容的指令；Chain 中指定 Output Parser，并使用 Chain 的 predict_and_parse / apply_and_parse 方法启动 Chain，即可直接输出解析后的数据。以下是一个完整的组合 Prompt Template, Output Parser 和 Chain 的具体用例：
from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.chains import LLMChain
llm = ChatOpenAI(temperature=0.5, model_name="gpt-3.5-turbo-16k-0613", openai_api_key=OPENAI_API_KEY, openai_api_base=OPENAI_BASE_URL)
template = """
## Input
{text}
## Instruction
Please summarize the piece of text in the input part above.
Respond in a manner that a 5 year old would understand.
{format_instructions}
YOUR RESPONSE:
"""
# 创建一个 Output Parser，包含两个输出字段，并指定类型和说明
output_parser = StructuredOutputParser.from_response_schemas(
[
ResponseSchema(name="keywords", type="list", description="keywords of the text"),
ResponseSchema(name="summary", type="string", description="summary of the text"),
]
)
# 创建 Prompt Template，并将 format_instructions 通过 partial_variables 直接指定为 Output Parser 的 format
prompt = PromptTemplate(
input_variables=["text"],
template=template,
partial_variables={"format_instructions": output_parser.get_format_instructions()},
)
# 创建 Chain 并绑定 Prompt Template 和 Output Parser(它将自动使用 Output Parser 解析 llm 输出)
summarize_chain = LLMChain(llm=llm, verbose=True, prompt=prompt, output_parser=output_parser)
to_summarize_text = 'Abstract. Text-to-SQL aims at generating SQL queries for the given natural language questions and thus helping users to query databases. Prompt learning with large language models (LLMs) has emerged as a recent approach, which designs prompts to lead LLMs to understand the input question and generate the corresponding SQL. However, it faces challenges with strict SQL syntax requirements. Existing work prompts the LLMs with a list of demonstration examples (i.e. question-SQL pairs) to generate SQL, but the fixed prompts can hardly handle the scenario where the semantic gap between the retrieved demonstration and the input question is large.'
output = summarize_chain.predict(text=to_summarize_text)
import json
print (json.dumps(output, indent=4))
输出如下：
{
"keywords": [
"Text-to-SQL",
"SQL queries",
"natural language questions",
"databases",
"prompt learning",
"large language models",
"LLMs",
"SQL syntax requirements",
"demonstration examples",
"semantic gap"
],
"summary": "Text-to-SQL is a method that helps users generate SQL queries for their questions about databases. One approach is to use large language models to understand the question and generate the SQL. However, this approach faces challenges with strict SQL syntax rules. Existing methods use examples to teach the language models, but they struggle when the examples are very different from the question."
}
正如我在文章开头的 LangChain 是什么一节中提到的，集成外部数据到 Language Model 中是 LangChain 提供的核心能力之一，也是市面上很多优秀的大语言模型应用成功的核心之一（例如 YouTube 视频总结助手…），在 LangChain 中，Data connection 这一层主要包含以下四个抽象组件：
下面我们展开介绍一下。
为了补全 LLM 的上下文信息，给予其足够的提示，我们需要从各类数据源获取各类数据，这也就是 LangChain 抽象的 Document loaders 这一组件的功能。
使用 Document loaders 可以将源中的数据加载为 Document。Document 由一段文本和相关元数据组成。例如，有用于加载简单.txt 文件的，用于加载相对结构化的 markdown 文件的，用于加载任何网页文本内容，甚至用于加载解析 YouTube 视频的脚本。
同时 LangChain 还收录了大量的文档加载器，以下是一个使用 NotionDBLoader 来加载 notion database 中的 page 为 Document 的示例：
from langchain.document_loaders import NotionDBLoader
from getpass import getpass
# getpass() 指引用户输入密钥
NOTION_TOKEN = getpass()
DATABASE_ID = getpass()
loader = NotionDBLoader(
integration_token=NOTION_TOKEN,
database_id=DATABASE_ID,
request_timeout_sec=30, # optional, defaults to 10
)
# 请求详情见 https://developers.notion.com/reference/post-database-query
docs = loader.load()
docs[0].page_content[:100]
当我们加载 Document 到内存后，我们通常还会希望将他们尽可能的结构化 / 分块，以进行更加灵活的操作。
最简单的例子是，我们很多时候都需要将一个长文档拆分成更小的块，以便放入模型的上下文窗口中；LangChain 有许多内置的 Document transformers(大部分都是 Text Spliter)，可以轻松地拆分、合并、筛选和以其他方式操作文档，一些常用的 Document transformers 如下：
同时 LangChain 也收录了很多处理工具（如基于爬虫中常见的 beautiful soup, 基于 OpenAI 打 metadata tag 的等等）。
在前面的 Prompt 一节中我们提到了 Example selectors，那么我们要如何找到相关示例呢？通常这个答案就是向量数据库。
存储和搜索非结构化数据的最常见方式之一是将其向量化 (embedding) 并存储所得到的嵌入向量，然后在查询时向量化非结构化查询并检索与嵌入的查询最相似的向量。Vector stores 负责存储向量化数据并提供向量搜索的功能，常见的向量数据库包括 FAISS, Milvus, Pinecone, Weaviate, Chroma 等，日常使用更常用的是 FAISS。
同时 LangChain 也收录了很多向量存储后端，提供更加强大的向量搜索等功能。
Retrievers 是 LangChain 提供的将 Document 与 Language Model 相结合的组件。
LangChain 中有许多不同类型的 Retrievers，但最广泛使用的就是 VectoreStoreRetriever，我们可以直接把它当做连接向量数据库和 Language Model 的中间层，并且 VectoreStoreRetriever 的使用也很简单，直接 retriever = db.as_retriever() 即可。
当然我们还有很多其它的 Retrievers 如 Web search Retrievers 等，LangChain 也收录了很多。
以下就是一个使用向量数据库 + VectoreStoreRetriever + QA Chain 的 QA 应用示例：
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
# 初始化 LLM
llm = ChatOpenAI(temperature=0.5, model_name="gpt-3.5-turbo-16k-0613", openai_api_key=OPENAI_API_KEY, openai_api_base=OPENAI_BASE_URL)
# 加载文档
loader = TextLoader('path/to/related/document')
doc = loader.load()
print (f"You have {len(doc)} document")
print (f"You have {len(doc[0].page_content)} characters in that document")
# 分割字符串
text_splitter = RecursiveCharacterTextSplitter(chunk_size=3000, chunk_overlap=400)
docs = text_splitter.split_documents(doc)
num_total_characters = sum([len(x.page_content) for x in docs])
print (f"Now you have {len(docs)} documents that have an average of {num_total_characters / len(docs):,.0f} characters (smaller pieces)")
# 初始化向量化模型
embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY, openai_api_base=OPENAI_BASE_URL)
# 向量化 Document 并存入向量数据库（绑定向量和对应 Document 元数据），这里我们选择本地最常用的 FAISS 数据库
# 注意：这会向 OpenAI 产生请求并产生费用
doc_search = FAISS.from_documents(docs, embeddings)
qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=doc_search.as_retriever(), verbose=True)
query = "Specific questions to be asked"
qa.run(query)
执行后 verbose 输出日志如下：
You have 1 document
You have 74663 characters in that document
Now you have 29 documents that have an average of 2,930 characters (smaller pieces)
Entering new chain…
Prompt after formatting:
System: Use the following pieces of context to answer the users question. If you don't know the answer, just say that you don't know, don't try to make up an answer.
Human: What does the author describe as good work?
The author describes working on things that aren't prestigious as a sign of good work. They believe that working on unprestigious types of work can lead to the discovery of something real and that it indicates having the right kind of motives. The author also mentions that working on things that last, such as paintings, is considered good work.
接下来就是 LangChain 中的主角——Chains 了，Chains 是 LangChain 中为连接多次与 Language Model 的交互过程而抽象的重要组件，它可以将多个组件组合在一起以创建一个单一的、连贯的任务，也可以嵌套多个 Chain 组合在一起，或者将 Chain 与其他组件组合来构建更复杂的 Chain。
除了单一 Chain 外，常用的几个 Chains 如下：
在一些场景下，我们需要根据输入 / 上下文决定使用哪一条 Chain，甚至哪一个 Prompt，Router Chain 就提供了一系列用于决策的 Chain（这与后面我们会提到的 Agent 有类似的地方）。
Router Chain 由两部分组成：
顾名思义，顺序执行的串行 Chain，其中最简单的 SimpleSequentialChain 非常简单粗暴，SimpleSequentialChain 的每个子 Chain 都有一个单一的输入/输出，并且一个步骤的输出是下一步的输入。
而高阶一些的 SequentialChain 则允许多输入输出，并且我们可以通过添加后面会提到的 Memory 等来提高其推理表现。
Map-reduce Chain 主要用于 summary 的场景，针对那些超长的文档，首先我们通过前面提到过的 TextSpliter 按一定规则分割文档为更小的 Chunks（通常使用 RecursiveCharacterTextSplitter，如果 Document 是结构化的可以考虑使用指定的 TextSpliter）,然后对每个分割的部分执行'map-chain'，收集全部'map-chain'的输出后，再执行'reduce-chain'，获得最终的 summary 输出。
下面就是一个 Router Chain 中的的具体示例：
from langchain.chains.router import MultiPromptChain
from langchain.llms import OpenAI
from langchain.chains import ConversationChain
from langchain.chains.llm import LLMChain
from langchain.prompts import PromptTemplate
from langchain.chains.router.llm_router import LLMRouterChain, RouterOutputParser
from langchain.chains.router.multi_prompt_prompt import MULTI_PROMPT_ROUTER_TEMPLATE
# 定义要路由的 prompts
physics_template = """You are a very smart physics professor. \You are great at answering questions about physics in a concise and easy to understand manner. \When you don't know the answer to a question you admit that you don't know.
Here is a question:
{input}"""
math_template = """You are a very good mathematician. You are great at answering math questions. \You are so good because you are able to break down hard problems into their component parts, \answer the component parts, and then put them together to answer the broader question.
Here is a question:
{input}"""
# 整理 prompt 和相关信息
prompt_infos = [
{
"name": "physics",
"description": "Good for answering questions about physics",
"prompt_template": physics_template,
},
{
"name": "math",
"description": "Good for answering math questions",
"prompt_template": math_template,
},
]
llm = OpenAI(temperature=0.5, openai_api_key=OPENAI_API_KEY, openai_api_base=OPENAI_BASE_URL+"/v1")
destination_chains = {}
for p_info in prompt_infos:
# 以每个 prompt 为基础创建一个 destination_chain(开启 verbose)
name = p_info["name"]
prompt_template = p_info["prompt_template"]
prompt = PromptTemplate(template=prompt_template, input_variables=["input"])
chain = LLMChain(llm=llm, prompt=prompt)
destination_chains[name] = chain
# 创建一个缺省 chain，如果没有其他 chain 满足路由条件，则使用该 chain
default_chain = ConversationChain(llm=llm, output_key="text")
destinations = [f"{p['name']}: {p['description']}" for p in prompt_infos]
destinations_str = "\n".join(destinations)
# 根据 prompt_infos 中的映射关系创建 router_prompt
router_template = MULTI_PROMPT_ROUTER_TEMPLATE.format(destinations=destinations_str)
router_prompt = PromptTemplate(
template=router_template,
input_variables=["input"],
output_parser=RouterOutputParser(),
)
# 创建 router_chain(开启 verbose)
router_chain = LLMRouterChain(llm_chain=LLMChain(llm=llm, prompt=router_prompt, verbose=True), verbose=True)
# 将 router_chain 和 destination_chains 以及 default_chain 组合成 MultiPromptChain(开启 verbose)
chain = MultiPromptChain(
router_chain=router_chain,
destination_chains=destination_chains,
default_chain=default_chain,
verbose=True,
)
# run
chain.run("What is black body radiation?")
执行后 verbose 输出日志如下：
Entering new chain… Prompt after formatting: Given a raw text input to a language model select the model prompt best suited for the input. You will be given the names of the available prompts and a description of what the prompt is best suited for. You may also revise the original input if you think that revising it will ultimately lead to a better response from the language model.
<< FORMATTING >> Return a markdown code snippet with a JSON object formatted to look like:
{
"destination": string \ name of the prompt to use or "DEFAULT"
"next_inputs": string \ a potentially modified version of the original input
}
REMEMBER: 'destination' MUST be one of the candidate prompt names specified below OR it can be 'DEFAULT' if the input is not well suited for any of the candidate prompts. REMEMBER: 'next_inputs' can just be the original input if you don't think any modifications are needed.
<< CANDIDATE PROMPTS >> physics: Good for answering questions about math math: Good for answering math questions
<< INPUT >>
What is black body radiation?
<< OUTPUT >>
Finished chain.
physics: {'input': 'What is black body radiation?'
Entering new chain…
Prompt after formatting:
You are a very smart physics professor. You are great at answering questions about physics in a concise and easy to understand manner. When you don't know the answer to a question you admit that you don't know.
Here is a question:
What is black body radiation?
Finished chain.
Memory 可以帮助 Language Model 补充历史信息的上下文，LangChain 中的 Memory 是一个有点模糊的术语，它可以像记住你过去聊天过的信息一样简单，也可以结合向量数据库做更加复杂的历史信息检索，甚至维护相关实体及其关系的具体信息，这取决于具体的应用。
通常 Memory 用于较长的 Chain，能一定程度上提高模型的推理表现。
常用的 Memory 类型如下：
Chat Messages
最简单 Memory，将历史 Chat 记录作为补充信息放入 prompt 中。
Vector store-backed memory
基于向量数据库的 Memory，将 memory 存储在向量数据库中，并在每次调用时查询 TopK 的最'重要'的文档。
这与大多数其他内存类的不同之处在于，它不显式跟踪交互的顺序，最多基于部分元数据筛选一下向量数据库的查询范围。
Conversation buffer(window) memory
保存一段时间内的历史 Chat 记录，它只使用最后 K 个记录（仅保持最近交互的滑动窗口），这样 buffer 也就不会变得太大，避免超过 token 上限。
Conversation summary memory
这种类型的 Memory 会随着 Chat 的进行创建对话的摘要，并将当前摘要存储在 Memory 中，用于后续对话的 history 提示；这种 memory 方案对长会话非常有用，但频繁的总结摘要会耗费大量的 token。
Conversation Summary Buffer Memory
结合了 buffer memory 和 summary memory 的策略，依旧会在内存中保留最后的一些 Chat 记录作为 buffer，并在 buffer 的总 token 数达到预置的上限后，对所有 Chat 记录总结摘要作为 SystemMessage 并清理其它历史 Messages；这种 memory 方案结合了 buffer memory 和 summary memory 的优点，既不会频繁地总结摘要消耗 token，也不会让 buffer 缺失过多信息。
下面是一个 Conversation Summary Buffer Memory 在 ConversationChain 中的使用示例，包含了切换会话时恢复现场 memory 的方法以及自定义 summary prompt 的方法：
from langchain.chains import ConversationChain
from langchain.memory import ConversationSummaryBufferMemory
from langchain.llms import OpenAI
from langchain.schema import SystemMessage, AIMessage, HumanMessage
from langchain.memory.prompt import SUMMARY_PROMPT
from langchain.prompts import PromptTemplate
llm = OpenAI(temperature=0.7, openai_api_key=OPENAI_API_KEY, openai_api_base=OPENAI_BASE_URL+"/v1")
# ConversationSummaryBufferMemory 默认使用 langchain.memory.prompt.SUMMARY_PROMPT 作为 summary 的 PromptTemplate
# 如果对它 summary 的格式/内容有特殊要求，可以自定义 PromptTemplate（实测默认的 summary 有些流水账）
prompt_template_str = """
## Instruction
Progressively summarize the lines of conversation provided, adding onto the previous summary returning a new concise and detailed summary.
Don't repeat the conversation directly in the summary, extract key information instead.
## EXAMPLE
Current summary:
The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good.
New lines of conversation:
Human: Why do you think artificial intelligence is a force for good?
AI: Because artificial intelligence will help humans reach their full potential.
New summary:
The human inquires about the AI's opinion on artificial intelligence. The AI believes that it is a force for good as it can help humans reach their full potential.
## Current summary
{summary}
## New lines of conversation
{new_lines}
## New summary
"""
prompt = PromptTemplate(
input_variables=SUMMARY_PROMPT.input_variables, # input_variables 为 SUMMARY_PROMPT 中的 input_variables 不变
template=prompt_template_str, # template 替换为上面重新编写的 prompt_template_str
)
memory = ConversationSummaryBufferMemory(llm=llm, prompt=prompt, max_token_limit=60)
# 添加历史 memory，其中第一条 SystemMessage 为历史对话中 Summary 的内容，第二条 HumanMessage 和第三条 AIMessage 为历史对话中最后的对话内容
memory.chat_memory.add_message(SystemMessage(content="The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good because it will help humans reach their full potential. The human then asks the difference between python and golang in short. The AI responds that python is a high-level interpreted language with an emphasis on readability and code readability, while golang is a statically typed compiled language with a focus on concurrency and performance. Python is typically used for general-purpose programming, while golang is often used for building distributed systems."))
memory.chat_memory.add_user_message("Then if I want to build a distributed system, which language should I choose?")
memory.chat_memory.add_ai_message("If you want to build a distributed system, I would recommend golang as it is a statically typed compiled language that is designed to facilitate concurrency and performance.")
# 调用 memory.prune() 确保 chat_memory 中的对话内容不超过 max_token_limit
memory.prune()
conversation_with_summary = ConversationChain(
llm=llm,
# We set a very low max_token_limit for the purposes of testing.
memory=memory,
verbose=True,
)
# memory.prune() 会在每次调用 predict() 后自动执行
conversation_with_summary.predict(input="Is there any well-known distributed system built with golang?")
conversation_with_summary.predict(input="Is there a substitutes for Kubernetes in python?")
执行后 verbose 输出日志如下：
> Entering new chain…
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
Current conversation: System: The human asks the AI about its opinion on artificial intelligence and is told that it is a force for good that can help humans reach their full potential. The human then inquires about the differences between python and golang, with the AI explaining that python is a high-level interpreted language for general-purpose programming, while golang is a statically typed compiled language often used for building distributed systems. Human: Then if I want to build a distributed system, which language should I choose? AI: If you want to build a distributed system, I would recommend golang as it is a statically typed compiled language that is designed to facilitate concurrency and performance. Human: Is there any well-known distributed system built with golang?
AI:
> Finished chain.
> Entering new chain…
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
Current conversation: System: The human asks the AI about its opinion on artificial intelligence and is told that it is a force for good that can help humans reach their full potential. The human then inquires about the differences between python and golang, with the AI explaining that python is a high-level interpreted language for general-purpose programming, while golang is a statically typed compiled language designed to facilitate concurrency and performance, thus better suited for distributed systems. The AI recommends golang for building distributed systems. Human: Is there any well-known distributed system built with golang? AI: Yes, there are several well-known distributed systems built with golang. These include Kubernetes, Docker, and Consul. Human: Is there a substitutes for Kubernetes in python?
AI:
'Yes, there are several substitutes for Kubernetes in python. These include Dask, Apache Mesos and Marathon, and Apache Aurora.'
在一些场景下，我们需要根据用户输入灵活地调用 LLM 和其它工具（LangChain 将工具抽象为 Tools 这一组件），Agent 为这样的应用程序提供了相关的支持。
Agent 可以访问一套工具，并根据用户输入确定要使用 Chain 或是 Function，我们可以简单的理解为他可以动态的帮我们选择和调用 Chain 或者已有的工具。
常用的 Agent 类型如下：
这类 Agent 可以根据 Language Model 的输出决定是否使用指定的 Tool，以及使用什么 Tool(这里的 Tool 也可以是一个 Chain)，以及时的为 Model I/O 的过程补充信息。
类似 Conversational Agent，但它能够让 Agent 更进一步地帮忙提取指定 Tool 的参数等，甚至使用多个 Tools。
抽象 Agent'决定做什么'的过程为'planning what to do'和'executing the sub tasks'(这种方法来自这一篇论文)，其中'planning what to do'这一步通常完全由 LLM 完成，而'executing the sub tasks'这一任务则通常由更多的 Tools 来完成。
结合对 LLM 输出的归因和执行，类似 OpenAI functions Agent，提供了一个更加明确的框架以及由论文支撑的方法。
这类 Agent 会基于 LLM 的输出，自行调用 Tools 以及 LLM 来进行额外的搜索和自查，以达到拓展和优化输出的目的。
LangChain 中的 Data Connection 将 LLM 与万物互联，给 LangChain 构建的应用带来了无限可能，而 Agent 又为应用开发中非常常见的'事件驱动'这一开发框架提供了偷懒的途径，将分支决策的工作交给 LLM，这又进一步简化了应用开发的工作；结合基于高度抽象的 Model I/O 及 Memory 等组件，LangChain 让开发者能够更快，更好更灵活地实现 LLM 助手、对话机器人等应用，极大地降低了 LLM 的使用门槛。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online