langchain_core 0.2.1

langchain_core.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, AgentStep

Classes

agents.AgentAction	一个ActionAgent执行的动作的完整描述。
agents.AgentActionMessageLog	覆盖init以支持通过位置进行实例化，以实现向后兼容。
agents.AgentFinish	ActionAgent的最终返回值。
agents.AgentStep	运行AgentAction的结果。

langchain_core.beta

一些尚未准备好投入生产的 beta 功能。

Classes

beta.runnables.context.Context()	用于可运行对象的上下文。
beta.runnables.context.ContextGet	[Beta] 获取上下文数值。
beta.runnables.context.ContextSet	[Beta] 设置上下文值。
beta.runnables.context.PrefixContext([prefix])	带有前缀的可运行上下文。

Functions

beta.runnables.context.aconfig_with_context(...)	异步地使用上下文获取器和设置器来修补可运行的配置。
beta.runnables.context.config_with_context(...)	使用上下文获取器和设置器对可运行配置进行修补。

langchain_core.caches

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

Cache 有两个用处：

• 如果你经常多次请求相同的完成，它可以通过减少你向LLM提供商发出的API调用来为你节省金钱。

• 通过减少你向LLM提供商发出的API调用，它可以加快你的应用程序速度。

Cache 直接与Memory竞争。请参阅文档了解优缺点。

类层次结构:

BaseCache --> <name>Cache  # 例如：InMemoryCache, RedisCache, GPTCache

Classes

caches.BaseCache()	这个接口为LLMs和Chat模型提供了一个缓存层。
caches.InMemoryCache()	在内存中存储东西的缓存。

langchain_core.callbacks

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

类层次结构:

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

Classes

callbacks.base.AsyncCallbackHandler()	处理来自LangChain的异步回调的回调处理程序。
callbacks.base.BaseCallbackHandler()	处理来自LangChain的回调的基本回调处理程序。
callbacks.base.BaseCallbackManager(handlers)	处理来自LangChain的回调的基本回调管理器。
callbacks.base.CallbackManagerMixin()	回调管理器的Mixin。
callbacks.base.ChainManagerMixin()	用于链式回调的Mixin。
callbacks.base.LLMManagerMixin()	LLM回调的Mixin。
callbacks.base.RetrieverManagerMixin()	用于检索器回调的Mixin。
callbacks.base.RunManagerMixin()	运行管理器的Mixin。
callbacks.base.ToolManagerMixin()	工具回调的Mixin。
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(handlers)	处理来自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()	流处理的回调处理程序。仅适用于支持流处理的LLMs。

Functions

callbacks.manager.ahandle_event(handlers, ...)	通用的AsyncCallbackManager事件处理程序。
callbacks.manager.atrace_as_chain_group(...)	获取一个用于链式组中的上下文管理器的异步回调管理器。 用于将不同的异步调用组合在一起，即使它们并不在一个单一的链中组成。
callbacks.manager.handle_event(handlers, ...)	通用事件处理程序，用于CallbackManager。
callbacks.manager.shielded(func)	确保可等待方法始终不会被取消。
callbacks.manager.trace_as_chain_group(...)	获取链组中的回调管理器，作为上下文管理器使用。 用于将不同调用组合在一起，即使它们不是在单个链中组合的。

langchain_core.chat_history

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

类层次结构:

BaseChatMessageHistory --> <name>ChatMessageHistory  # 例如: FileChatMessageHistory, PostgresChatMessageHistory

主要辅助功能:

AIMessage, HumanMessage, BaseMessage

Classes

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

langchain_core.chat_loaders

Classes

chat_loaders.BaseChatLoader()

用于聊天加载器的基类。

langchain_core.chat_sessions

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

Classes

chat_sessions.ChatSession

聊天会话代表一个单独的对话、频道或其他消息组。

langchain_core.document_loaders

Classes

document_loaders.base.BaseBlobParser()	用于blob解析器的抽象接口。
document_loaders.base.BaseLoader()	文档加载器的接口。
document_loaders.blob_loaders.Blob	Blob代表通过引用或值表示的原始数据。
document_loaders.blob_loaders.BlobLoader()	用于blob加载器实现的抽象接口。

langchain_core.documents

Document 模块是处理文档及其转换的一组类。

Classes

documents.base.Document	用于存储文本片段和相关元数据的类。
documents.compressor.BaseDocumentCompressor	用于文档压缩的基类。
documents.transformers.BaseDocumentTransformer()	抽象基类，用于文档转换系统。

langchain_core.embeddings

Classes

embeddings.embeddings.Embeddings()	用于嵌入模型的接口。
embeddings.fake.DeterministicFakeEmbedding	虚拟嵌入模型，始终为相同文本返回相同的嵌入向量。
embeddings.fake.FakeEmbeddings	虚假的嵌入模型。

langchain_core.example_selectors

示例选择器 实现了选择示例以包含在提示中的逻辑。 这使我们能够选择与输入最相关的示例。

Classes

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

Functions

example_selectors.semantic_similarity.sorted_values(values)

返回一个按键排序的字典中值的列表。

langchain_core.exceptions

为LangChain自定义 异常 。

Classes

exceptions.LangChainException	通用的LangChain异常。
exceptions.OutputParserException(error[, ...])	输出解析器应该引发的异常，表示解析错误。
exceptions.TracerException	用于跟踪器模块中异常的基类。

langchain_core.globals

全局数值和适用于LangChain的所有配置。

Functions

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.indexing

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

此软件包包含帮助处理将数据索引到向量存储中的逻辑，同时避免重复内容和覆盖未更改的内容。

Classes

indexing.api.IndexingResult	返回对索引操作结果的详细分析。
indexing.base.RecordManager(namespace)	抽象基类，表示记录管理器的接口。

Functions

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

langchain_core.language_models

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

LangChain有两个主要类用于处理语言模型： - LLM 类提供对大型语言模型（ LLM ）API和服务的访问。 - Chat Models 是语言模型的一种变体。

类层次结构:

BaseLanguageModel --> BaseLLM --> LLM --> <name>  # 例如: AI21, HuggingFaceHub, OpenAI
                  --> BaseChatModel --> <name>    # 例如: ChatOpenAI, ChatGooglePalm

主要辅助功能:

LLMResult, PromptValue,
CallbackManagerForLLMRun, AsyncCallbackManagerForLLMRun,
CallbackManager, AsyncCallbackManager,
AIMessage, BaseMessage, HumanMessage

Classes

language_models.base.BaseLanguageModel	用于与语言模型进行交互的抽象基类。
language_models.chat_models.BaseChatModel	用于聊天模型的基类。
language_models.chat_models.LangSmithParams
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的简单接口。

Functions

language_models.chat_models.agenerate_from_stream(stream)	异步从流中生成数据。
language_models.chat_models.generate_from_stream(stream)	从流中生成。
language_models.llms.aget_prompts(params, ...)	获取已缓存的提示。 Async version.
language_models.llms.aupdate_cache(cache, ...)	更新缓存并获取LLM输出。 Async version
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 模块有助于序列化和反序列化。

Classes

load.load.Reviver([secrets_map, ...])	JSON对象的恢复器。
load.serializable.BaseSerialized	用于序列化对象的基类。
load.serializable.Serializable	可序列化的基类。
load.serializable.SerializedConstructor	序列化构造函数。
load.serializable.SerializedNotImplemented	未实现序列化。
load.serializable.SerializedSecret	序列化的秘密。

Functions

load.dump.default(obj)	返回一个Serializable对象或SerializedNotImplemented对象的默认值。
load.dump.dumpd(obj)	返回一个对象的json字典表示。
load.dump.dumps(obj, *[, pretty])	返回一个对象的JSON字符串表示形式。
load.load.load(obj, *[, secrets_map, ...])	[Beta] 从JSON对象中恢复LangChain类。如果您已经有一个解析过的JSON对象，例如从`json.load`或`orjson.loads`中获取。
load.load.loads(text, *[, secrets_map, ...])	[Beta] 从JSON字符串中恢复一个LangChain类。 相当于`load(json.loads(text))`。
load.serializable.to_json_not_implemented(obj)	将一个“未实现”的对象序列化。
load.serializable.try_neq_default(value, ...)	尝试确定一个值是否与默认值不同。

langchain_core.memory

Memory 维护链状态，包含来自过去运行的上下文。

Memory的类层次结构：

BaseMemory --> <name>Memory --> <name>Memory  # 例子：BaseChatMemory -> MotorheadMemory

Classes

memory.BaseMemory

抽象基类，用于Chains中的记忆。

langchain_core.messages

消息 是用于提示和聊天对话的对象。

类层次结构:

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

主要辅助功能:

ChatPromptTemplate

Classes

messages.ai.AIMessage	来自人工智能的消息。
messages.ai.AIMessageChunk	来自人工智能的消息块。
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.system.SystemMessage	用于激活AI行为的消息，通常作为输入消息序列中的第一个消息传递。
messages.system.SystemMessageChunk	系统消息块。
messages.tool.InvalidToolCall	允许LLM产生的错误。
messages.tool.ToolCall	代表调用工具的请求。
messages.tool.ToolCallChunk	工具调用的一部分（例如，作为流的一部分）。
messages.tool.ToolMessage	将执行工具的结果传递回模型的消息。
messages.tool.ToolMessageChunk	工具消息块。

Functions

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.utils.convert_to_messages(messages)	将一系列消息转换为消息列表。
messages.utils.get_buffer_string(messages[, ...])	将一系列消息转换为字符串并将它们连接成一个字符串。
messages.utils.message_chunk_to_message(chunk)	将消息块转换为消息。
messages.utils.messages_from_dict(messages)	将字典格式的消息序列转换为消息对象。

langchain_core.output_parsers

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

类层次结构:

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

主要辅助类:

Serializable, Generation, PromptValue

Classes

output_parsers.base.BaseGenerationOutputParser	用于解析LLM调用输出的基类。
output_parsers.base.BaseLLMOutputParser()	模型输出解析的抽象基类。
output_parsers.base.BaseOutputParser	用于解析LLM调用输出的基类。
output_parsers.json.JsonOutputParser	将LLM调用的输出解析为JSON对象。
output_parsers.json.SimpleJsonOutputParser	alias of 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格式解析输出。

Functions

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

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

Classes

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

langchain_core.prompt_values

为语言模型提示设置提示值。

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

Classes

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

Classes

prompts.base.BasePromptTemplate	所有提示模板的基类，返回一个提示。
prompts.chat.AIMessagePromptTemplate	AI消息提示模板。这是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	[Beta] 为语言模型设计的结构化提示模板。

Functions

prompts.base.aformat_document(doc, prompt)	将文档根据提示模板格式化为字符串。
prompts.base.format_document(doc, prompt)	将文档根据提示模板格式化为字符串。
prompts.loading.load_prompt(path)	从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, ...)	使用大括号进行模板格式化。
prompts.string.mustache_schema(template)	从一个mustache模板中获取变量。
prompts.string.mustache_template_vars(template)	从一个mustache模板中获取变量。
prompts.string.validate_jinja2(template, ...)	验证模板的输入变量是否有效。 如果发现缺少或多余的变量，则发出警告。

langchain_core.retrievers

Retriever 类根据文本 query 返回文档。

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

类层次结构:

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

主要辅助功能:

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

Classes

retrievers.BaseRetriever

抽象基类，用于文档检索系统。

langchain_core.runnables

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

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

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

对 async 的支持使得托管基于 LCEL 的程序的服务器能够更好地应对更高的并发负载。

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

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

该模块包含 LangChain Runnable 原语的模式和实现。

Classes

runnables.base.Runnable()	一个可以被调用、批处理、流式处理、转换和组合的工作单元。
runnables.base.RunnableBinding	使用额外功能包装一个Runnable。
runnables.base.RunnableBindingBase	将调用委托给具有一组kwargs的另一个Runnable的可运行对象。
runnables.base.RunnableEach	一个将调用委托给另一个Runnable的可运行对象，每个输入序列的元素。
runnables.base.RunnableEachBase	将调用委托给输入序列的每个元素的另一个Runnable的可运行对象。
runnables.base.RunnableGenerator(transform)	可运行的生成器函数。
runnables.base.RunnableLambda(func[, afunc, ...])	RunnableLambda将python可调用对象转换为Runnable。
runnables.base.RunnableMap	alias of RunnableParallel
runnables.base.RunnableParallel	在并行运行映射的Runnable，返回它们的输出映射。
runnables.base.RunnableSequence	运行任务序列，其中每个任务的输出是下一个任务的输入。
runnables.base.RunnableSerializable	可序列化为JSON的可运行对象。
runnables.branch.RunnableBranch	根据条件选择要运行的分支的可运行程序。
runnables.config.ContextThreadPoolExecutor([...])	将上下文复制到子线程的ThreadPoolExecutor。
runnables.config.EmptyDict	空字典类型。
runnables.config.RunnableConfig	一个可运行的配置。
runnables.configurable.DynamicRunnable	可动态配置的可序列化的Runnable。
runnables.configurable.RunnableConfigurableAlternatives	可动态配置的可运行对象。
runnables.configurable.RunnableConfigurableFields	可动态配置的可运行对象。
runnables.configurable.StrEnum(value[, ...])	字符串枚举。
runnables.fallbacks.RunnableWithFallbacks	可在失败时回退到其他Runnable的可运行对象。
runnables.graph.Branch(condition, ends)	图中的分支。
runnables.graph.CurveStyle(value[, names, ...])	Mermaid支持的不同曲线样式的枚举
runnables.graph.Edge(source, target[, data, ...])	图中的边。
runnables.graph.Graph(nodes, ...)	节点和边的图。
runnables.graph.LabelsDict	图中节点和边的标签字典。
runnables.graph.MermaidDrawMethod(value[, ...])	Mermaid支持的不同绘图方法的枚举
runnables.graph.Node(id, data)	图中的节点。
runnables.graph.NodeColors([start, end, other])	不同节点类型的十六进制颜色代码架构
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]输入的可运行对象。
runnables.passthrough.RunnablePassthrough	将输入保持不变或添加额外键的可运行程序。
runnables.passthrough.RunnablePick	RunnablePick类表示一个可运行对象，它可以从字典输入中选择性地提取键。允许您指定一个或多个要从输入字典中提取的键。它返回一个仅包含所选键的新字典。
runnables.retry.RunnableRetry	重新运行一个Runnable如果它失败。
runnables.router.RouterInput	路由器输入。
runnables.router.RouterRunnable	根据Input['key']路由到一组Runnable的Runnable。 返回所选Runnable的输出。
runnables.schema.EventData	与流事件相关的数据。
runnables.schema.StreamEvent	流式事件。
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)	支持加法的对象的协议。

Functions

runnables.base.chain()	装饰一个函数，使其成为可运行的。 将可运行对象的名称设置为函数的名称。 由函数调用的任何可运行对象都将被跟踪为依赖项。
runnables.base.coerce_to_runnable(thing)	将可运行对象强制转换为Runnable。
runnables.config.acall_func_with_variable_args(...)	调用可能可选接受 run_manager 和/或 config 的函数。
runnables.config.call_func_with_variable_args(...)	调用可能可选接受 run_manager 和/或 config 的函数。
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创建一个可配置的字段规范。
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(node)	将节点的数据转换为字符串。
runnables.graph_ascii.draw_ascii(vertices, edges)	构建一个有向无环图（DAG）并用ASCII图形表示出来。
runnables.graph_mermaid.draw_mermaid(nodes, ...)	使用提供的图数据绘制美人鱼图
runnables.graph_mermaid.draw_mermaid_png(...)	使用提供的语法绘制一个美人鱼图形，并将其保存为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)	使用信号量运行一个协程。 参数： 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 实现了键-值存储和存储辅助功能。

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

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

Classes

stores.BaseStore()	用于键值存储的抽象接口。
stores.InMemoryBaseStore()	使用字典实现的BaseStore的内存实现。
stores.InvalidKeyException	当键无效时引发；例如，使用了不正确的字符。

langchain_core.structured_query

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

Classes

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

langchain_core.sys_info

sys_info 打印有关系统和langchain软件包的信息，用于调试目的。

Functions

sys_info.print_sys_info(*[, additional_pkgs])

打印环境信息，用于调试目的。

langchain_core.tools

工具 是Agent用来与世界互动的类。

每个工具都有一个 描述 。Agent使用描述来选择合适的工具来完成工作。

类层次结构:

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

主要辅助工具:

CallbackManagerForToolRun, AsyncCallbackManagerForToolRun

Classes

tools.BaseTool	LangChain工具必须实现的接口。
tools.BaseToolkit	基础工具包，代表了一组相关工具。
tools.RetrieverInput	检索器的输入。
tools.SchemaAnnotationError	当 'args_schema' 丢失或具有不正确的类型注释时引发。
tools.StructuredTool	可以操作任意数量输入的工具。
tools.Tool	直接接收函数或协程的工具。
tools.ToolException	当执行错误发生时工具抛出的可选异常。

Functions

tools.create_retriever_tool(retriever, name, ...)	创建一个工具来检索文档。
tools.create_schema_from_function(...)	从函数的签名创建一个pydantic模式。 参数： model_name：分配给生成的pydandic模式的名称 func：要从中生成模式的函数 返回： 一个具有与函数相同参数的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  # 例如: LangChainTracer, RootListenersTracer
                                   --> <name>  # 例如: LogStreamCallbackHandler

Classes

tracers.base.BaseTracer(*[, _schema_format])	用于跟踪器的基本接口。
tracers.evaluation.EvaluatorCallbackHandler(...)	运行评估器的跟踪器，每当运行被持久化时运行评估器。
tracers.event_stream.RunInfo	关于一次运行的信息。
tracers.langchain.LangChainTracer([...])	实现了向LangChain端点发送POST请求的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.RootListenersTracer(*, ...)	在运行开始、结束和出错时调用监听器的跟踪器。
tracers.run_collector.RunCollectorCallbackHandler([...])	收集所有嵌套运行的跟踪器列表。
tracers.schemas.BaseRun	[Deprecated] 运行的基类。
tracers.schemas.ChainRun	[Deprecated] ChainRun的类。
tracers.schemas.LLMRun	[Deprecated] LLMRun的类。
tracers.schemas.Run	在跟踪器中为V2 API运行模式。
tracers.schemas.ToolRun	[Deprecated] 工具运行的类。
tracers.schemas.TracerSession	[Deprecated] TracerSessionV1模式用于V2 API。
tracers.schemas.TracerSessionBase	[Deprecated] 用于TracerSession的基类。
tracers.schemas.TracerSessionV1	[Deprecated] TracerSessionV1模式。
tracers.schemas.TracerSessionV1Base	[Deprecated] TracerSessionV1的基类。
tracers.schemas.TracerSessionV1Create	[Deprecated] 为TracerSessionV1创建类。
tracers.stdout.ConsoleCallbackHandler(**kwargs)	在控制台打印的跟踪器。
tracers.stdout.FunctionCallbackHandler(...)	调用带有单个str参数的函数的跟踪器。

Functions

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.schemas.RunTypeEnum()	[Deprecated] 运行类型枚举。
tracers.stdout.elapsed(run)	获取运行的经过时间。
tracers.stdout.try_json_stringify(obj, fallback)	尝试将对象转换为JSON字符串。 参数： obj：要转换为字符串的对象。 fallback：如果无法将对象转换为字符串，则返回的备用字符串。

langchain_core.utils

LangChain 的实用函数。

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

Classes

utils.aiter.NoLock()	虚拟锁，提供正确的接口但不提供保护
utils.aiter.Tee(iterable[, n, lock])	创建``n``个单独的异步迭代器，遍历``iterable``。
utils.aiter.atee	alias of Tee
utils.formatting.StrictFormatter()	检查额外键的格式化程序。
utils.function_calling.FunctionDescription	将可调用函数的表示发送到LLM。
utils.function_calling.ToolDescription	代表一个可调用函数给OpenAI API。
utils.iter.NoLock()	虚拟锁，提供正确的接口但没有保护
utils.iter.Tee(iterable[, n, lock])	创建``n``个单独的异步迭代器，遍历``iterable``
utils.iter.safetee	alias of Tee
utils.mustache.ChevronError	用于Chevron错误的自定义异常。

Functions

utils.aiter.py_anext(iterator[, default])	用于测试目的的纯Python实现anext()。
utils.aiter.tee_peer(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_pydantic_to_openai_function(...)	[Deprecated] 将Pydantic模型转换为OpenAI API的函数描述。
utils.function_calling.convert_pydantic_to_openai_tool(...)	[Deprecated] 将Pydantic模型转换为OpenAI API的函数描述。
utils.function_calling.convert_python_function_to_openai_function(...)	[Deprecated] 将一个Python函数转换为与OpenAI函数调用API兼容的字典。
utils.function_calling.convert_to_openai_function(...)	将原始函数/类转换为OpenAI函数。
utils.function_calling.convert_to_openai_tool(tool)	将原始函数/类转换为OpenAI工具。
utils.function_calling.format_tool_to_openai_function(tool)	[Deprecated] 将工具格式化为OpenAI函数API。
utils.function_calling.format_tool_to_openai_tool(tool)	[Deprecated] 将工具格式化为OpenAI函数API。
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)
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.loading.try_load_from_hub(*args, **kwargs)	[Deprecated]
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.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)	验证指定的关键字参数是否彼此互斥。

langchain_core.vectorstores

向量存储 存储嵌入数据并执行向量搜索。

存储和检索非结构化数据的最常见方式之一是对其进行嵌入，并存储生成的嵌入向量，然后查询存储库并检索与嵌入查询“最相似”的数据。

类层次结构:

VectorStore --> <name>  # 例如: Annoy, FAISS, Milvus

BaseRetriever --> VectorStoreRetriever --> <name>Retriever  # 例如: VespaRetriever

主要辅助功能:

Embeddings, Document

Classes

vectorstores.VectorStore()	向量存储的接口。
vectorstores.VectorStoreRetriever	用于VectorStore的基本Retriever类。