langchain 0.2.0

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

Classes

agents.agent.Agent	[Deprecated] 代理程序调用语言模型并决定动作。
agents.agent.AgentExecutor	使用工具的代理。
agents.agent.AgentOutputParser	用于将代理输出解析为代理动作/完成的基类。
agents.agent.BaseMultiActionAgent	基础的多动作代理类。
agents.agent.BaseSingleActionAgent	基础的单动作代理类。
agents.agent.ExceptionTool	返回查询的工具。
agents.agent.LLMSingleActionAgent	[Deprecated] 用于单个动作代理的基类。
agents.agent.MultiActionAgentOutputParser	用于将代理输出解析为代理动作/完成的基类。
agents.agent.RunnableAgent	代理由可运行的任务驱动。
agents.agent.RunnableMultiActionAgent	代理由可运行的任务驱动。
agents.agent_iterator.AgentExecutorIterator(...)	AgentExecutor的迭代器。
agents.agent_toolkits.vectorstore.toolkit.VectorStoreInfo	关于VectorStore的信息。
agents.agent_toolkits.vectorstore.toolkit.VectorStoreRouterToolkit	用于在向量存储之间进行路由的工具包。
agents.agent_toolkits.vectorstore.toolkit.VectorStoreToolkit	与向量存储交互的工具包。
agents.agent_types.AgentType(value[, names, ...])	[Deprecated] 代理类型的枚举。
agents.chat.base.ChatAgent	[Deprecated] 聊天机器人。
agents.chat.output_parser.ChatOutputParser	聊天代理的输出解析器。
agents.conversational.base.ConversationalAgent	[Deprecated] 一个除了使用工具外还能进行对话的代理程序。
agents.conversational.output_parser.ConvoOutputParser	对话代理的输出解析器。
agents.conversational_chat.base.ConversationalChatAgent	[Deprecated] 一个旨在进行对话并使用工具的代理程序。
agents.conversational_chat.output_parser.ConvoOutputParser	对话代理的输出解析器。
agents.mrkl.base.ChainConfig(action_name, ...)	MRKL系统中用于链配置。
agents.mrkl.base.MRKLChain	[Deprecated] [已弃用] 实现MRKL系统的链。
agents.mrkl.base.ZeroShotAgent	[Deprecated] MRKL链的代理。
agents.mrkl.output_parser.MRKLOutputParser	MRKL输出解析器，用于聊天代理。
agents.openai_assistant.base.OpenAIAssistantAction	AgentAction 包含提交自定义工具输出到现有运行所需的信息。
agents.openai_assistant.base.OpenAIAssistantFinish	代理完成运行和线程元数据。
agents.openai_assistant.base.OpenAIAssistantRunnable	运行一个OpenAI助手。
agents.openai_assistant.base_v2.OpenAIAssistantV2Runnable	[Beta] 运行一个OpenAI助手。
agents.openai_functions_agent.agent_token_buffer_memory.AgentTokenBufferMemory	用于保存代理输出和中间步骤的内存。
agents.openai_functions_agent.base.OpenAIFunctionsAgent	[Deprecated] 由OpenAI的功能驱动API的代理。
agents.openai_functions_multi_agent.base.OpenAIMultiFunctionsAgent	[Deprecated] 由OpenAI的功能驱动的代理。
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	解析具有json格式中单个工具输入的ReAct风格LLM调用。
agents.output_parsers.react_single_input.ReActSingleInputOutputParser	解析具有单个工具输入的ReAct风格LLM调用。
agents.output_parsers.self_ask.SelfAskOutputParser	解析自问自答风格的LLM调用。
agents.output_parsers.tools.ToolAgentAction	覆盖init以支持通过位置进行实例化，以实现向后兼容。
agents.output_parsers.tools.ToolsAgentOutputParser	将消息解析为代理动作/完成。
agents.output_parsers.xml.XMLAgentOutputParser	解析工具调用和最终答案的XML格式。
agents.react.base.DocstoreExplorer(docstore)	[Deprecated] 用于辅助探索文档存储的类。
agents.react.base.ReActChain	[Deprecated] [已弃用] 实现ReAct论文的链条。
agents.react.base.ReActDocstoreAgent	[Deprecated] ReAct链的代理。
agents.react.base.ReActTextWorldAgent	[Deprecated] ReAct TextWorld链的代理。
agents.react.output_parser.ReActOutputParser	ReAct代理的输出解析器。
agents.schema.AgentScratchPadChatPromptTemplate	代理人备忘录的聊天提示模板。
agents.self_ask_with_search.base.SelfAskWithSearchAgent	[Deprecated] 自问自答搜索论文的代理。
agents.self_ask_with_search.base.SelfAskWithSearchChain	[Deprecated] [已弃用] 执行自我询问并进行搜索的链。
agents.structured_chat.base.StructuredChatAgent	[Deprecated] 结构化聊天机器人。
agents.structured_chat.output_parser.StructuredChatOutputParser	结构化聊天代理的输出解析器。
agents.structured_chat.output_parser.StructuredChatOutputParserWithRetries	为结构化聊天代理设置带有重试功能的输出解析器。
agents.tools.InvalidTool	当代理遇到无效的工具名称时运行的工具。
agents.xml.base.XMLAgent	[Deprecated] 代理程序使用XML标记。

Functions

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，工具输出）元组转换为FunctionMessages。
agents.format_scratchpad.xml.format_xml(...)	将中间步骤格式化为XML。
agents.initialize.initialize_agent(tools, llm)	[Deprecated] 加载给定工具和LLM的代理执行器。
agents.json_chat.base.create_json_chat_agent(...)	创建一个代理，使用JSON格式化其逻辑，为聊天模型构建。
agents.loading.load_agent(path, **kwargs)	[Deprecated] 统一的方法，用于从LangChainHub或本地文件系统加载代理。
agents.loading.load_agent_from_config(config)	[Deprecated] 从配置字典中加载代理。
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)	解析一个可能包含工具调用的AI消息。
agents.output_parsers.tools.parse_ai_message_to_tool_action(message)	解析可能包含工具调用的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格式化其逻辑的代理。

langchain.callbacks

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

类层次结构:

BaseCallbackHandler --> <name>CallbackHandler  # 例如: AimCallbackHandler

Classes

callbacks.streaming_aiter.AsyncIteratorCallbackHandler()	回调处理程序，返回一个异步迭代器。
callbacks.streaming_aiter_final_only.AsyncFinalIteratorCallbackHandler(*)	回调处理程序，返回一个异步迭代器。 仅迭代代理的最终输出。
callbacks.streaming_stdout_final_only.FinalStreamingStdOutCallbackHandler(*)	代理流处理程序的回调函数。 仅适用于支持流式处理的LLM代理。
callbacks.tracers.logging.LoggingCallbackHandler(logger)	通过输入日志记录器记录的追踪器。

langchain.chains

**链**是易于重复使用的组件，它们链接在一起。

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

链接口使得创建以下类型的应用程序变得容易：

• 有状态的： 为任何链添加内存以赋予其状态，

• 可观察的： 传递回调函数给链以执行额外功能，比如日志记录，超出组件调用主序列之外，

• 可组合的： 将链与其他组件（包括其他链）组合在一起。

类层次结构：

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

Classes

chains.api.base.APIChain	用于进行API调用并总结响应以回答问题的链。
chains.base.Chain	用于创建组件调用序列的结构化序列的抽象基类。
chains.combine_documents.base.AnalyzeDocumentChain	链条，用于拆分文档，然后逐段分析。
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.conversation.base.ConversationChain	链条用于进行对话并从内存中加载上下文。
chains.conversational_retrieval.base.BaseConversationalRetrievalChain	用于与索引进行聊天的链条。
chains.conversational_retrieval.base.ChatVectorDBChain	用于与向量数据库进行聊天的链。
chains.conversational_retrieval.base.ConversationalRetrievalChain	[Deprecated] 基于检索文档的对话链。
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.LLMChain	[Deprecated] 链式查询LLMs。
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_generation.base.QAGenerationChain	用于问题-答案生成链的基类。
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.RetrievalQA	[Deprecated] 用于针对索引进行问答的链。
chains.retrieval_qa.base.VectorDBQA	用于针对向量数据库进行问答的链。
chains.router.base.MultiRouteChain	使用单一链将输入路由到多个候选链中的一个。
chains.router.base.Route(destination, ...)	Create new instance of 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路由器链来在检索qa链之间进行选择。
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	链条，用于转换链条输出。

Functions

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.base.create_openai_fn_chain(...)	[Deprecated] [传统] 创建一个使用OpenAI函数的LLM链。
chains.openai_functions.base.create_structured_output_chain(...)	[Deprecated] [遗留] 创建一个LLMChain，使用OpenAI函数来获取结构化输出。
chains.openai_functions.citation_fuzzy_match.create_citation_fuzzy_match_chain(llm)	创建一个引文模糊匹配链。
chains.openai_functions.extraction.create_extraction_chain(...)	[Deprecated] 创建一个从段落中提取信息的链。
chains.openai_functions.extraction.create_extraction_chain_pydantic(...)	[Deprecated] 创建一个链条，使用pydantic模式从一个段落中提取信息。
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.openai_tools.extraction.create_extraction_chain_pydantic(...)	[Deprecated] 创建一个从段落中提取信息的链。
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.create_openai_fn_runnable(...)	[Deprecated] 创建一个可运行的序列，使用OpenAI函数。
chains.structured_output.base.create_structured_output_runnable(...)	[Deprecated] 创建一个可运行的程序，用于提取结构化输出。
chains.structured_output.base.get_openai_output_parser(...)	给定用户函数，获取适当的函数输出解析器。
chains.summarize.chain.load_summarize_chain(llm)	加载总结链。

langchain.embeddings

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

嵌入模型 可以是LLMs，也可以不是。

类层次结构:

嵌入 --> <name>嵌入  # 例子: OpenAI嵌入, HuggingFace嵌入

Classes

embeddings.cache.CacheBackedEmbeddings(...)

用于缓存嵌入模型结果的接口。

langchain.evaluation

评估 链用于对LLM和Chain输出进行评分。

该模块包含用于对语言链基元（如语言模型和链）的输出进行评分的现成评估链。

加载评估器

要加载评估器，可以使用 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 或 :class:`LabeledPairwiseStringEvalChain <langchain.evaluation.comparison.eval_chain.LabeledPairwiseStringEvalChain>`（当还有参考标签时）。

• 评估代理工具使用的有效性： TrajectoryEvalChain

• 检查输出是否符合一组标准： CriteriaEvalChain 或 :class:`LabeledCriteriaEvalChain <langchain.evaluation.criteria.eval_chain.LabeledCriteriaEvalChain>`（当还有参考标签时）。

• 计算预测和参考之间的语义差异： EmbeddingDistanceEvalChain 或计算两个预测之间的差异： PairwiseEmbeddingDistanceEvalChain

• 测量预测和参考之间的字符串距离： StringDistanceEvalChain 或计算两个预测之间的距离： PairwiseStringDistanceEvalChain

低级API

这些评估器实现以下接口之一：

• StringEvaluator: 对预测字符串与参考标签和/或输入上下文进行评估。

• PairwiseStringEvaluator: 对两个预测字符串进行相互评估。用于评分偏好、衡量两个链或LLM代理之间的相似性，或比较类似输入上的输出。

• AgentTrajectoryEvaluator: 评估代理所采取的完整动作序列。

这些接口使得在更高级别的评估框架中更容易地进行组合和使用。

Classes

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	用于根据上下文评估没有基于GT的QA的LLM链。
evaluation.qa.eval_chain.CotQAEvalChain	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	计算预测值和参考值之间的字符串距离。

Functions

evaluation.comparison.eval_chain.resolve_pairwise_criteria(...)	解析成对评估器的标准。
evaluation.criteria.eval_chain.resolve_criteria(...)	解析用于评估的标准。
evaluation.loading.load_dataset(uri)	从`HuggingFace上的LangChainDatasets <https://huggingface.co/LangChainDatasets>`_加载数据集。
evaluation.loading.load_evaluator(evaluator, *)	加载指定的评估链。
evaluation.loading.load_evaluators(evaluators, *)	加载由评估器类型列表指定的评估器。
evaluation.scoring.eval_chain.resolve_criteria(...)	解析成对评估器的标准。

langchain.hub

与LangChain Hub进行接口交互。

Functions

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

langchain.indexes

索引 用于避免将重复内容写入向量存储，并在内容未更改时避免覆盖内容。

索引还有：

• 从数据创建知识图。

• 支持从LangChain数据加载程序到向量存储的索引工作流程。

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

Classes

indexes.vectorstore.VectorStoreIndexWrapper	封装了一个向量存储，以便更容易访问。
indexes.vectorstore.VectorstoreIndexCreator	创建索引的逻辑。

langchain.memory

Memory 维护链状态，整合了过去运行的上下文。

Memory的类层次结构:

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

主要辅助功能:

BaseChatMessageHistory

Chat Message History 存储不同存储中的聊天消息历史记录。

ChatMessageHistory的类层次结构:

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

主要辅助功能:

AIMessage, BaseMessage, HumanMessage

Classes

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	摘要生成器的Mixin。
memory.summary_buffer.ConversationSummaryBufferMemory	用于存储对话记忆的带有总结器的缓冲区。
memory.token_buffer.ConversationTokenBufferMemory	对话聊天内存，带有令牌限制。
memory.vectorstore.VectorStoreRetrieverMemory	基于VectorStoreRetriever的内存。

Functions

memory.utils.get_prompt_input_key(inputs, ...)

获取提示输入键。

langchain.model_laboratory

尝试不同的模型。

Classes

model_laboratory.ModelLaboratory(chains[, names])

尝试不同的模型。

langchain.output_parsers

OutputParser 类用于解析LLM调用的输出。

类层次结构:

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

主要辅助类:

Serializable, Generation, PromptValue

Classes

output_parsers.boolean.BooleanOutputParser	将LLM调用的输出解析为布尔值。
output_parsers.combining.CombiningOutputParser	将多个输出解析器合并为一个。
output_parsers.datetime.DatetimeOutputParser	将LLM调用的输出解析为datetime。
output_parsers.enum.EnumOutputParser	解析一个属于一组值之一的输出。
output_parsers.fix.OutputFixingParser	封装一个解析器并尝试修复解析错误。
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.RetryWithErrorOutputParser	封装一个解析器并尝试修复解析错误。
output_parsers.structured.ResponseSchema	用于结构化输出解析器响应的模式。
output_parsers.structured.StructuredOutputParser	解析LLM调用的输出，转换为结构化输出。
output_parsers.yaml.YamlOutputParser	使用pydantic模型解析YAML输出。

Functions

output_parsers.loading.load_output_parser(config)

加载一个输出解析器。

langchain.retrievers

Retriever类根据文本查询返回文档。

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

类层次结构:

BaseRetriever --> <name>Retriever  # 例如：ArxivRetriever, MergerRetriever

主要辅助功能:

Document, Serializable, Callbacks,
CallbackManagerForRetrieverRun, AsyncCallbackManagerForRetrieverRun

Classes

retrievers.contextual_compression.ContextualCompressionRetriever	包装基础检索器并压缩结果的检索器。
retrievers.document_compressors.base.DocumentCompressorPipeline	使用一系列变换器的文档压缩器。
retrievers.document_compressors.chain_extract.LLMChainExtractor	使用LLM链提取文档中相关部分的文档压缩器。
retrievers.document_compressors.chain_extract.NoOutputParser	解析可能返回某种空字符串的输出。
retrievers.document_compressors.chain_filter.LLMChainFilter	过滤器，删除与查询不相关的文档。
retrievers.document_compressors.cohere_rerank.CohereRerank	[Deprecated] 使用`Cohere Rerank API`的文档压缩器。
retrievers.document_compressors.cross_encoder.BaseCrossEncoder()	用于交叉编码器模型的接口。
retrievers.document_compressors.cross_encoder_rerank.CrossEncoderReranker	使用CrossEncoder进行重新排序的文档压缩器。
retrievers.document_compressors.embeddings_filter.EmbeddingsFilter	使用嵌入来压缩文档，以删除与查询无关的文档。
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	检索器，结合嵌入相似性和最近性来检索数值。

Functions

retrievers.document_compressors.chain_extract.default_get_input(...)	返回压缩链的输入。
retrievers.document_compressors.chain_filter.default_get_input(...)	返回压缩链输入。
retrievers.ensemble.unique_by_key(iterable, key)	基于键函数，生成可迭代对象的唯一元素。

langchain.runnables

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

LangChain 表达式语言 (LCEL) 提供了一种声明性方法来构建利用 LLMs 强大功能的生产级程序。

使用 LCEL 和 LangChain Runnable 创建的程序天然支持同步、异步、批处理和流处理操作。

支持 async 允许托管基于 LCEL 的程序的服务器更好地扩展以处理更高的并发负载。

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

在生成中间输出时进行 Streaming ，允许创建更具响应性的用户体验。

此模块包含非核心的 Runnable 类。

Classes

runnables.hub.HubRunnable	一个存储在LangChain Hub中的可运行实例。
runnables.openai_functions.OpenAIFunction	ChatOpenAI的函数描述
runnables.openai_functions.OpenAIFunctionsRouter	一个可运行的程序，用于路由到所选的函数。

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": "回答这个问题是否需要比五年级生更聪明？"
        }),
    ]
)

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。

Classes

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	将输入映射到工具。

Functions

smith.evaluation.name_generation.random_name()	生成一个随机名称。
smith.evaluation.runner_utils.arun_on_dataset(...)	Run the Chain or language model on a dataset and store traces to the specified project name.
smith.evaluation.runner_utils.run_on_dataset(...)	Run the Chain or language model on a dataset and store traces to the specified project name.

langchain.storage

实现键值存储和存储助手。

该模块提供了符合简单键值接口的各种键值存储的实现。

这些存储的主要目标是支持缓存的实现。

Classes

storage.encoder_backed.EncoderBackedStore(...)	使用键和值编码器/解码器包装存储。
storage.file_system.LocalFileStore(root_path, *)	基于本地文件系统的BaseStore接口。