langchain 0.2.12

langchain.agents

代理是一个使用LLM(大型语言模型)来选择一组动作的类。

在链(Chains)中,动作用硬编码的方式。在代理(Agents)中,使用语言模型作为推理引擎来确定执行哪些动作以及动作的顺序。

代理将选择并使用工具工具包进行动作。

类层次结构

BaseSingleActionAgent --> LLMSingleActionAgent
                          OpenAIFunctionsAgent
                          XMLAgent
                          Agent --> <name>Agent  # Examples: 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

由可运行对象提供的代理。

agents.agent.RunnableMultiActionAgent

由可运行对象提供的代理。

agents.agent_iterator.AgentExecutorIterator(...)

代理执行器迭代器。

agents.agent_toolkits.vectorstore.toolkit.VectorStoreInfo

关于向量存储的信息。

agents.agent_toolkits.vectorstore.toolkit.VectorStoreRouterToolkit

在向量存储之间进行路由的工具包。

agents.agent_toolkits.vectorstore.toolkit.VectorStoreToolkit

用于与向量存储交互的工具包。

agents.chat.output_parser.ChartOutputParser

聊天代理的输出解析器。

agents.conversational.output_parser.ConvoOutputParser

对话代理的输出解析器。

agents.conversational_chat.output_parser.ConvoOutputParser

对话代理的输出解析器。

agents.mrkl.base_chainConfig(动作名称, ...)

用于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

解析带有单个工具输入的json格式的ReAct风格LLM调用。

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和工具构建向量存储代理。

agents.agent_toolkits.vectorstore.base.create_vectorstore_router_agent(...)

从LLM和工具构建向量存储路由代理。

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)

解析含有工具调用的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格式化其逻辑的代理。

弃用类

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 --> <name>CallbackHandler  # Example: 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

是易于复用的组件。

链编码了对诸如模型、文档检索器、其他链等组件的一连串调用,并提供了一个简单的接口来访问这个序列。

链接口使得创建以下应用变得简单:

  • 具有状态:将内存添加到任何链中,以使其具有状态,

  • 可观察:将回调传递给链以执行额外的功能,如日志记录,在主要组件调用序列之外,

  • 可组合:将链与其他组件结合,包括其他链。

类层次结构

Chain --> <name>Chain  # Examples: 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(...)

组合_docs方法的接口。

chains.combine_documents.reduce.CombineDocsProtocol(...)

组合_docs方法的接口。

chains.combine_documents.reduce.ReduceDocumentsChain

通过递归减少文档来组合文档。

chains.combine_documents.refine.RefineDocumentsChain

通过先进行一次遍历然后对更多文档进行细化来组合文档。

chains.combine_documents.stuff.StuffDocumentsChain

通过将文档 Stuff 到上下文中来组合文档的链。

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

ConversationalRetrievalChain 的输入类型。

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, ...)

创建带有 destination 和 next_inputs 的新 Route 实例。

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

转换链输出的链。

函数

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(...)

创建一个从段落中提取信息的链。

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://python-api.langchain.ac.cn/en/latest/chains/langchain.chains.combine_documents.base.AnalyzeDocumentChain.html代替。

chains.conversation.base.ConversationChain

自版本0.2.7弃用: 使用RunnableWithMessageHistory: https://python-api.langchain.ac.cn/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 | llm`代替。

chains.qa_generation.base.QAGenerationChain

自版本0.2.7弃用: 使用example in API reference with more detail: https://python-api.langchain.ac.cn/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 的方法,该方法在支持工具调用的 ChatModel 上可用。您可以在此处了解更多关于此方法的信息:https://python.langchain.ac.cn/docs/modules/model_io/chat/structured_output/。请遵循我们关于如何使用 LLM 进行信息提取的使用案例文档以获取更多指南。https://python.langchain.ac.cn/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 的方法,该方法在支持工具调用的 ChatModel 上可用。您可以在此处了解更多关于此方法的信息:https://python.langchain.ac.cn/docs/modules/model_io/chat/structured_output/。请遵循我们关于如何使用 LLM 进行信息提取的使用案例文档以获取更多指南。https://python.langchain.ac.cn/docs/use_cases/extraction/。如果您注意到其他问题,请在此处提供反馈:https://github.com/langchain-ai/langchain/discussions/18154。使用 ``

chains.openai_tools.extraction.create_extraction_chain_pydantic(...)

自版本0.1.14已弃用: LangChain 引入了一种名为 with_structured_output 的方法,该方法在支持工具调用的 ChatModel 上可用。您可以在此处了解更多关于此方法的信息:https://python.langchain.ac.cn/docs/modules/model_io/chat/structured_output/。请遵循我们关于如何使用 LLM 进行信息提取的使用案例文档以获取更多指南。https://python.langchain.ac.cn/docs/use_cases/extraction/。当前 with_structured_output 不支持 pydantic schemas 的列表。如果您这被视为一个阻塞问题或者您注意到其他问题,请在此处提供反馈:https://github.com/langchain-ai/langchain/discussions/18154。使用 ``

chains.structured_output.base.create_openai_fn_runnable(...)

自版本0.1.14已弃用: LangChain 引入了一种名为 with_structured_output 的方法,该方法在支持工具调用的 ChatModel 上可用。您可以在此处了解更多关于此方法的信息:https://python.langchain.ac.cn/docs/modules/model_io/chat/structured_output/。请遵循我们关于如何使用 LLM 进行信息提取的使用案例文档以获取更多指南。https://python.langchain.ac.cn/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 的方法,该方法在支持工具调用的 ChatModel 上可用。您可以在此处了解更多关于此方法的信息:https://python.langchain.ac.cn/docs/modules/model_io/chat/structured_output/。请遵循我们关于如何使用 LLM 进行信息提取的使用案例文档以获取更多指南。https://python.langchain.ac.cn/docs/use_cases/extraction/。如果您注意到其他问题,请在此处提供反馈:https://github.com/langchain-ai/langchain/discussions/18154。使用 ``

langchain.chat_models

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

虽然聊天模型在底层使用语言模型,但它们暴露的接口略有不同。它们不是显示“文本输入、文本输出”API,而是提供一个接口,其中“聊天消息”是输入和输出。

类层次结构

BaseLanguageModel --> BaseChatModel --> <name>  # Examples: ChatOpenAI, ChatGooglePalm

主要助手

AIMessage, BaseMessage, HumanMessage

函数

chat_models.base.init_chat_model()

langchain.embeddings

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

嵌入模型可以是LLM或者不是。

类层次结构

Embeddings --> <name>Embeddings  # Examples: OpenAIEmbeddings, HuggingFaceEmbeddings

类别

embeddings.cache.CacheBackedEmbeddings(...)

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

langchain.evaluation

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

此模块包含现成的评估链,用于评分LangChain原语(如语言模型和链)的输出。

加载评估器

要加载评估器,可以使用带有关键字load_evaluatorsload_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")

评估的一些常见用途包括

低级别API

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

这些接口使在高级评估框架中使用它们变得更加容易。

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 Chain,用于根据准则评估运行。

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([...])

评估在……之后,预测是否等于参考

evaluation.parsing.base.JsonValidityEvaluator(...)

评估预测是否是有效的JSON。

evaluation.parsing.json_distance.JsonEditDistanceEvaluator([...])

一个计算JSON字符串之间编辑距离的评估器。

evaluation.parsing.json_schema.JsonSchemaEvaluator(...)

一个评估JSON预测与JSON参考架构的验证器。

evaluation.qa.eval_chain.ContextQAEvalChain

LLM Chain,用于根据上下文评估QA w/o GT。

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

计算预测和参考之间的字符串距离。

函数

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()

获取全局设置debug的值。

globals.get_llm_cache()

获取全局设置llm_cache的值。

globals.get_verbose()

获取全局设置verbose的值。

globals.set_debug(value)

为全局设置 debug 设置新的值。

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

索引 用于避免将重复内容写入 vectostore,以及避免在内容未改变的情况下覆盖内容。

索引也

  • 从数据创建知识图谱。

  • 支持从 LangChain 数据加载器到 vectorstores 的索引工作流程。

重要的是,即使在写入的内容是由某些来源内容(如通过截块从父文档派生出的子文档)的一组转换得出时,索引仍然可以正常工作。

indexes.vectorstore.VectorStoreIndexWrapper

围绕 vectorstore 的包装,以实现易于访问。

indexes.vectorstore.VectorstoreIndexCreator

创建索引的逻辑。

langchain.memory

内存 维护链状态,结合历史运行中的上下文。

内存的类分层

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

主要助手

BaseChatMessageHistory

聊天气息历史 存储在不同存储中的聊天气息历史。

ChatMessageHistory 的类分层

BaseChatMessageHistory --> <name>ChatMessageHistory  # Example: 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

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

它比向量存储更通用。检索器不需要能够存储文档,只需返回(或检索)它。向量存储可以用作检索器的骨干,但也有其他类型的检索器。

类层次结构

BaseRetriever --> <name>Retriever  # Examples: ArxivRetriever, MergerRetriever

主要助手

Document, Serializable, Callbacks,
CallbackManagerForRetrieverRun, AsyncCallbackManagerForRetrieverRun

retrievers.contextual_compression.ContextualCompressionRetriever

封装基本检索器并压缩结果的检索器。

retrievers.document_compressors.base.DocumentCompressorPipeline

使用Transformer管道的文档压缩器。

retrievers.document_compressors.chain_extract.LLMChainExtractor

使用LLM链提取文档相关部分的文档压缩器。

retrievers.document_compressors.chain_extract.NoOutputParser

解析可能返回某种null字符串的输出。

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 RunnableLangChain 表达式语言 (LCEL)

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

使用LCEL和LangChain Runnables创建的程序天生就支持同步、异步、批量和实时流操作。

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

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

实时输出中间输出,它们正在生成,允创建更响应的UX。

此模块包含非核心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

# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
    llm = ChatOpenAI(temperature=0)
    chain = LLMChain.from_string(
        llm,
        "What's the answer to {your_input_key}"
    )
    return chain

# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
    evaluators=[
        "qa",  # "Correctness" against a reference answer
        "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(...)

在数据集上运行链或语言模型,并将跟踪存储到指定的项目名称。

langchain.storage

实现键值存储和存储辅助工具。

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

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

storage.encoder_backed.EncoderBackedStore(...)

封装带有键和值编码器/解码器的存储。

storage.file_system.LocalFileStore(root_path, *)

工作在本地文件系统的底层存储接口。