langchain_core 0.2.28

langchain_core.agents

表示代理操作、观察和返回值模式的定义。

注意 模式定义提供向后兼容性。

应使用 langgraph 库（https://github.com/langchain-ai/langgraph）来构建新的代理，该库以更简单、更灵活的方式定义代理。

有关如何将现有代理迁移到现代 langgraph 代理的信息，请参阅迁移指南：https://python.langchain.ac.cn/v0.2/docs/how_to/migrate_agent/

代理使用语言模型来选择要采取的动作序列。

一个基本的代理按以下方式运行

1. 给定一个提示，代理使用一个语言模型来请求采取的操作（例如，运行工具）。

2. 代理执行操作（例如，运行工具），并接收到一个观察值。

3. 代理将观察值返回给语言模型，该模型可以用来生成下一个操作。

4. 当代理达到停止条件时，它返回一个最终的返回值。

代理自身的模式定义在 langchain.agents.agent 中。

类

agents.AgentAction	表示代理请求执行动作。
agents.AgentActionMessageLog	表示代理要执行的动作。
agents.AgentFinish	ActionAgent 的最终返回值。
agents.AgentStep	运行代理操作的结果。

langchain_core.beta

一些尚未准备用于生产的 beta 功能。

类

beta.runnables.context.Context()	runnable 的上下文。
beta.runnables.context.ContextGet
beta.runnables.context.ContextSet
beta.runnables.context.PrefixContext([prefix])	具有前缀的 runnable 的上下文。

函数

beta.runnables.context.aconfig_with_context(...)	异步修补带有上下文获取器和设置器的 runnable 配置。
beta.runnables.context.config_with_context(...)	修补带有上下文获取器和设置器的 runnable 配置。

langchain_core.caches

警告

Beta 功能！

缓存 为 LLM 提供了一个可选的缓存层。

Cache 有两个原因很有用

• 如果您经常请求相同的完成内容多次，它可以省钱，通过减少对 LLM 提供商的 API 调用次数。

• 它可以通过减少对 LLM 提供商的 API 调用次数来加速您的应用程序。

Cache 直接与 Memory 竞争。请参阅文档以了解利弊。

类层次结构

BaseCache --> <name>Cache  # Examples: InMemoryCache, RedisCache, GPTCache

类

caches.BaseCache()	LLM 和 Chat 模型的缓存层接口。
caches.InMemoryCache(*[, maxsize])	存储在内存中的缓存。

langchain_core.callbacks

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

类层次结构

BaseCallbackHandler --> <name>CallbackHandler  # Example: AimCallbackHandler

类

callbacks.base.AsyncCallbackHandler()	LangChain 的异步回调处理程序。
callbacks.base.BaseCallbackHandler()	LangChain 的基本回调处理程序。
callbacks.base.BaseCallbackManager(handlers)	LangChain 的基本回调管理器。
callbacks.base.CallbackManagerMixin()	回调管理器的混合。
callbacks.base.ChainManagerMixin()	链回调的混合。
callbacks.base.LLMManagerMixin()	LLM回调的混合。
callbacks.base.RetrieverManagerMixin()	检索器回调的混合。
callbacks.base.RunManagerMixin()	运行管理器的混合。
callbacks.base.ToolManagerMixin()	工具回调的混合。
callbacks.file.FileCallbackHandler(filename)	将数据写入文件的回调处理程序。
callbacks.manager.AsyncCallbackManager(handlers)	处理来自 LangChain 的回调的异步回调管理器。
callbacks.manager.AsyncCallbackManagerForChainGroup(...)	链组的异步回调管理器。
callbacks.manager.AsyncCallbackManagerForChainRun(*, ...)	链运行异步回调管理器。
callbacks.manager.AsyncCallbackManagerForLLMRun(*, ...)	LLM 运行的异步回调管理器。
callbacks.manager.AsyncCallbackManagerForRetrieverRun(*, ...)	检索器运行的异步回调管理器。
callbacks.manager.AsyncCallbackManagerForToolRun(*, ...)	工具运行的异步回调管理器。
callbacks.manager.AsyncParentRunManager(*, ...)	异步父运行管理器。
callbacks.manager.AsyncRunManager(*, run_id, ...)	异步运行管理器。
callbacks.manager.BaseRunManager(*, run_id, ...)	运行管理器的基类（一个绑定回调管理器）。
callbacks.manager.CallbackManager(处理器)	LangChain的回调管理器。
callbacks.manager.CallbackManagerForChainGroup(...)	链组的回调管理器。
callbacks.manager.CallbackManagerForChainRun(*, ...)	链运行回调管理器。
callbacks.manager.CallbackManagerForLLMRun(*, ...)	LLM运行回调管理器。
callbacks.manager.CallbackManagerForRetrieverRun(*, ...)	检索器运行回调管理器。
callbacks.manager.CallbackManagerForToolRun(*, ...)	工具运行回调管理器。
callbacks.manager.ParentRunManager(*, ...[, ...])	同步父运行管理器。
callbacks.manager.RunManager(*, run_id, ...)	同步运行管理器。
callbacks.stdout.StdOutCallbackHandler([color])	打印到标准输出的回调处理器。
callbacks.streaming_stdout.StreamingStdOutCallbackHandler()	流式回调处理器。

函数

callbacks.manager.adispatch_custom_event(...)	向处理器发送一个临时的活动事件。
callbacks.manager.ahandle_event(handlers, ...)	AsyncCallbackManager的异步通用事件处理器。
callbacks.manager.atrace_as_chain_group(...)	在上下文管理器中获取链组的异步回调管理器。
callbacks.manager.dispatch_custom_event(...)	发送一个临时的活动事件。
callbacks.manager.handle_event(handlers, ...)	CallbackManager的通用事件处理器。
callbacks.manager.shielded(func)	确保awaitable方法总是受到抵消保护。
callbacks.manager.trace_as_chain_group(...)	在上下文管理器中获取链组的回调管理器。

langchain_core.chat_history

聊天消息历史 存储了聊天中消息交互的历史。

类层次结构

BaseChatMessageHistory --> <name>ChatMessageHistory  # Examples: FileChatMessageHistory, PostgresChatMessageHistory

主要助手

AIMessage, HumanMessage, BaseMessage

类

chat_history.BaseChatMessageHistory()	存储聊天消息历史记录的抽象基类。
chat_history.InMemoryChatMessageHistory	内存中的聊天消息历史实现。

langchain_core.chat_loaders

类

chat_loaders.BaseChatLoader()

聊天加载器的基础类。

langchain_core.chat_sessions

聊天会话 是一系列消息和函数调用的集合。

类

chat_sessions.ChatSession

聊天会话表示单次对话、频道或其他消息组合。

langchain_core.document_loaders

类

document_loaders.base.BaseBlobParser()	抽象接口，用于处理块解析器。
document_loaders.base.BaseLoader()	文档加载器的接口。
document_loaders.blob_loaders.BlobLoader()	实现块加载器的抽象接口。

langchain_core.documents

文档 模块包含一组用于处理文档及其转换的类。

类

documents.base.BaseMedia	用于表示媒体内容。
documents.base.Blob	Blob通过引用或值表示原始数据。
documents.base.Document	用于存储文本及其相关元数据的类。
documents.compressor.BaseDocumentCompressor	文档压缩器的基类。
documents.transformers.BaseDocumentTransformer()	文档转换的抽象基类。

langchain_core.embeddings

类

embeddings.embeddings.Embeddings()	嵌入模型的接口。
embeddings.fake.DeterministicFakeEmbedding	确定性伪造嵌入模型，用于单元测试目的。
embeddings.fake.FakeEmbeddings	伪造嵌入模型，用于单元测试目的。

langchain_core.example_selectors

示例选择器 实现了选择示例的逻辑，以便在提示中包含它们。这允许我们选择与输入最相关的示例。

类

example_selectors.base.BaseExampleSelector()	选择用于提示中包括的示例的接口。
example_selectors.length_based.LengthBasedExampleSelector	根据长度选择示例。
example_selectors.semantic_similarity.MaxMarginalRelevanceExampleSelector	根据最大边际相关性选择示例。
example_selectors.semantic_similarity.SemanticSimilarityExampleSelector	根据语义相似度选择示例。

函数

example_selectors.semantic_similarity.sorted_values(values)

根据键对字典中的值进行排序并返回值列表。

langchain_core.exceptions

LangChain的定制异常。

类

exceptions.LangChainException	通用LangChain异常。
exceptions.OutputParserException(error[, ...])	输出解析器应抛出的异常以指示解析错误。
exceptions.TracerException	跟踪器模块中异常的基类。

langchain_core.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_core.graph_vectorstores

类

graph_vectorstores.base.GraphVectorStore(...)
graph_vectorstores.base.GraphVectorStoreRetriever	GraphVectorStore的检索类。
graph_vectorstores.base.Node	GraphVectorStore中的节点。
graph_vectorstores.links.Link(kind, ...)	给定标签到/从标签的链接。

函数

graph_vectorstores.base.nodes_to_documents(nodes)
graph_vectorstores.links.add_links(doc, *links)	向给定元数据添加链接。
graph_vectorstores.links.copy_with_links(...)	返回带有给定链接的文档。
graph_vectorstores.links.get_links(doc)	从文档中获取链接。

langchain_core.indexing

将数据索引到向量存储中的辅助代码。

此包包含帮助逻辑，以帮助将数据索引到向量存储，同时避免重复内容，并在内容未更改时避免覆盖内容。

类

indexing.api.IndexingResult	返回索引操作结果的详细分解。
indexing.base.DeleteResponse	删除操作的通用响应。
indexing.base.DocumentIndex
indexing.base.InMemoryRecordManager(namespace)	用于测试的内存中记录管理器。
indexing.base.RecordManager(namespace)	表示记录管理器接口的抽象基类。
indexing.base.UpsertResponse	更新插入操作的通用响应。
indexing.in_memory.InMemoryDocumentIndex

函数

indexing.api.aindex(docs_source, ...[, ...])	从加载器中异步索引数据到向量存储。
indexing.api.index(docs_source, ...[, ...])	将数据从加载器索引到向量存储。

langchain_core.language_models

语言模型 是一种可以生成文本或完成文本提示的模型。

LangChain主要有两个类来处理语言模型：聊天模型 和“传统”的 LLMs。

## 聊天模型

使用一组消息作为输入并返回聊天消息作为输出的语言模型（与使用纯文本相反）。这些是传统的更新型号（更老型的模型通常是LLMs，见下文）。聊天模型支持将不同角色分配给对话消息，帮助区分来自AI、用户和系统消息等指令的消息。

聊天模型的关键抽象是 BaseChatModel。实现应该继承此类。请参阅LangChain如何指南，了解有关如何实现自定义聊天模型的更多信息。

要实现自定义聊天模型，继承自 BaseChatModel。以下指南提供了更多关于如何实现自定义聊天模型的信息

https://python.langchain.ac.cn/v0.2/docs/how_to/custom_chat_model/

## LLMs

将字符串作为输入并返回字符串的语言模型。这些是传统的更老型模型（更新型的模型通常是聊天模型，见下文）。

尽管底层模型是字符串输入，字符串输出，LangChain包装器也允许这些模型以消息作为输入。这使得它们的接口与Chat模型相同。当以输入形式传递消息时，它们将在传递给底层模型之前在后台格式化为字符串。

要实现自定义的LLM，从< cite>BaseLLM或< cite>LLM继承。有关如何实现自定义LLM的更多信息，请参阅以下指南

https://python.langchain.ac.cn/v0.2/docs/how_to/custom_llm/

类

language_models.base.BaseLanguageModel	与语言模型接口的抽象基类。
language_models.chat_models.BaseChatModel	聊天模型的基类。
language_models.chat_models.LangSmithParams	LangSmith跟踪参数。
language_models.chat_models.SimpleChatModel	简化实现，用于聊天模型继承。
language_models.fake.FakeListLLM	用于测试的假LLM。
language_models.fake.FakeStreamingListLLM	用于测试的假流列表LLM。
language_models.fake_chat_models.FakeChatModel	用于测试的假聊天模型包装器。
language_models.fake_chat_models.FakeListChatModel	用于测试的假ChatModel。
language_models.fake_chat_models.FakeMessagesListChatModel	用于测试的假ChatModel。
language_models.fake_chat_models.GenericFakeChatModel	通用的假聊天模型，可用于测试聊天模型接口。
language_models.fake_chat_models.ParrotFakeChatModel	通用的假聊天模型，可用于测试聊天模型接口。
language_models.llms.BaseLLM	基本LLM抽象接口。
language_models.llms.LLM	简单的接口，用于实现自定义LLM。

函数

language_models.chat_models.agenerate_from_stream(stream)	从流异步生成。
language_models.chat_models.generate_from_stream(stream)	从流生成。
language_models.llms.aget-prompts(params, ...)	获取已缓存的提示。
language_models.llms.aupdate-cache(cache, ...)	更新缓存并获取LLM输出。
language_models.llms.create_base_retry_decorator(...)	为给定LLM和提供的创建重试装饰器
language_models.llms.get-prompts(params, prompts)	获取已缓存的提示。
language_models.llms.update-cache(cache, ...)	更新缓存并获取LLM输出。

langchain_core.load

加载模块有助于序列化和反序列化。

类

load.load.Reviver([secrets_map, ...])	JSON对象的Reviver。
load.serializable.BaseSerialized	序列化对象的基本类。
load.serializable.Serializable	序列化基本类。
load.serializable.SerializedConstructor	序列化构造函数。
load.serializable.SerializedNotImplemented	序列化未实现。
load.serializable.SerializedSecret	序列化密钥。

函数

load.dump.default(obj)	返回Serializable对象或SerializedNotImplemented对象的默认值。
load.dump.dumpd(obj)	返回对象的字典表示。
load.dump.dumps(obj,​ *[， becky ])	返回对象的JSON字符串表示。
load.load.load(obj,​ *[， secrets_map， ... ])
load.load.loads(text,​ *[， secrets_map， ... ])
load.serializable.to_json_not_implemented(obj)	序列化“未实现”对象。
load.serializable.try_neq_default(value,​ ...)	尝试确定一个值是否与默认值不同。

langchain_core.memory

Memory 维护Chain状态，结合过去运行的上下文。

Memory类继承结构

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

类

memory.BaseMemory

Chains中内存的抽象基类。

langchain_core.messages

Messages 是在提示和聊天对话中使用的对象。

类层次结构

BaseMessage --> SystemMessage, AIMessage, HumanMessage, ChatMessage, FunctionMessage, ToolMessage
            --> BaseMessageChunk --> SystemMessageChunk, AIMessageChunk, HumanMessageChunk, ChatMessageChunk, FunctionMessageChunk, ToolMessageChunk

主要助手

ChatPromptTemplate

类

messages.ai.AIMessage	AI的消息。
messages.ai.AIMessageChunk	AI消息块。
messages.ai.UsageMetadata	消息的使用元数据，例如token计数。
messages.base.BaseMessage	基础抽象消息类。
messages.base.BaseMessageChunk	消息块，可以与其他消息块连接。
messages.chat.ChatMessage	可以分配任意说话者的消息（即。
messages.chat.ChatMessageChunk	聊天消息块。
messages.function.FunctionMessage	用于将工具执行结果传递回模型的消息。
messages.function.FunctionMessageChunk	函数消息块。
messages.human.HumanMessage	人类的消息。
messages.human.HumanMessageChunk	人类消息块。
messages.modifier.RemoveMessage
messages.system.SystemMessage	用于启蒙AI行为的消息。
messages.system.SystemMessageChunk	系统消息块。
messages.tool.InvalidToolCall	允许LLM犯错误。
messages.tool.ToolCall	代表调用工具的请求。
messages.tool.ToolCallChunk	工具调用块的一部分（例如，作为流的一部分）。
messages.tool.ToolMessage	用于将工具执行结果传递回模型的消息。
messages.tool.ToolMessageChunk	工具消息块。

函数

messages.ai.add_ai_message_chunks(left, *others)	将多个 AIMessageChunk 合并起来。
messages.base.get_msg_title_repr(title, *[, ...])	获取消息的标题表示。
messages.base.merge_content(first_content, ...)	合并两个消息内容。
messages.base.message_to_dict(message)	将消息转换为字典。
messages.base.messages_to_dict(messages)	将消息序列转换为字典列表。
messages.tool.default_tool_chunk_parser(...)	对工具块进行最佳努力解析。
messages.tool.default_tool_parser(raw_tool_calls)	对工具进行最佳努力解析。
messages.tool.invalid_tool_call(*[, name, ...])
messages.tool.tool_call(*, name, args, id)
messages.tool.tool_call_chunk(*, name, ...)
messages.utils.convert_to_messages(messages)	将消息序列转换为消息列表。
messages.utils.filter_messages([messages])	根据名称、类型或 ID 过滤消息。
messages.utils.get_buffer_string(messages[, ...])	将消息序列转换为字符串并将它们连接成一个字符串。
messages.utils.merge_message_runs([messages])	合并相同类型的连续消息。
messages.utils.message_chunk_to_message(chunk)	将消息块转换成消息。
messages.utils.messages_from_dict(messages)	将消息序列从字典转换为Message对象。
messages.utils.trim_messages([messages])	修剪消息以使令牌数低于特定值。

langchain_core.output_parsers

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

类层次结构

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

主要助手

Serializable, Generation, PromptValue

类

output_parsers.base.BaseGenerationOutputParser	解析 LLM 调用输出的基类。
output_parsers.base.BaseLLMOutputParser()	用于解析模型输出结果的抽象基类。
output_parsers.base.BaseOutputParser	解析 LLM 调用输出的基类。
output_parsers.json.JsonOutputParser	将 LLM 调用的输出解析为 JSON 对象。
output_parsers.json.SimpleJsonOutputParser	是 JsonOutputParser 的别名
output_parsers.list.CommaSeparatedListOutputParser	将 LLM 调用的输出解析为逗号分隔的列表。
output_parsers.list.ListOutputParser	将 LLM 调用的输出解析为列表。
output_parsers.list.MarkdownListOutputParser	解析 Markdown 列表。
output_parsers.list.NumberedListOutputParser	解析编号列表。
output_parsers.openai_functions.JsonKeyOutputFunctionsParser	将输出作为 Json 对象的元素解析。
output_parsers.openai_functions.JsonOutputFunctionsParser	将输出作为 Json 对象解析。
output_parsers.openai_functions.OutputFunctionsParser	解析一种组值之一的输出。
output_parsers.openai_functions.PydanticAttrOutputFunctionsParser	将输出作为 pydantic 对象的属性解析。
output_parsers.openai_functions.PydanticOutputFunctionsParser	将输出作为 pydantic 对象解析。
output_parsers.openai_tools.JsonOutputKeyToolsParser	解析 OpenAI 响应中的工具。
output_parsers.openai_tools.JsonOutputToolsParser	解析 OpenAI 响应中的工具。
output_parsers.openai_tools.PydanticToolsParser	解析 OpenAI 响应中的工具。
output_parsers.pydantic.PydanticOutputParser	使用 pydantic 模型解析输出。
output_parsers.string.StrOutputParser	将 LLMResult 解析为最可能的字符串的 OutputParser。
output_parsers.transform.BaseCumulativeTransformOutputParser	用于处理流输入的输出解析器的基类。
output_parsers.transform.BaseTransformOutputParser	用于处理流输入的输出解析器的基类。
output_parsers.xml.XMLOutputParser	使用 xml 格式解析输出。

函数

output_parsers.list.droplastn(iter, n)	丢弃迭代器的最后 n 个元素。
output_parsers.openai_tools.make_invalid_tool_call(...)	从原始工具调用创建 InvalidToolCall。
output_parsers.openai_tools.parse_tool_call(...)	解析单个工具调用。
output_parsers.openai_tools.parse_tool_calls(...)	解析工具调用的列表。
output_parsers.xml.nested_element(path, elem)	从路径获取嵌套元素。

langchain_core.outputs

输出类用于表示语言模型调用和聊天输出的结果。

信息的高级容器是一个< nóngain ): LLMResult

由聊天模型和LLM使用。此对象包含语言模型的输出以及模型提供者希望返回的任何其他信息。

通过标准可运行方法调用模型（例如，调用、批处理等）： - 聊天模型将返回< nóngain >AIMessage

对象。 - LLM将返回常规文本字符串。

类

outputs.chat_generation.ChatGeneration	单个聊天生成输出。
outputs.chat_generation.ChatGenerationChunk	聊天生成块，可以与其他ChatGeneration块连接。
outputs.chat_result.ChatResult	用于表示单次提示的聊天模型调用结果。
outputs.generation.Generation	单个文本生成输出。
outputs.generation.GenerationChunk	生成块，可以与其他生成块连接。
outputs.llm_result.LLMResult	LLM调用结果的容器。
outputs.run_info.RunInfo	包含单个执行链或模型的元数据的类。

langchain_core.prompt_values

提示值用于语言模型提示。

提示值用于表示不同部分的提示。它们可以用于表示文本、图像或聊天消息片段。

类

prompt_values.ChatPromptValue	聊天提示值。
prompt_values.ChatPromptValueConcrete	聊天提示值，明确列出它接受的消息类型。
prompt_values.ImagePromptValue	图像提示值。
prompt_values.ImageURL	图像URL。
prompt_values.PromptValue	任何语言模型输入的直接抽象基类。
prompt_values.StringPromptValue	字符串提示值。

langchain_core.prompts

提示是模型输入。

提示通常由多个组件和提示值构建。提示类和函数使构建

和使用提示变得容易。

类层次结构

BasePromptTemplate --> PipelinePromptTemplate
                       StringPromptTemplate --> PromptTemplate
                                                FewShotPromptTemplate
                                                FewShotPromptWithTemplates
                       BaseChatPromptTemplate --> AutoGPTPrompt
                                                  ChatPromptTemplate --> AgentScratchPadChatPromptTemplate



BaseMessagePromptTemplate --> MessagesPlaceholder
                              BaseStringMessagePromptTemplate --> ChatMessagePromptTemplate
                                                                  HumanMessagePromptTemplate
                                                                  AIMessagePromptTemplate
                                                                  SystemMessagePromptTemplate

类

prompts.base.BasePromptTemplate	所有提示模板的基类，返回一个提示。
prompts.chat.AIMessagePromptTemplate	AI消息提示模板。
prompts.chat.BaseChatPromptTemplate	聊天提示模板的基类。
prompts.chat.BaseMessagePromptTemplate	消息提示模板的基类。
prompts.chat.BaseStringMessagePromptTemplate	使用字符串提示模板的消息提示模板的基类。
prompts.chat.ChatMessagePromptTemplate	聊天消息提示模板。
prompts.chat.ChatPromptTemplate	聊天模型提示模板。
prompts.chat.HumanMessagePromptTemplate	人工消息提示模板。
prompts.chat.MessagesPlaceholder	假设变量已经是消息列表的提示模板。
prompts.chat.SystemMessagePromptTemplate	系统消息提示模板。
prompts.few_shot.FewShotChatMessagePromptTemplate	支持少量示例的聊天提示模板。
prompts.few_shot.FewShotPromptTemplate	包含少量示例的提示模板。
prompts.few_shot_with_templates.FewShotPromptWithTemplates	包含少量示例的提示模板。
prompts.image.ImagePromptTemplate	多模态模型图像提示模板。
prompts.pipeline.PipelinePromptTemplate	组合多个提示模板的提示模板。
prompts.prompt.PromptTemplate	语言模型提示模板。
prompts.string.StringPromptTemplate	公开格式化方法的字符串提示，返回提示。
prompts.structured.StructuredPrompt

函数

prompts.base.aformat_document(doc, prompt)	基于提示模板异步将文档格式化为字符串。
prompts.base.format_document(doc, prompt)	基于提示模板将文档格式化为字符串。
prompts.loading.load_prompt(path[, encoding])	从 LangChainHub 或本地文件系统加载提示的统一方法。
prompts.loading.load_prompt_from_config(config)	从配置字典加载提示。
prompts.string.check_valid_template(...)	检查模板字符串是否有效。
prompts.string.get_template_variables(...)	从模板中获取变量。
prompts.string.jinja2_formatter(template, ...)	使用 jinja2 格式化模板。
prompts.string.mustache_formatter(template, ...)	使用 mustache 格式化模板。
prompts.string.mustache_schema(template)	从 mustache 模板中获取变量。
prompts.string.mustache_template_vars(template)	从 mustache 模板中获取变量。
prompts.string.validate_jinja2(template, ...)	验证输入变量是否符合模板的有效性。

langchain_core.rate_limiters

速率限制器和内存中速率限制器的接口。

类

rate_limiters.BaseRateLimiter(*args, **kwargs)
rate_limiters.InMemoryRateLimiter(*[,...])

langchain_core.retrievers

检索（Retriever）类根据文本。

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

类层次结构

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

主要助手

RetrieverInput, RetrieverOutput, RetrieverLike, RetrieverOutputLike,
Document, Serializable, Callbacks,
CallbackManagerForRetrieverRun, AsyncCallbackManagerForRetrieverRun

类

retrievers.BaseRetriever

文档检索系统的抽象基类。

langchain_core.runnables

LangChain Runnable 和 LangChain 表达式语言（LCEL）。

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

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

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

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

以生成时，中间输出的 流式传输 允许创建更响应式的 UX。

此模块包含 LangChain Runnables 基本原语的模式和实现。

类

runnables.base.Runnable()	可调用、批处理、流式传输、转换和复合的工作单元。
runnables.base.RunnableBinding	包装 Runnable 以附加功能。
runnables.base.RunnableBindingBase	将调用委托给另一个 Runnable 并带有一定 kwargs 的 Runnable。
runnables.base.RunnableEach	将调用委托给另一个 Runnable 的 Runnable，该 Runnable 使用输入序列的每个元素。
runnables.base.RunnableEachBase	将调用委托给另一个 Runnable 的 Runnable，该 Runnable 使用输入序列的每个元素。
runnables.base.RunnableGenerator(transform)	运行生成器函数的 Runnable。
runnables.base.RunnableLambda(func[, afunc, ...])	RunnableLambda 将python可调用转换为 Runnable。
runnables.base.RunnableMap	runnables.base.RunnableParallel 的别名
runnables.base.RunnableParallel	并行运行 Runnable 的映射，并返回其输出映射的 Runnable。
runnables.base.RunnableSequence	Runnable 序列，其中每个的输出是下一个的输入。
runnables.base.RunnableSerializable	可序列化为 JSON 的 Runnable。
runnables.branch.RunnableBranch	根据条件选择要运行的分支的 Runnable。
runnables.config.ContextThreadPoolExecutor([...])	将上下文复制到子线程的 ThreadPoolExecutor。
runnables.config.EmptyDict	空字典类型。
runnables.config.RunnableConfig	Runnable 的配置。
runnables.configurable.DynamicRunnable	可动态配置的可序列化Runnable。
runnables.configurable.RunnableConfigurableAlternatives	可动态配置的Runnable。
runnables.configurable.RunnableConfigurableFields	可动态配置的Runnable。
runnables.configurable.StrEnum(value)	字符串枚举。
runnables.fallbacks.RunnableWithFallbacks	当失败时可以回退到其他Runnable的Runnable。
runnables.graph.Branch(condition, ends)	图中的分支。
runnables.graph.CurveStyle(value)	Mermaid支持的不同曲线样式枚举。
runnables.graph.Edge(source, target[, data, ...])	图中的边。
runnables.graph.Graph(nodes, ...)	节点和边的图。
runnables.graph.LabelsDict	图中节点和边的标签字典。
runnables.graph.MermaidDrawMethod(value)	Mermaid支持的不同绘图方法枚举。
runnables.graph.Node(id, name, data, metadata)	图中的节点。
runnables.graph.NodeStyles([default, first, ...])	不同节点类型的十六进制颜色代码模式。
runnables.graph.Stringifiable(*args, **kwargs)
runnables.graph_ascii.AsciiCanvas(cols, lines)	用于ASCII绘图的类。
runnables.graph_ascii.VertexViewer(name)	定义顶点框边界的类，用于在grandalf构建图时进行考虑。
runnables.graph_png.PngDrawer([fontname, labels])	将状态图绘制到PNG文件的帮助器类。
runnables.history.RunnableWithMessageHistory	管理另一个Runnable的聊天消息历史的Runnable。
runnables.passthrough.RunnableAssign	将键值对分配到Dict[str, Any]输入的Runnable。
runnables.passthrough.RunnablePassthrough	将输入传递不变或带有额外键的Runnable。
runnables.passthrough.RunnablePick	从Dict[str, Any]输入中选取键的Runnable。
runnables.retry.RunnableRetry	如果失败则重试Runnable。
runnables.router.RouterInput	路由输入。
runnables.router.RouterRunnable	根据输入['key']将路由到一组Runnable的可运行对象。
runnables.schema.BaseStreamEvent	流式事件。
runnables.schema.CustomStreamEvent	由用户创建的定制流式事件。
runnables.schema.EventData	与流式事件相关的数据。
runnables.schema.StandardStreamEvent	遵循LangChain约定的事件数据的标准流式事件。
runnables.utils.AddableDict	可以添加到另一个字典中的字典。
runnables.utils.ConfigurableField(id[, ...])	用户可配置的字段。
runnables.utils.ConfigurableFieldMultiOption(id, ...)	用户可配置的字段，具有多个默认值。
runnables.utils.ConfigurableFieldSingleOption(id, ...)	用户可配置的字段，具有默认值。
runnables.utils.ConfigurableFieldSpec(id, ...)	用户可配置的字段。
runnables.utils.FunctionNonLocals()	获取函数访问的非局部变量。
runnables.utils.GetLambdaSource()	获取lambda函数的源代码。
runnables.utils.IsFunctionArgDict()	检查函数的第一个参数是否是字典。
runnables.utils.IsLocalDict(name, keys)	检查名称是否是局部字典。
runnables.utils.NonLocals()	获取访问的非局部变量。
runnables.utils.SupportsAdd(*args, **kwargs)	支持添加的对象的协议。

函数

runnables.base.chain()	装饰一个函数使其成为一个Runnable。
runnables.base.coerce_to_runnable(thing)	将类似Runnable的对象强制转换为Runnable。
runnables.config.acall_func_with_variable_args(...)	异步调用可能需要接受运行管理器和/或配置的函数。
runnables.config.call_func_with_variable_args(...)	调用可能需要接受运行管理器和/或配置的函数。
runnables.config.ensure_config([config])	确保配置是一个包含所有键的字典。
runnables.config.get_async_callback_manager_for_config(config)	为配置获取异步回调管理器。
runnables.config.get_callback_manager_for_config(config)	为配置获取回调管理器。
runnables.config.get_config_list(config, length)	从一个单个配置或配置列表中获取配置列表。
runnables.config.get_executor_for_config(config)	获取一个配置的执行器。
runnables.config.merge_configs(*configs)	将多个配置合并为一个。
runnables.config.patch_config(config, *[, ...])	使用新值修补配置。
runnables.config.run_in_executor(...)	在执行器中运行一个函数。
runnables.configurable.make_options_spec(...)	为ConfigurableFieldSingleOption或ConfigurableFieldMultiOption创建ConfigurableFieldSpec。
runnables.configurable.prefix_config_spec(...)	给ConfigurableFieldSpec的id添加前缀。
runnables.graph.is_uuid(value)	检查一个字符串是否是有效的UUID。
runnables.graph.node_data_json(node, *[, ...])	将节点数据转换为JSON可序列化格式。
runnables.graph.node_data_str(id, data)	将节点数据转换为字符串。
runnables.graph_ascii.draw_ascii(vertices, edges)	构建一个DAG并在ASCII中绘制。
runnables.graph_mermaid.draw_mermaid(nodes, ...)	使用提供的图数据绘制Mermaid图。
runnables.graph_mermaid.draw_mermaid_png(...)	使用提供的语法将Mermaid图绘制为PNG格式。
runnables.passthrough.aidentity(x)	异步恒等函数。
runnables.passthrough.identity(x)	恒等函数。
runnables.utils.aadd(addables)	异步地将一组可添加对象相加。
runnables.utils.accepts_config(callable)	检查一个可调用对象是否接受配置参数。
runnables.utils.accepts_context(callable)	检查一个可调用对象是否接受上下文参数。
runnables.utils.accepts_run_manager(callable)	检查一个可调用对象是否接受run_manager参数。
runnables.utils.add(addables)	将一系列可添加对象求和。
runnables.utils.create_model(__model_name, ...)	使用给定的字段定义创建一个pydantic模型。
runnables.utils.gated_coro(semaphore, coro)	使用信号量运行协程。
runnables.utils.gather_with_concurrency(n, ...)	在协程数量的限制下收集协程。
runnables.utils.get_function_first_arg_dict_keys(func)	如果是一个字典，则获取函数的第一个参数的键。
runnables.utils.get_function_nonlocals(func)	获取被函数访问的非局部变量。
runnables.utils.get_lambda_source(func)	获取lambda函数的源代码。
runnables.utils.get_unique_config_specs(specs)	从一个配置规范序列中获取唯一的配置规范。
runnables.utils.indent_lines_after_first(...)	在第一行后面的所有文本行缩进。
runnables.utils.is_async_callable(func)	检查一个函数是否是异步的。
runnables.utils.is_async_generator(func)	检查一个函数是否是异步生成器。

langchain_core.stores

Store 具实了键值存储和存储助手。

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

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

类

stores.BaseStore()	键值存储的抽象接口。
stores.InMemoryBaseStore()	使用字典实现的BaseStore的内存版本。
stores.InMemoryByteStore()	字节数据的内存存储。
stores.InMemoryStore()	任何类型数据的内存存储。
stores.InvalidKeyException	在键无效时引发；例如，使用错误的字符。

langchain_core.structured_query

结构化查询语言的内部表示。

类

structured_query.Comparator(值)	比较运算符枚举器。
structured_query.Comparison	与值的比较。
structured_query.Expr	所有表达式的基类。
structured_query.FilterDirective	过滤表达式。
structured_query.Operation	其他指令的逻辑运算。
structured_query.Operator(值)	操作枚举器。
structured_query.StructuredQuery	结构化查询。
structured_query.Visitor()	定义使用访问者模式进行 IR 翻译的接口。

langchain_core.sys_info

sys_info 在调试目的下打印有关系统和 langchain 包的信息。

函数

sys_info.print_sys_info(*[, additional_pkgs])

打印有关环境的信息以供调试目的。

langchain_core.tools

工具 是代理用来与世界交互的类。

每个工具都有一个 描述。代理使用描述来选择适合工作的工具。

类层次结构

RunnableSerializable --> BaseTool --> <name>Tool  # Examples: AIPluginTool, BaseGraphQLTool
                                      <name>      # Examples: BraveSearch, HumanInputRun

主要助手

CallbackManagerForToolRun, AsyncCallbackManagerForToolRun

类

tools.BaseTool	LangChain 工具必须实现的接口。
tools.BaseToolkit	表示相关工具集合的基本工具包。
tools.InjectedToolArg()	为一个工具参数注解，该参数不应该由模型生成。
tools.RetrieverInput	检索器的输入。
tools.SchemaAnnotationError	当 'args_schema' 缺失或有错误的类型注解时引发。
tools.StructuredTool	可操作任何数量输入的工具。
tools.Tool	直接接收函数或协程的工具。
tools.ToolException	工具在执行错误发生时抛出的可选异常。

函数

tools.convert_runnable_to_tool(runnable[, ...])	将可运行的转换为 BaseTool。
tools.create_retriever_tool(retriever, name, ...)	创建用于检索文档的工具。
tools.create_schema_from_function(...[, ...])	从函数签名创建pydantic模式。
tools.render_text_description(tools)	以纯文本形式渲染工具名称和描述。
tools.render_text_description_and_args(tools)	以纯文本形式渲染工具名称、描述和参数。
tools.tool(*args[, return_direct, ...])	将函数转换为工具，可带或不带参数使用。

langchain_core.tracers

追踪器是一组追踪运行的类。

类层次结构

BaseCallbackHandler --> BaseTracer --> <name>Tracer  # Examples: LangChainTracer, RootListenersTracer
                                   --> <name>  # Examples: LogStreamCallbackHandler

类

tracers.base.AsyncBaseTracer(*[, _schema_format])	异步追踪器的基础接口。
tracers.base.BaseTracer(*[, _schema_format])	追踪器的基础接口。
tracers.evaluation.EvaluatorCallbackHandler(...)	运行保存时运行运行评估器的追踪器。
tracers.event_stream.RunInfo	关于运行的信息。
tracers.langchain.LangChainTracer([...])	实现了通过POST发送到LangChain端点的SharedTracer。
tracers.log_stream.LogEntry	运行日志中的一次条目。
tracers.log_stream.LogStreamCallbackHandler(*)	将运行日志流式传输到流中的追踪器。
tracers.log_stream.RunLog(*ops, state)	运行日志。
tracers.log_stream.RunLogPatch(*ops)	运行日志的补丁。
tracers.log_stream.RunState	运行状态。
tracers.root_listeners.AsyncRootListenersTracer(*, ...)	在运行开始、结束和错误时调用监听器的异步追踪器。
tracers.root_listeners.RootListenersTracer(*, ...)	在运行开始、结束和错误时调用监听器的追踪器。
tracers.run_collector.RunCollectorCallbackHandler([...])	将所有嵌套运行收集到列表中的追踪器。
tracers.schemas.Run	在追踪器中为V2 API提供的运行模式。
tracers.stdout.ConsoleCallbackHandler(**kwargs)	向控制台打印的追踪器。
tracers.stdout.FunctionCallbackHandler(...)	带有单个str参数的函数追踪器。

函数

tracers.context.collect_runs()	收集上下文中的所有运行跟踪。
tracers.context.register_configure_hook(...)	注册一个配置钩子。
tracers.context.tracing_enabled([session_name])	由于已被 tracing_v2_enabled 替换，将引发错误。
tracers.context.tracing_v2_enabled([...])	指示 LangChain 将所有运行日志记录到 LangSmith。
tracers.evaluation.wait_for_all_evaluators()	等待所有跟踪器完成。
tracers.langchain.get_client()	获取客户端。
tracers.langchain.log_error_once(method, ...)	记录一次错误。
tracers.langchain.wait_for_all_tracers()	等待所有跟踪器完成。
tracers.langchain_v1.LangChainTracerV1(...)	由于已被 LangChainTracer 替换，将引发错误。
tracers.langchain_v1.get_headers(*args, **kwargs)	由于已被 get_headers 替换，将引发错误。
tracers.stdout.elapsed(run)	获取运行的耗时。
tracers.stdout.try_json_stringify(obj, fallback)	尝试将对象串行为 JSON。

已弃用的类

tracers.schemas.BaseRun	自版本 0.1.0 弃用: 请使用 Run 代替。
tracers.schemas.ChainRun	自版本 0.1.0 弃用: 请使用 Run 代替。
tracers.schemas.LLMRun	自版本 0.1.0 弃用: 请使用 Run 代替。
tracers.schemas.ToolRun	自版本 0.1.0 弃用: 请使用 Run 代替。
tracers.schemas.TracerSession	自版本 0.1.0 弃用。
tracers.schemas.TracerSessionBase	自版本 0.1.0 弃用。
tracers.schemas.TracerSessionV1	自版本 0.1.0 弃用。
tracers.schemas.TracerSessionV1Base	自版本 0.1.0 弃用。
tracers.schemas.TracerSessionV1Create	自版本 0.1.0 弃用。

已弃用的函数

tracers.schemas.RunTypeEnum()

自版本 0.1.0 弃用: 请使用字符串 Use string instead. 代替。

langchain_core.utils

实用函数 用于 LangChain。

这些函数不依赖于任何其他 LangChain 模块。

类

utils.aiter.NoLock()	提供适当接口但不提供保护的虚构锁。
utils.aiter.Tee(iterable[, n, lock])	创建 n 个独立异步迭代器，对 iterable 进行操作。
utils.aiter.aclosing(thing)	异步上下文管理器，用于安全地最终化异步清理的资源，例如异步生成器，调用其 aclose() 方法。
utils.aiter.atee	Tee 的别名
utils.formatting.StrictFormatter()	检查额外键的格式化程序。
utils.function_calling.FunctionDescription	用于发送到 LLM 的可调用函数表示形式。
utils.function_calling.ToolDescription	用于 OpenAI API 的可调用函数表示形式。
utils.iter.NoLock()	提供适当接口但不提供保护的虚构锁。
utils.iter.Tee(iterable[, n, lock])	针对 iterable 创建 n 个独立的异步迭代器
utils.iter.safetee	Tee 的别名
utils.mustache.ChevronError	用于 Chevron 错误的自定义异常。

函数

utils.aiter.abatch_iterate(size, iterable)	异步可迭代实用批处理函数。
utils.aiter.py_anext(iterator[, default])	用于测试目的的 pure-Python anext() 实现。
utils.aiter.teePeer(iterator, buffer, ...)	单个 tee() 迭代器。
utils.env.env_var_is_set(env_var)	检查环境变量是否设置。
utils.env.get_from_dict_or_env(data, key, ...)	从字典或环境变量中获取一个值。
utils.env.get_from_env(key, env_key[, default])	从字典或环境变量中获取一个值。
utils.function_calling.convert_to_openai_function(...)	将原始函数/类转换为 OpenAI 函数。
utils.function_calling.convert_to_openai_tool(tool)	将原始函数/类转换为 OpenAI 工具。
utils.function_calling.tool_example_to_messages(...)	将示例转换为可以输入到 LLM 的消息列表。
utils.html.extract_sub_links(raw_html, url, *)	从原始 HTML 字符串中提取所有链接并转换为绝对路径。
utils.html.find_all_links(raw_html, *[, pattern])	从原始 HTML 字符串中提取所有链接。
utils.image.encode_image(image_path)	从图像 URI 获取 base64 字符串。
utils.image.image_to_data_url(image_path)	从图片URI获取数据URL。
utils.input.get_bolded_text(text)	获取加粗文本。
utils.input.get_color_mapping(items[, ...])	获取项目到支持颜色的映射。
utils.input.get_colored_text(text, color)	获取彩色文本。
utils.input.print_text(text[, color, end, file])	使用高亮显示打印文本且不包含结束字符。
utils.interactive_env.is_interactive_env()	确定是否在IPython或Jupyter中运行。
utils.iter.batch_iterate(size, iterable)	实用批量函数。
utils.iter.tee_peer(iterator, buffer, peers, ...)	单个 tee() 迭代器。
utils.json.parse_and_check_json_markdown(...)	从Markdown字符串解析JSON字符串并检查它是否包含预期的密钥。
utils.json.parse_json_markdown(json_string, *)	从Markdown字符串解析JSON字符串。
utils.json.parse_partial_json(s, *[, strict])	解析可能缺少闭花括号的JSON字符串。
utils.json_schema.dereference_refs(schema_obj, *)	尝试在JSON Schema中替换$refs。
utils.mustache.grab_literal(template, l_del)	从模板中解析文字。
utils.mustache.l_sa_check(template, literal, ...)	进行初步检查以确定标签是否可以是独立的。
utils.mustache.parse_tag(template, l_del, r_del)	从模板中解析标签。
utils.mustache.r_sa_check(template, ...)	进行最终检查以确定标签是否可以是独立的。
utils.mustache.render([template, data, ...])	渲染mustache模板。
utils.mustache.tokenize(template[, ...])	对mustache模板进行标记化。
utils.pydantic.get_pydantic_major_version()	获取Pydantic的主版本。
utils.pydantic.is_basemodel_instance(obj)	检查给定的类是否为Pydantic BaseModel实例。
utils.pydantic.is_basemodel_subclass(cls)	检查给定的类是否是Pydantic BaseModel的子类。
utils.pydantic.is_pydantic_v1_subclass(cls)	检查安装的Pydantic版本是否类似1.x。
utils.pydantic.is_pydantic_v2_subclass(cls)	检查安装的Pydantic版本是否类似1.x。
utils.pydantic.pre_init(func)	装饰器，在模型初始化之前运行函数。
utils.strings.comma_list(items)	将列表转换为以逗号分隔的字符串。
utils.strings.stringify_dict(data)	将字典转换为字符串。
utils.strings.stringify_value(val)	将值转换为字符串。
utils.utils.build_extra_kwargs(extra_kwargs, ...)	从值和extra_kwargs构建额外的kwargs。
utils.utils.check_package_version(package[, ...])	检查包的版本。
utils.utils.convert_to_secret_str(value)	如有必要，将字符串转换为SecretStr。
utils.utils.get_pydantic_field_names(...)	获取pydantic类的字段名，包括别名。
utils.utils.guard_import(module_name, *[, ...])	动态导入模块，并在模块未安装时引发异常。
utils.utils.mock_now(dt_value)	用于单元测试中模拟datetime.now()的上下文管理器。
utils.utils.raise_for_status_with_text(response)	使用响应文本来引发错误。
utils.utils.xor_args(*arg_groups)	验证指定的关键字参数是否互斥。

已弃用函数

utils.function_calling.convert_pydantic_to_openai_function(...)	自版本 0.1.16 起已弃用: 请使用 langchain_core.utils.function_calling.convert_to_openai_function() 代替。
utils.function_calling.convert_pydantic_to_openai_tool(...)	自版本 0.1.16 起已弃用: 请使用 langchain_core.utils.function_calling.convert_to_openai_tool() 代替。
utils.function_calling.convert_python_function_to_openai_function(...)	自版本 0.1.16 起已弃用: 请使用 langchain_core.utils.function_calling.convert_to_openai_function() 代替。
utils.function_calling.format_tool_to_openai_function(tool)	自版本 0.1.16 起已弃用: 请使用 langchain_core.utils.function_calling.convert_to_openai_function() 代替。
utils.function_calling.format_tool_to_openai_tool(tool)	自版本 0.1.16 起已弃用: 请使用 langchain_core.utils.function_calling.convert_to_openai_tool() 代替。
utils.loading.try_load_from_hub(*args, **kwargs)	自版本 0.1.30 起已弃用: 使用 hwchase17/langchain-hub 存库中的提示已弃用。请使用 <https://smith.langchain.com/hub> 代替。

langchain_core.vectorstores

类

vectorstores.base.VectorStore()	向量化商店的接口。
vectorstores.base.VectorStoreRetriever	VectorStore 的基检索类。
vectorstores.in_memory.InMemoryVectorStore(...)	使用字典实现的 VectorStore 的内存版本。