langchain 0.2.12 API 参考手册

强哥之神

已于 2024-08-29 10:21:17 修改

阅读量984

点赞数 17

于 2024-08-08 11:04:52 首次发布

本文链接：https://blog.csdn.net/qianggezhishen/article/details/141021481

版权

欢迎各位开发者伙伴们探索 LangChain 0.2.12 API 的精彩世界！这份参考手册是参考官网langchain 0.2.12 API 参考手册的整理过来的，希望对大家有所帮助，旨在帮助大家更深入地理解 LangChain 的API接口。通过本手册，您将能够快速掌握如何利用 LangChain 提供的各种工具和类库来构建智能应用程序。
在这里插入图片描述

`langchain.agents` 模块

Agent 类使用大型语言模型（LLM）来选择要执行的一系列动作。

在 Chains 中，动作序列是硬编码的。而在 Agents 中，使用语言模型作为推理引擎来确定要执行哪些动作以及它们的顺序。

Agents 选择并使用 Tools 和 Toolkits 来执行动作。

类层级结构：

BaseSingleActionAgent --> LLMSingleActionAgent
                          OpenAIFunctionsAgent
                          XMLAgent
                          Agent --> <name>Agent  # 示例：ZeroShotAgent, ChatAgent

BaseMultiActionAgent --> OpenAIMultiFunctionsAgent

主要助手：

AgentType, AgentExecutor, AgentOutputParser, AgentExecutorIterator,
AgentAction, AgentFinish

类


`agents.agent.AgentExecutor`	使用工具的代理。
`agents.agent.AgentOutputParser`	将代理输出解析为代理动作/结束的基类。
`agents.agent.BaseMultiActionAgent`	基础多动作代理类。
`agents.agent.BaseSingleActionAgent`	基础单动作代理类。
`agents.agent.ExceptionTool`	代理遇到查询时仅返回该查询的工具。
`agents.agent.MultiActionAgentOutputParser`	将代理输出解析为代理动作/结束的基类。
`agents.agent.RunnableAgent`	由 Runnables 驱动的代理。
`agents.agent.RunnableMultiActionAgent`	由 Runnables 驱动的代理。
`agents.agent_iterator.AgentExecutorIterator(...)`	AgentExecutor 的迭代器。
`agents.agent_toolkits.vectorstore.toolkit.VectorStoreInfo`	关于 VectorStore 的信息。
`agents.agent_toolkits.vectorstore.toolkit.VectorStoreRouterToolkit`	在 Vector Stores 之间路由的工具包。
`agents.agent_toolkits.vectorstore.toolkit.VectorStoreToolkit`	与 Vector Store 交互的工具包。
`agents.chat.output_parser.ChatOutputParser`	聊天代理的输出解析器。
`agents.conversational.output_parser.ConvoOutputParser`	对话代理的输出解析器。
`agents.conversational_chat.output_parser.ConvoOutputParser`	对话代理的输出解析器。
`agents.mrkl.base.ChainConfig(action_name, ...)`	MRKL 系统中使用的链配置。
`agents.mrkl.output_parser.MRKLOutputParser`	聊天代理的 MRKL 输出解析器。
`agents.openai_assistant.base.OpenAIAssistantAction`	需要将自定义工具输出提交到现有运行的 AgentAction。
`agents.openai_assistant.base.OpenAIAssistantFinish`	带有运行和线程元数据的 AgentFinish。
`agents.openai_assistant.base.OpenAIAssistantRunnable`	运行 OpenAI 助手。
`agents.openai_functions_agent.agent_token_buffer_memory.AgentTokenBufferMemory`	用于保存代理输出和中间步骤的记忆。
`agents.output_parsers.json.JSONAgentOutputParser`	以 JSON 格式解析工具调用和最终答案。
`agents.output_parsers.openai_functions.OpenAIFunctionsAgentOutputParser`	将消息解析为代理动作/结束。
`agents.output_parsers.openai_tools.OpenAIToolsAgentOutputParser`	将消息解析为代理动作/结束。
`agents.output_parsers.react_json_single_input.ReActJsonSingleInputOutputParser`	解析具有单个工具输入的 ReAct 风格的 LLM 调用的 JSON 格式。
`agents.output_parsers.react_single_input.ReActSingleInputOutputParser`	解析具有单个工具输入的 ReAct 风格的 LLM 调用。
`agents.output_parsers.self_ask.SelfAskOutputParser`	解析自问自答风格的 LLM 调用。
`agents.output_parsers.tools.ToolAgentAction`	字段
`agents.output_parsers.tools.ToolsAgentOutputParser`	将消息解析为代理动作/结束。
`agents.output_parsers.xml.XMLAgentOutputParser`	以 XML 格式解析工具调用和最终答案。
`agents.react.output_parser.ReActOutputParser`	ReAct 代理的输出解析器。
`agents.schema.AgentScratchPadChatPromptTemplate`	代理草稿本的聊天提示模板。
`agents.structured_chat.output_parser.StructuredChatOutputParser`	结构化聊天代理的输出解析器。
`agents.structured_chat.output_parser.StructuredChatOutputParserWithRetries`	结构化聊天代理的带重试的输出解析器。
`agents.tools.InvalidTool`	代理遇到无效工具名称时运行的工具。

函数


`agents.agent_toolkits.conversational_retrieval.openai_functions.create_conversational_retrieval_agent(...)`	创建会话检索代理的便捷方法。
`agents.agent_toolkits.vectorstore.base.create_vectorstore_agent(...)`	从 LLM 和工具构造 VectorStore 代理。
`agents.agent_toolkits.vectorstore.base.create_vectorstore_router_agent(...)`	从 LLM 和工具构造 VectorStore 路由器代理。
`agents.format_scratchpad.log.format_log_to_str(...)`	构建让代理继续其思维过程的草稿本。
`agents.format_scratchpad.log_to_messages.format_log_to_messages(...)`	构建让代理继续其思维过程的草稿本。
`agents.format_scratchpad.openai_functions.format_to_openai_function_messages(...)`	将 (AgentAction, 工具输出) 元组转换为 FunctionMessages。
`agents.format_scratchpad.openai_functions.format_to_openai_functions(...)`	将 (AgentAction, 工具输出) 元组转换为 FunctionMessages。
`agents.format_scratchpad.tools.format_to_tool_messages(...)`	将 (AgentAction, 工具输出) 元组转换为 ToolMessages。
`agents.format_scratchpad.xml.format_xml(...)`	将中间步骤格式化为 XML。
`agents.json_chat.base.create_json_chat_agent(...)`	创建一个使用 JSON 格式化其逻辑的代理，为聊天模型构建。
`agents.openai_functions_agent.base.create_openai_functions_agent(...)`	创建一个使用 OpenAI 函数调用的代理。
`agents.openai_tools.base.create_openai_tools_agent(...)`	创建一个使用 OpenAI 工具的代理。
`agents.output_parsers.openai_tools.parse_ai_message_to_openai_tool_action(message)`	解析可能包含 tool_calls 的 AI 消息。
`agents.output_parsers.tools.parse_ai_message_to_tool_action(message)`	解析可能包含 tool_calls 的 AI 消息。
`agents.react.agent.create_react_agent(llm, ...)`	创建一个使用 ReAct 提示的代理。
`agents.self_ask_with_search.base.create_self_ask_with_search_agent(...)`	创建一个使用自问自答带搜索提示的代理。
`agents.structured_chat.base.create_structured_chat_agent(...)`	创建一个旨在支持具有多个输入的工具的代理。
`agents.tool_calling_agent.base.create_tool_calling_agent(...)`	创建一个使用工具的代理。
`agents.utils.validate_tools_single_input(...)`	验证单输入工具。
`agents.xml.base.create_xml_agent(llm, tools, ...)`	创建一个使用 XML 格式化其逻辑的代理。

弃用的类


`agents.agent.Agent`	弃用自 0.1.0 版本：使用 `create_react_agent`、`create_json_agent`、`create_structured_chat_agent` 等新的代理构造方法代替。
`agents.agent.LLMSingleActionAgent`	弃用自 0.1.0 版本：使用 `create_react_agent`、`create_json_agent`、`create_structured_chat_agent` 等新的代理构造方法代替。
`agents.agent_types.AgentType(value)`	弃用自 0.1.0 版本：使用 `create_react_agent`、`create_json_agent`、`create_structured_chat_agent` 等新的代理构造方法代替。
`agents.chat.base.ChatAgent`	弃用自 0.1.0 版本：使用 `create_react_agent` 代替。
`agents.conversational.base.ConversationalAgent`	弃用自 0.1.0 版本：使用 `create_react_agent` 代替。
`agents.conversational_chat.base.ConversationalChatAgent`	弃用自 0.1.0 版本：使用 `create_json_chat_agent` 代替。
`agents.mrkl.base.MRKLChain`	弃用自 0.1.0 版本。
`agents.mrkl.base.ZeroShotAgent`	弃用自 0.1.0 版本：使用 `create
_react_agent` 代替。
`agents.openai_functions_agent.base.OpenAIFunctionsAgent`	弃用自 0.1.0 版本：使用 `create_openai_functions_agent` 代替。
`agents.openai_functions_multi_agent.base.OpenAIMultiFunctionsAgent`	弃用自 0.1.0 版本：使用 `create_openai_tools_agent` 代替。
`agents.react.base.DocstoreExplorer`(docstore)	弃用自 0.1.0 版本。
`agents.react.base.ReActChain`	弃用自 0.1.0 版本。
`agents.react.base.ReActDocstoreAgent`	弃用自 0.1.0 版本。
`agents.react.base.ReActTextWorldAgent`	弃用自 0.1.0 版本。
`agents.self_ask_with_search.base.SelfAskWithSearchAgent`	弃用自 0.1.0 版本：使用 `create_self_ask_with_search` 代替。
`agents.self_ask_with_search.base.SelfAskWithSearchChain`	弃用自 0.1.0 版本。
`agents.structured_chat.base.StructuredChatAgent`	弃用自 0.1.0 版本：使用 `create_structured_chat_agent` 代替。
`agents.xml.base.XMLAgent`	弃用自 0.1.0 版本：使用 `create_xml_agent` 代替。

弃用的函数


`agents.initialize.initialize_agent`(tools, llm)	弃用自 0.1.0 版本：使用 `create_react_agent`、`create_json_agent`、`create_structured_chat_agent` 等新的代理构造方法代替。
`agents.loading.load_agent`(path, **kwargs)	弃用自 0.1.0 版本。
`agents.loading.load_agent_from_config`(config)	弃用自 0.1.0 版本。

`langchain.callbacks` ¶

回调处理器 允许监听 LangChain 中的事件。

类层级结构：

BaseCallbackHandler -- > CallbackHandler  # 示例：AimCallbackHandler

类 ¶


`callbacks.streaming_aiter.AsyncIteratorCallbackHandler()`	返回一个异步迭代器的回调处理器。
`callbacks.streaming_aiter_final_only.AsyncFinalIteratorCallbackHandler(*)`	返回一个异步迭代器的回调处理器。
`callbacks.streaming_stdout_final_only.FinalStreamingStdOutCallbackHandler(*)`	代理中的流式处理回调处理器。
`callbacks.tracers.logging.LoggingCallbackHandler(logger)`	通过输入的 Logger 记录的跟踪器。

`langchain.chains` ¶

链（Chains） 是可以轻松重用的组件链接在一起。

链（Chains）编码了对模型、文档检索器、其他链等组件的调用序列，并为此序列提供了简单的接口。

链接口使得创建应用程序变得容易，这些应用程序可以是：

有状态的（Stateful）：给任何链添加内存以赋予其状态，
可观察的（Observable）：向链传递回调以执行附加功能，如日志记录，在组件调用的主要序列之外，
可组合的（Composable）：将链与其他组件结合，包括其他链。

类层级结构：

Chain -- > <name>Chain  # 示例：LLMChain, MapReduceChain, RouterChain

类 ¶


`chains.api.base.APIChain`	进行 API 调用并总结响应以回答问题的链。
`chains.base.Chain`	用于创建对组件进行结构化调用序列的抽象基类。
`chains.combine_documents.base.BaseCombineDocumentsChain`	组合文档的基础接口链。
`chains.combine_documents.map_reduce.MapReduceDocumentsChain`	通过将链映射到文档上，然后组合结果来组合文档。
`chains.combine_documents.map_rerank.MapRerankDocumentsChain`	通过将链映射到文档上，然后重新排列结果来组合文档。
`chains.combine_documents.reduce.AsyncCombineDocsProtocol(...)`	组合文档方法的接口。
`chains.combine_documents.reduce.CombineDocsProtocol(...)`	组合文档方法的接口。
`chains.combine_documents.reduce.ReduceDocumentsChain`	通过递归地减少它们来组合文档。
`chains.combine_documents.refine.RefineDocumentsChain`	通过对更多文档进行首次传递，然后细化来组合文档。
`chains.combine_documents.stuff.StuffDocumentsChain`	通过将上下文填充到文档中来组合文档的链。
`chains.constitutional_ai.base.ConstitutionalChain`	应用宪法原则的链。
`chains.constitutional_ai.models.ConstitutionalPrinciple`	宪法原则的类。
`chains.conversational_retrieval.base.BaseConversationalRetrievalChain`	与索引聊天的链。
`chains.conversational_retrieval.base.ChatVectorDBChain`	与向量数据库聊天的链。
`chains.conversational_retrieval.base.InputType`	对话检索链的输入类型。
`chains.elasticsearch_database.base.ElasticsearchDatabaseChain`	与 Elasticsearch 数据库交互的链。
`chains.flare.base.FlareChain`	结合检索器、问题生成器和响应生成器的链。
`chains.flare.base.QuestionGeneratorChain`	从不确定的跨度生成问题的链。
`chains.flare.prompts.FinishedOutputParser`	检查输出是否完成的输出解析器。
`chains.hyde.base.HypotheticalDocumentEmbedder`	为查询生成假定文档，然后嵌入该文档。
`chains.llm_checker.base.LLMCheckerChain`	带有自我验证的问题回答链。
`chains.llm_math.base.LLMMathChain`	解释提示并执行 Python 代码以进行数学运算的链。
`chains.llm_summarization_checker.base.LLMSummarizationCheckerChain`	带有自我验证的问题回答链。
`chains.mapreduce.MapReduceChain`	Map-reduce 链。
`chains.moderation.OpenAIModerationChain`	通过审核端点传递输入。
`chains.natbot.base.NatBotChain`	实现由 LLM 驱动的浏览器。
`chains.natbot.crawler.Crawler()`	网页的爬虫。
`chains.natbot.crawler.ElementInViewPort`	包含视口中元素信息的类型化字典。
`chains.openai_functions.citation_fuzzy_match.FactWithEvidence`	表示单个陈述的类。
`chains.openai_functions.citation_fuzzy_match.QuestionAnswer`	一个问题及其答案，每个事实都应该有来源。
`chains.openai_functions.openapi.SimpleRequestChain`	向 API 端点发出简单请求的链。
`chains.openai_functions.qa_with_structure.AnswerWithSources`	问题的答案，带有来源。
`chains.prompt_selector.BasePromptSelector`	提示选择器的基类。
`chains.prompt_selector.ConditionalPromptSelector`	通过条件语句进行提示集合。
`chains.qa_with_sources.base.BaseQAWithSourcesChain`	带有文档来源的问题回答链。
`chains.qa_with_sources.base.QAWithSourcesChain`	带有文档来源的问题回答链。
`chains.qa_with_sources.loading.LoadingCallable(...)`	加载组合文档链的接口。
`chains.qa_with_sources.retrieval.RetrievalQAWithSourcesChain`	带有索引来源的问题回答链。
`chains.qa_with_sources.vector_db.VectorDBQAWithSourcesChain`	带有向量数据库来源的问题回答链。
`chains.query_constructor.base.StructuredQueryOutputParser`	解析结构化查询的输出解析器。
`chains.query_constructor.parser.ISO8601Date`	格式为 ISO 8601（YYYY-MM-DD）的日期。
`chains.query_constructor.schema.AttributeInfo`	数据源属性的信息。
`chains.question_answering.chain.LoadingCallable(...)`	加载组合文档链的接口。
`chains.retrieval_qa.base.BaseRetrievalQA`	问题回答链的基类。
`chains.retrieval_qa.base.VectorDBQA`	针对向量数据库的问题回答链。
`chains.router.base.MultiRouteChain`	使用单个链将输入路由到多个候选链之一。
`chains.router.base.Route(destination, ...)`	创建新的 Route 实例（destination, next_inputs）
`chains.router.base.RouterChain`	输出目标链的名称和输入的链。
`chains.router.embedding_router.EmbeddingRouterChain`	使用嵌入来在选项之间路由的链。
`chains.router.llm_router.LLMRouterChain`	使用 LLM 链执行路由的路由器链。
`chains.router.llm_router.RouterOutputParser`	多提示链中路由器链输出的解析器。
`chains.router.multi_prompt.MultiPromptChain`	使用 LLM 路由器链在提示之间选择的多路由链。
`chains.router.multi_retrieval_qa.MultiRetrievalQAChain`	使用 LLM 路由器链在检索问答链之间选择的多路由链。
`chains.sequential.SequentialChain`	一个链的输出直接输入到下一个链。
`chains.sequential.SimpleSequentialChain`	一个简单的链，其中一个步骤的输出直接输入到下一个步骤。
`chains.sql_database.query.SQLInput`	SQL 链的输入。
`chains.sql_database.query.SQLInputWithTables`	SQL 链的输入。
`chains.summarize.chain.LoadingCallable(...)`	加载组合文档链的接口。
`chains.transform.TransformChain`	转换链输出的链。

函数 ¶


`chains.combine_documents.reduce.acollapse_docs(...)`	对一组文档执行折叠函数并将它们的元数据合并。
`chains.combine_documents.reduce.collapse_docs(...)`	对一组文档执行折叠函数并将它们的元数据合并。
`chains.combine_documents.reduce.split_list_of_docs(...)`	将文档拆分成每个子集都满足累积长度约束的子集。
`chains.combine_documents.stuff.create_stuff_documents_chain(...)`	创建一个将文档列表传递给模型的链。
`chains.example_generator.generate_example(...)`	给定提示的示例列表，返回另一个示例。
`chains.history_aware_retriever.create_history_aware_retriever(...)`	创建一个链，它接受对话历史并返回文档。
`chains.loading.load_chain(path, **kwargs)`	从 LangChainHub 或本地文件系统统一加载链的方法。
`chains.loading.load_chain_from_config(...)`	从配置字典加载链。
`chains.openai_functions.citation_fuzzy_match.create_citation_fuzzy_match_chain(llm)`	创建一个引用模糊匹配链。
`chains.openai_functions.openapi.get_openapi_chain(spec)`	根据 OpenAPI 规范创建一个查询 API 的链。
`chains.openai_functions.openapi.openapi_spec_to_openai_fn(spec)`	将有效的 OpenAPI 规范转换为 OpenAI 预期的 JSON Schema 格式。
`chains.openai_functions.qa_with_structure.create_qa_with_sources_chain(llm)`	创建一个返回答案及来源的问题回答链。
`chains.openai_functions.qa_with_structure.create_qa_with_structure_chain(...)`	创建一个返回答案及来源的问题回答链。
`chains.openai_functions.tagging.create_tagging_chain(...)`	创建一个从段落中提取信息的链。
`chains.openai_functions.tagging.create_tagging_chain_pydantic(...)`	使用 pydantic 模式从段落中提取信息的链。
`chains.openai_functions.utils.get_llm_kwargs(...)`	返回 LLMChain 构造函数的 kwargs。
`chains.prompt_selector.is_chat_model(llm)`	检查语言模型是否为聊天模型。
`chains.prompt_selector.is_llm(llm)`	检查语言模型是否为 LLM。
`chains.qa_with_sources.loading.load_qa_with_sources_chain(llm)`	加载带有来源的问题回答链。
`chains.query_constructor.base.construct_examples(...)`	从输入输出对构建示例。
`chains.query_constructor.base.fix_filter_directive(...)`	修复无效的过滤指令。
`chains.query_constructor.base.get_query_constructor_prompt(...)`	创建查询构造提示。
`chains.query_constructor.base.load_query_constructor_chain(...)`	加载查询构造链。
`chains.query_constructor.base.load_query_constructor_runnable(...)`	加载查询构造可运行链。
`chains.query_constructor.parser.get_parser([...])`	返回查询语言的解析器。
`chains.query_constructor.parser.v_args(...)`	当 lark 未安装时的虚拟装饰器。
`chains.question_answering.chain.load_qa_chain(llm)`	加载问题回答链。
`chains.retrieval.create_retrieval_chain(...)`	创建检索链，检索文档然后传递它们。
`chains.sql_database.query.create_sql_query_chain(llm, db)`	创建生成 SQL 查询的链。
`chains.structured_output.base.get_openai_output_parser(...)`	根据用户函数获取适当的函数输出解析器。
`chains.summarize.chain.load_summarize_chain(llm)`	加载摘要链。

弃用的类 ¶


`chains.combine_documents.base.AnalyzeDocumentChain`	弃用自 0.2.7 版本：使用 `example in API reference with more detail: https://api.python.langchain.com/en/latest/chains/langchain.chains.combine_documents.base.AnalyzeDocumentChain.html` 代替。
`chains.conversation.base.ConversationChain`	弃用自 0.2.7 版本：使用 `RunnableWithMessageHistory: https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html` 代替。
`chains.conversational_retrieval.base.ConversationalRetrievalChain`	弃用自 0.1.17 版本：使用 `create_history_aware_retriever together with create_retrieval_chain (see example in docstring)` 代替。
`chains.llm.LLMChain`	弃用自 0.1.17 版本：使用 ``RunnableSequence, e.g., `prompt
`chains.qa_generation.base.QAGenerationChain`	弃用自 0.2.7 版本：使用 `example in API reference with more detail: https://api.python.langchain.com/en/latest/chains/langchain.chains.qa_generation.base.QAGenerationChain.html` 代替。
`chains.retrieval_qa.base.RetrievalQA`	弃用自 0.1.17 版本：使用 `create_retrieval_chain` 代替。

弃用的函数 ¶


`chains.openai_functions.base.create_openai_fn_chain(...)`	弃用自 0.1.1 版本：使用 `create_openai_fn_runnable` 代替。
`chains.openai_functions.base.create_structured_output_chain(...)`	弃用自 0.1.1 版本：使用 `ChatOpenAI.with_structured_output` 代替。
`chains.openai_functions.extraction.create_extraction_chain(...)`	弃用自 0.1.14 版本：LangChain 引入了一个名为 with_structured_output 的方法，该方法可在能够调用工具的 ChatModels 上使用。您可以在这里阅读更多关于该方法的信息： https://python.langchain.com/docs/modules/model_io/chat/structured_output/ 。请按照我们的提取用例文档，了解如何使用 LLMs 进行信息提取的更多指导 https://python.langchain.com/docs/use_cases/extraction/ 。如果您注意到其他问题，请在此处提供反馈：https://github.com/langchain-ai/langchain/discussions/18154。使用 ``。
`chains.openai_functions.extraction.create_extraction_chain_pydantic(...)`	弃用自 0.1.14 版本：LangChain 引入了一个名为 with_structured_output 的方法，该方法可在能够调用工具的 ChatModels 上使用。您可以在这里阅读更多关于该方法的信息： https://python.langchain.com/docs/modules/model_io/chat/structured_output/ 。请按照我们的提取用例文档，了解如何使用 LLMs 进行信息提取的更多指导 https://python.langchain.com/docs/use_cases/extraction/ 。with_structured_output 当前不支持 pydantic 模式列表。如果这是阻碍，或者如果您注意到其他问题，请在此处提供反馈：https://github.com/langchain-ai/langchain/discussions/18154。使用 ``。
`chains.openai_tools.extraction.create_extraction_chain_pydantic(...)`	弃用自 0.1.14 版本：LangChain 引入了一个名为 with_structured_output 的方法，该方法可在能够调用工具的 ChatModels 上使用。您可以在这里阅读更多关于该方法的信息： https://python.langchain.com/docs/modules/model_io/chat/structured_output/ 。请按照我们的提取用例文档，了解如何使用 LLMs 进行信息提取的更多指导 https://python.langchain.com/docs/use_cases/extraction/ 。with_structured_output 当前不支持 pydantic 模式列表。如果这是阻碍，或者如果您注意到其他问题，请在此处提供反馈：https://github.com/langchain-ai/langchain/discussions/18154。使用 ``。
`chains.structured_output.base.create_openai_fn_runnable(...)`	弃用自 0.1.14 版本：LangChain 引入了一个名为 with_structured_output 的方法，该方法可在能够调用工具的 ChatModels 上使用。您可以在这里阅读更多关于该方法的信息： https://python.langchain.com/docs/modules/model_io/chat/structured_output/ 。请按照我们的提取用例文档，了解如何使用 LLMs 进行信息提取的更多指导 https://python.langchain.com/docs/use_cases/extraction/ 。如果您注意到其他问题，请在此处提供反馈：https://github.com/langchain-ai/langchain/discussions/18154。使用 ``。
`chains.structured_output.base.create_structured_output_runnable(...)`	弃用自 0.1.17 版本：LangChain 引入了一个名为 with_structured_output 的方法，该方法可在能够调用工具的 ChatModels 上使用。您可以在这里阅读更多关于该方法的信息： https://python.langchain.com/docs/modules/model_io/chat/structured_output/ 。请按照我们的提取用例文档，了解如何使用 LLMs 进行信息提取的更多指导 https://python.langchain.com/docs/use_cases/extraction/ 。如果您注意到其他问题，请在此处提供反馈：https://github.com/langchain-ai/langchain/discussions/18154。使用 ``。

`langchain.chat_models` ¶

聊天模型 是语言模型的一个变体。

虽然聊天模型在底层使用语言模型，但它们提供的接口有所不同。它们不是提供一个“文本输入，文本输出”的API，而是提供一个以“聊天消息”作为输入和输出的接口。

类层级结构：

BaseLanguageModel -- > BaseChatModel -- > <name>  # 示例: ChatOpenAI, ChatGooglePalm

主要助手：

AIMessage, BaseMessage, HumanMessage

函数 ¶

chat_models.base.init_chat_model() |

`langchain.embeddings` ¶

嵌入模型 是不同API和服务的嵌入模型的包装器。

嵌入模型 可以是大型语言模型（LLM）或不是。

类层级结构：

Embeddings -- > <name>Embeddings  # 示例: OpenAIEmbeddings, HuggingFaceEmbeddings

类 ¶

embeddings.cache.CacheBackedEmbeddings(...) | 缓存嵌入模型结果的接口。

`langchain.evaluation` ¶

用于评估 LLM 和链输出的评估链。

此模块包含用于评估 LangChain 原语（如语言模型和链）输出的现成评估链。

加载评估器
要加载评估器，您可以使用 load_evaluators 或 load_evaluator 函数，并提供要加载的评估器名称。

from langchain.evaluation import load_evaluator
evaluator = load_evaluator("qa")
evaluator.evaluate_strings(
    prediction="We sold more than 40,000 units last week",
    input="How many units did we sell last week?",
    reference="We sold 32,378 units",
)

评估器必须是 EvaluatorType 之一。

数据集
要加载 LangChain HuggingFace 的数据集之一，您可以使用 load_dataset 函数，并提供要加载的数据集名称。

from langchain.evaluation import load_dataset
ds = load_dataset("llm-math")

评估的一些常见用例包括：

根据真实答案评估响应的准确性：QAEvalChain
比较多个模型的输出：PairwiseStringEvalChain 或当有参考标签时使用 LabeledPairwiseStringEvalChain
判断代理工具使用的有效性：TrajectoryEvalChain
检查输出是否符合一组标准：CriteriaEvalChain 或当有参考标签时使用 LabeledCriteriaEvalChain
计算预测和参考之间的语义差异：EmbeddingDistanceEvalChain 或两个预测之间：PairwiseEmbeddingDistanceEvalChain
测量预测和参考之间的字符串距离 StringDistanceEvalChain 或两个预测之间 PairwiseStringDistanceEvalChain

低级 API
这些评估器实现了以下接口之一：

StringEvaluator: 评估预测字符串与参考标签和/或输入上下文的匹配度。
PairwiseStringEvaluator: 评估两个预测字符串之间的差异。适用于评分偏好、测量两个链或 llm 代理之间的相似性，或比较相似输入上的输出。
AgentTrajectoryEvaluator 评估代理采取的完整动作序列。

这些接口支持在更高层次的评估框架内更容易地组合和使用。

类 ¶

evaluation.agents.trajectory_eval_chain.TrajectoryEval: 包含轨迹分数和理由的命名元组。
evaluation.agents.trajectory_eval_chain.TrajectoryEvalChain: 用于评估 ReAct 风格代理的链。
evaluation.agents.trajectory_eval_chain.TrajectoryOutputParser: 轨迹输出解析器。
evaluation.comparison.eval_chain.LabeledPairwiseStringEvalChain: 比较多个输出的链，例如输出。
evaluation.comparison.eval_chain.PairwiseStringEvalChain: 比较多个输出的链，例如输出。
evaluation.comparison.eval_chain.PairwiseStringResultOutputParser: PairwiseStringEvalChain 输出的解析器。
evaluation.criteria.eval_chain.Criteria(value): 要评估的标准。
evaluation.criteria.eval_chain.CriteriaEvalChain: 用于根据标准评估运行的 LLM 链。
evaluation.criteria.eval_chain.CriteriaResultOutputParser: CriteriaEvalChain 输出的解析器。
evaluation.criteria.eval_chain.LabeledCriteriaEvalChain: 需要参考的标准评估链。
evaluation.embedding_distance.base.EmbeddingDistance(value): 嵌入距离度量。
evaluation.embedding_distance.base.EmbeddingDistanceEvalChain: 使用嵌入距离来评估预测和参考之间的语义差异。
evaluation.embedding_distance.base.PairwiseEmbeddingDistanceEvalChain: 使用嵌入距离来评估两个预测之间的语义差异。
evaluation.exact_match.base.ExactMatchStringEvaluator(*): 计算预测和参考之间的完全匹配。
evaluation.parsing.base.JsonEqualityEvaluator([...]): 评估预测在转换为 JSON 后是否等于参考。
evaluation.parsing.base.JsonValidityEvaluator(...): 评估预测是否为有效的 JSON。
evaluation.parsing.json_distance.JsonEditDistanceEvaluator([...]): 计算 JSON 字符串之间的编辑距离的评估器。
evaluation.parsing.json_schema.JsonSchemaEvaluator(...): 验证 JSON 预测与 JSON 模式引用的评估器。
evaluation.qa.eval_chain.ContextQAEvalChain: 基于上下文评估 QA 的 LLM 链，无需 GT。
evaluation.qa.eval_chain.CotQAEvalChain: 使用思维链推理评估 QA 的 LLM 链。
evaluation.qa.eval_chain.QAEvalChain: 评估问题回答的 LLM 链。
evaluation.qa.generate_chain.QAGenerateChain: 为问题回答生成示例的 LLM 链。
evaluation.regex_match.base.RegexMatchStringEvaluator(*): 计算预测和参考之间的正则表达式匹配。
evaluation.schema.AgentTrajectoryEvaluator: 评估代理轨迹的接口。
evaluation.schema.EvaluatorType(value): 评估器的类型。
evaluation.schema.LLMEvalChain: 使用 LLM 的评估器的基类。
evaluation.schema.PairwiseStringEvaluator: 比较多个模型（或同一模型的两个输出）。
evaluation.schema.StringEvaluator: 根据输入和/或参考标签对预测进行分级、标记或以其他方式评估。
evaluation.scoring.eval_chain.LabeledScoreStringEvalChain: 按 1-10 的量表对模型的输出进行评分的链。
evaluation.scoring.eval_chain.ScoreStringEvalChain: 按 1-10 的量表对模型的输出进行评分的链。
evaluation.scoring.eval_chain.ScoreStringResultOutputParser: ScoreStringEvalChain 输出的解析器。
evaluation.string_distance.base.PairwiseStringDistanceEvalChain: 计算两个预测之间的字符串编辑距离。
evaluation.string_distance.base.StringDistance(value): 要使用的距离度量。
evaluation.string_distance.base.StringDistanceEvalChain: 计算预测和参考之间的字符串距离。

函数 ¶

evaluation.comparison.eval_chain.resolve_pairwise_criteria(...): 解决成对评估器的标准。
evaluation.criteria.eval_chain.resolve_criteria(...): 解决要评估的标准。
evaluation.loading.load_dataset(uri): 从 HuggingFace 上的 LangChainDatasets 加载数据集。
evaluation.loading.load_evaluator(evaluator, *): 加载由字符串指定的请求评估链。
evaluation.loading.load_evaluators(evaluators, *): 加载由评估器类型列表指定的评估器。
evaluation.scoring.eval_chain.resolve_criteria(...): 解决成对评估器的标准。

`langchain.globals` ¶

全局值和配置，适用于整个 LangChain。

函数 ¶

globals.get_debug(): 获取调试全局设置的值。
globals.get_llm_cache(): 获取 llm_cache 全局设置的值。
globals.get_verbose(): 获取 verbose 全局设置的值。
globals.set_debug(value): 为调试全局设置设置新值。
globals.set_llm_cache(value): 设置一个新的 LLM 缓存，如果之前有设置则覆盖之前的值。
globals.set_verbose(value): 为 verbose 全局设置设置新值。

`langchain.hub` ¶

与 LangChain Hub 交互的接口。

函数 ¶

hub.pull(owner_repo_commit, *[, api_url, ...]): 从 Hub 中提取对象，并将其作为 LangChain 对象返回。
hub.push(repo_full_name, object, *[, ...]): 将对象推送到 Hub，并返回可以在浏览器中查看的 URL。

`langchain.indexes` ¶

索引用于避免向 vectorstore 写入重复内容，并避免如果内容未改变则覆盖内容。

索引还可以：

从数据创建知识图谱。
支持从 LangChain 数据加载器到 vectorstores 的索引工作流程。

重要的是，即使正在写入的内容是通过从某些源内容（例如，通过分块从父文档派生的子文档）进行一系列转换派生的，索引也会继续工作。

类 ¶

indexes.vectorstore.VectorStoreIndexWrapper: 对 vectorstore 的包装，便于访问。
indexes.vectorstore.VectorstoreIndexCreator: 创建索引的逻辑。

`langchain.memory` ¶

内存维护链状态，整合来自以往运行的上下文。

内存的类层级结构：

BaseMemory -- > BaseChatMemory -- > <name>Memory  # 示例: ZepMemory, MotorheadMemory

主要助手：
聊天消息历史 在不同的存储中存储聊天消息历史。

聊天消息历史的类层级结构：

BaseChatMessageHistory -- > <name>ChatMessageHistory  # 示例: ZepChatMessageHistory

主要助手：

AIMessage, BaseMessage, HumanMessage

类 ¶

memory.buffer.ConversationBufferMemory: 用于存储对话内存的缓冲区。
memory.buffer.ConversationStringBufferMemory: 用于存储对话内存的字符串缓冲区。
memory.buffer_window.ConversationBufferWindowMemory: 在有限大小的窗口内存储对话内存的缓冲区。
memory.chat_memory.BaseChatMemory: 聊天内存的抽象基类。
memory.combined.CombinedMemory: 组合多个内存的数据。
memory.entity.BaseEntityStore: 实体存储的抽象基类。
memory.entity.ConversationEntityMemory: 实体提取器 & 摘要器内存。
memory.entity.InMemoryEntityStore: 内存中的实体存储。
memory.entity.RedisEntityStore: Redis 支持的实体存储。
memory.entity.SQLiteEntityStore: SQLite 支持的实体存储。
memory.entity.UpstashRedisEntityStore: Upstash Redis 支持的实体存储。
memory.readonly.ReadOnlySharedMemory: 只读并且不能更改的内存包装器。
memory.simple.SimpleMemory: 用于存储不应在提示之间改变的上下文或其他信息的简单内存。
memory.summary.ConversationSummaryMemory: 对话摘要器到聊天内存。
memory.summary.SummarizerMixin: 摘要器的混入。
memory.summary_buffer.ConversationSummaryBufferMemory: 带摘要器的存储对话内存的缓冲区。
memory.token_buffer.ConversationTokenBufferMemory: 具有令牌限制的对话聊天内存。
memory.vectorstore.VectorStoreRetrieverMemory: 由 VectorStoreRetriever 支持的内存。
memory.vectorstore_token_buffer_memory.ConversationVectorStoreTokenBufferMemory: 对话聊天内存具有令牌限制和向量数据库支持。

函数 ¶

memory.utils.get_prompt_input_key(inputs, ...): 获取提示输入键。

`langchain.model_laboratory` ¶

实验不同的模型。

类 ¶

model_laboratory.ModelLaboratory(chains[, names]): 实验不同的模型。

`langchain.output_parsers` ¶

OutputParser 类解析 LLM 调用的输出。

类层级结构：

BaseLLMOutputParser -- > BaseOutputParser -- > <name>OutputParser  # ListOutputParser, PydanticOutputParser

主要助手：

Serializable, Generation, PromptValue

类 ¶

output_parsers.boolean.BooleanOutputParser: 将 LLM 调用的输出解析为布尔值。
output_parsers.combining.CombiningOutputParser: 将多个输出解析器合并为一个。
output_parsers.datetime.DatetimeOutputParser: 将 LLM 调用的输出解析为日期时间。
output_parsers.enum.EnumOutputParser: 解析为一组值中的一个的输出。
output_parsers.fix.OutputFixingParser: 包装一个解析器并尝试修复解析错误。
output_parsers.fix.OutputFixingParserRetryChainInput:
output_parsers.pandas_dataframe.PandasDataFrameOutputParser: 使用 Pandas DataFrame 格式解析输出。
output_parsers.regex.RegexParser: 使用正则表达式解析 LLM 调用的输出。
output_parsers.regex_dict.RegexDictParser: 使用正则表达式将 LLM 调用的输出解析为字典。
output_parsers.retry.RetryOutputParser: 包装一个解析器并尝试修复解析错误。
output_parsers.retry.RetryOutputParserRetryChainInput:
output_parsers.retry.RetryWithErrorOutputParser: 包装一个解析器并尝试修复解析错误。
output_parsers.retry.RetryWithErrorOutputParserRetryChainInput:
output_parsers.structured.ResponseSchema: 来自结构化输出解析器的响应的模式。
output_parsers.structured.StructuredOutputParser: 将 LLM 调用的输出解析为结构化输出。
output_parsers.yaml.YamlOutputParser: 使用 pydantic 模型解析 YAML 输出。

函数 ¶

output_parsers.loading.load_output_parser(config): 加载输出解析器。

`langchain.retrievers` ¶

检索器 类根据文本查询返回文档。

它比向量存储更通用。检索器不需要能够存储文档，只需要能够返回（或检索）它。向量存储可以用作检索器的后端，但还有其他类型的检索器。

类层级结构：

BaseRetriever -- > <name>Retriever  # 示例: ArxivRetriever, MergerRetriever

主要助手：

Document, Serializable, Callbacks, CallbackManagerForRetrieverRun, AsyncCallbackManagerForRetrieverRun

类 ¶

retrievers.contextual_compression.ContextualCompressionRetriever: 包装基础检索器并压缩结果的检索器。
retrievers.document_compressors.base.DocumentCompressorPipeline: 使用 Transformers 管道的文档压缩器。
retrievers.document_compressors.chain_extract.LLMChainExtractor: 使用 LLM 链提取文档相关部分的文档压缩器。
retrievers.document_compressors.chain_extract.NoOutputParser: 解析可能返回某种空字符串的输出。
retrievers.document_compressors.chain_filter.LLMChainFilter: 删除与查询无关的文档的过滤器。
retrievers.document_compressors.cross_encoder.BaseCrossEncoder: 交叉编码器模型的接口。
retrievers.document_compressors.cross_encoder_rerank.CrossEncoderReranker: 使用 CrossEncoder 进行重新排序的文档压缩器。
retrievers.document_compressors.embeddings_filter.EmbeddingsFilter: 使用嵌入丢弃与查询无关的文档的文档压缩器。
retrievers.document_compressors.listwise_rerank.LLMListwiseRerank: 使用 Zero-Shot Listwise Document Reranking 的文档压缩器。
retrievers.ensemble.EnsembleRetriever: 集成多个检索器的检索器。
retrievers.merger_retriever.MergerRetriever: 合并多个检索器结果的检索器。
retrievers.multi_query.LineListOutputParser: 行列表的输出解析器。
retrievers.multi_query.MultiQueryRetriever: 给定一个查询，使用 LLM 编写一组查询。
retrievers.multi_vector.MultiVectorRetriever: 从同一文档的一组多个嵌入中检索。
retrievers.multi_vector.SearchType(value): 要执行的搜索类型的枚举器。
retrievers.parent_document_retriever.ParentDocumentRetriever: 检索小块，然后检索其父文档。
retrievers.re_phraser.RePhraseQueryRetriever: 给定一个查询，使用 LLM 重述它。
retrievers.self_query.base.SelfQueryRetriever: 使用向量存储和 LLM 生成向量存储查询的检索器。
retrievers.time_weighted_retriever.TimeWeightedVectorStoreRetriever: 结合嵌入相似度和检索值的最新性的检索器。

函数 ¶

retrievers.document_compressors.chain_extract.default_get_input(...): 返回压缩链输入。
retrievers.document_compressors.chain_filter.default_get_input(...): 返回压缩链输入。
retrievers.ensemble.unique_by_key(iterable, key): 根据键函数基于迭代器的元素唯一性。

弃用的类 ¶

retrievers.document_compressors.cohere_rerank.CohereRerank: 弃用自版本 0.0.30: 使用 langchain_cohere.CohereRerank 代替。

`langchain.runnables` ¶

LangChain Runnable 和 LangChain 表达式语言 (LCEL)。

LangChain 表达式语言 (LCEL) 提供了一种声明式方法来构建利用 LLM 能力的高级程序。

使用 LCEL 和 LangChain Runnables 创建的程序自然支持同步、异步、批量和流操作。

对异步的支持允许托管基于 LCEL 的程序的服务器更好地扩展以应对更高的并发负载。

批量操作允许并行处理多个输入。

中间输出的 流式传输 允许在生成时创建更响应性的用户体验。

此模块包含非核心 Runnable 类。

类 ¶

runnables.hub.HubRunnable: 存储在 LangChain Hub 中的 Runnable 实例。
runnables.openai_functions.OpenAIFunction: ChatOpenAI 的函数描述。
runnables.openai_functions.OpenAIFunctionsRouter: 路由到选定函数的 Runnable。

`langchain.smith` ¶

LangSmith 工具。

此模块提供了连接到 LangSmith 的工具。有关 LangSmith 的更多信息，请参见 LangSmith 文档。

评估
LangSmith 帮助您使用多种 LangChain 评估器评估链和其他语言模型应用程序组件。下面是一个示例，假设您已经创建了一个名为 <my_dataset_name> 的 LangSmith 数据集：

from langsmith import Client
from langchain_community.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig, run_on_dataset

# 链可能有内存。传入构造函数允许
# 评估框架避免运行之间的交叉污染。
def construct_chain():
    llm = ChatOpenAI(temperature=0)
    chain = LLMChain.from_string(
        llm,
        "What's the answer to {your_input_key}"
    )
    return chain

# 通过配置或 EvaluatorType（字符串或枚举）加载现成的评估器
evaluation_config = RunEvalConfig(
    evaluators=[
        "qa",  # "正确性" 与参考答案相对
        "embedding_distance",
        RunEvalConfig.Criteria("helpfulness"),
        RunEvalConfig.Criteria({
            "fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
        }),
    ]
)

client = Client()
run_on_dataset(
    client,
    "<my_dataset_name>",
    construct_chain,
    evaluation=evaluation_config,
)

您也可以通过继承 StringEvaluator 或 LangSmith 的 RunEvaluator 类来创建自定义评估器。

from typing import Optional
from langchain.evaluation import StringEvaluator

class MyStringEvaluator(StringEvaluator):

    @property
    def requires_input(self) -> bool:
        return False

    @property
    def requires_reference(self) -> bool:
        return True

    @property
    def evaluation_name(self) -> str:
        return "exact_match"

    def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
        return {"score": prediction == reference}

evaluation_config = RunEvalConfig(
    custom_evaluators = [MyStringEvaluator()],
)

run_on_dataset(
    client,
    "<my_dataset_name>",
    construct_chain,
    evaluation=evaluation_config,
)

主要函数

arun_on_dataset: 异步函数，用于评估链、代理或其他 LangChain 组件在数据集上的性能。
run_on_dataset: 函数，用于评估链、代理或其他 LangChain 组件在数据集上的性能。
RunEvalConfig: 表示运行评估的配置的类。您可以通过 EvaluatorType 或配置选择评估器，或者您可以传入 custom_evaluators。

类 ¶

smith.evaluation.config.EvalConfig: 给定运行评估的配置。
smith.evaluation.config.RunEvalConfig: 运行评估的配置。
smith.evaluation.config.SingleKeyEvalConfig: 仅需要单个键的运行评估的配置。
smith.evaluation.progress.ProgressBarCallback(total): 控制台的简单进度条。
smith.evaluation.runner_utils.ChatModelInput: 聊天模型的输入。
smith.evaluation.runner_utils.EvalError(...): 您的架构引发了一个错误。
smith.evaluation.runner_utils.InputFormatError: 输入格式无效时引发。
smith.evaluation.runner_utils.TestResult: 单个测试运行结果的字典。
smith.evaluation.string_run_evaluator.ChainStringRunMapper: 从链中提取评估项目的项目。
smith.evaluation.string_run_evaluator.LLMStringRunMapper: 从运行对象中提取评估项目。
smith.evaluation.string_run_evaluator.StringExampleMapper: 将示例（或数据集中的行）映射到评估的输入。
smith.evaluation.string_run_evaluator.StringRunEvaluatorChain: 评估运行和可选示例。
smith.evaluation.string_run_evaluator.StringRunMapper: 从运行对象中提取评估项目。
smith.evaluation.string_run_evaluator.ToolStringRunMapper: 将输入映射到工具。

函数 ¶

smith.evaluation.name_generation.random_name(): 生成一个随机名称。
smith.evaluation.runner_utils.arun_on_dataset(...): 在数据集上运行链或语言模型，并将跟踪存储到指定的项目名称。
smith.evaluation.runner_utils.run_on_dataset(...): 在数据集上运行链或语言模型，并将跟踪存储到指定的项目名称。