【LangChain】ainvoke() 方法的 config（RunnableConfig） 参数可配置的设置项

已于 2025-05-14 17:59:58 修改
阅读量961 收藏 18
点赞数 8
CC 4.0 BY-SA版权
分类专栏： LangChain 文章标签： langchain ainvoke invoke config RunnableConfig
于 2025-05-14 12:45:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013172930/article/details/147951662

本文基于 LangChain 0.3.x，详细介绍 LangChain 中 模型调用时使用的ainvoke() 方法的 config 参数（类型为 RunnableConfig），列出可配置的设置项、其作用和使用场景，并提供一个独立示例，展示如何通过 config 设置超时和回调来优化人工智能主题的问答工作流，示例突出 config 在异步调用中的灵活性。（ LangChain RunnableConfig 文档)

ainvoke() 方法的 config 参数概览

ainvoke() 是 LangChain 中 Runnable 类的异步调用方法，用于异步执行链、模型或工具的逻辑。它接受一个可选的 config 参数，类型为 RunnableConfig，用于配置运行时行为。RunnableConfig 是一个字典或 TypedDict，允许开发者设置超时、并发、回调、元数据等，以控制执行流程和调试。

方法签名：

async def ainvoke(
    self,
    input: Input,
    config: Optional[RunnableConfig] = None,
    **kwargs: Any
) -> Output
  • 参数：
    • input（Input）：输入数据，类型取决于具体 Runnable。
    • config（Optional[RunnableConfig]）：运行时配置，默认为 None。
    • **kwargs：其他参数，传递给底层实现。
  • 返回值：Output，异步返回的输出，类型取决于 Runnable。

RunnableConfig 的作用：

  • 提供运行时控制，如超时、最大并发、回调等。
  • 支持调试，通过元数据和标签跟踪执行。
  • 允许动态调整行为，适用于复杂工作流。

适用场景：

  • 设置超时，防止长时间运行的任务阻塞。
  • 添加回调，记录执行日志或监控性能。
  • 配置并发，优化多任务处理。
  • 传递元数据，跟踪任务来源或上下文。

RunnableConfig 可设置项

以下是 RunnableConfig 支持的主要设置项，基于 LangChain 0.3.x 的源码（langchain_core/runnables/config.py）和文档。RunnableConfig 是一个 TypedDict，定义如下：

class RunnableConfig(TypedDict, total=False):
    tags: List[str]
    metadata: Dict[str, Any]
    callbacks: Optional[Callbacks]
    run_name: Optional[str]
    max_concurrency: Optional[int]
    recursion_limit: Optional[int]
    configurable: Optional[Dict[str, Any]]
1. tags
  • 类型：List[str]
  • 作用：为运行添加标签，用于过滤或分组。
  • 使用场景：
    • 区分不同类型的任务（如 "query"、"moderation"）。
    • 在回调中根据标签执行特定逻辑。
  • 示例：
    config = {"tags": ["ai_query", "test"]}
2. metadata
  • 类型：Dict[str, Any]
  • 作用：附加元数据，记录任务上下文或标识。
  • 使用场景：
    • 跟踪用户 ID、会话 ID 或任务来源。
    • 在日志或监控中记录额外信息。
  • 示例：
    config = {"metadata": {"user_id": "123", "session_id": "abc"}}
3. callbacks
  • 类型：Optional[Callbacks]（List[BaseCallbackHandler] 或 BaseCallbackManager）
  • 作用：定义回调函数，监控运行事件（如开始、结束、错误）。
  • 支持的回调：
    • langchain_core.callbacks.StdOutCallbackHandler：打印标准输出。
    • langchain_core.callbacks.FileCallbackHandler：记录到文件。
    • 自定义回调：继承 BaseCallbackHandler。
  • 使用场景：
    • 记录执行时间或日志。
    • 集成监控工具（如 LangSmith）。
  • 示例：
    from langchain_core.callbacks import StdOutCallbackHandler
config = {"callbacks": [StdOutCallbackHandler()]}
4. run_name
  • 类型：Optional[str]
  • 作用：指定运行的名称，便于跟踪。
  • 使用场景：
    • 在复杂工作流中标识特定任务。
    • 在回调或日志中显示任务名称。
  • 示例：
    config = {"run_name": "AI_Query"}
5. max_concurrency
  • 类型：Optional[int]
  • 作用：限制并发调用数量，防止资源过载。
  • 使用场景：
    • 在高负载场景下控制 API 调用。
    • 优化多线程或异步任务。
  • 示例：
    config = {"max_concurrency": 5}
6. recursion_limit
  • 类型：Optional[int]
  • 作用：限制递归深度，防止无限循环（如在代理中）。
  • 使用场景：
    • 控制复杂链或代理的迭代次数。
    • 避免栈溢出。
  • 示例：
    config = {"recursion_limit": 10}
7. configurable
  • 类型：Optional[Dict[str, Any]]
  • 作用：存储动态配置，传递给特定组件。
  • 使用场景：
    • 传递自定义参数（如模型温度、超时）。
    • 支持运行时调整组件行为。
  • 示例：
    config = {"configurable": {"timeout": 30, "temperature": 0.9}}
其他运行时设置

虽然 RunnableConfig 本身不直接定义以下设置，但 config 可以间接影响底层组件的行为（如通过 configurable 或回调）：

  • Timeout：通过 configurable 设置 HTTP 请求超时。
    config = {"configurable": {"timeout": 30}}
  • API Key：通过 configurable 动态传递密钥（特定于某些链）。
    config = {"configurable": {"api_key": "your-api-key"}}

注意：

  • 不同 Runnable 子类可能支持额外的 config 设置，需查阅具体文档。
  • config 的优先级：运行时 config > 组件初始化配置 > 全局配置（如 langchain.globals）。

使用方式

以下是使用 ainvoke() 方法和 config 参数的通用步骤。

1. 安装依赖
pip install --upgrade langchain langchain-openai
2. 设置 OpenAI API 密钥
export OPENAI_API_KEY="your-api-key"

或在代码中：

import os
os.environ["OPENAI_API_KEY"] = "your-api-key"
3. 配置链和 config
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.callbacks import StdOutCallbackHandler
llm = ChatOpenAI(model="gpt-3.5-turbo")
prompt = ChatPromptTemplate.from_template("回答: {input}")
chain = prompt | llm
config = {
    "tags": ["ai_query"],
    "metadata": {"user_id": "123"},
    "callbacks": [StdOutCallbackHandler()],
    "run_name": "AI_Query",
    "configurable": {"timeout": 30}
}
4. 异步调用
import asyncio
result = asyncio.run(chain.ainvoke({"input": "什么是 AI？"}, config=config))
print(result.content)

使用 ainvoke() 和 config 的示例

以下是一个独立示例，展示如何使用 ainvoke() 方法的 config 参数配置超时和回调，优化人工智能主题的问答工作流。config 设置包括 callbacks（记录日志）、configurable（超时）和 metadata（用户追踪）。

准备环境：

  • 获取 OpenAI API 密钥：OpenAI Platform。
  • 设置环境变量：
    export OPENAI_API_KEY="your-api-key"
  • 安装依赖：
    pip install --upgrade langchain langchain-openai

代码：

import asyncio
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableLambda
from langchain_core.output_parsers import StrOutputParser
from langchain_core.callbacks import StdOutCallbackHandler

# 初始化 ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)

# 定义提示模板
prompt = ChatPromptTemplate.from_template(
    "你是一个人工智能专家，回答问题：{input}\n回答："
)

# 定义输出解析器
parser = StrOutputParser()

# 创建工作流
chain = (
    RunnableLambda(lambda x: x.strip()) | prompt | llm | parser
)

# 定义 config
config = {
    "tags": ["ai_query", "test"],
    "metadata": {"user_id": "123", "session_id": "abc"},
    "callbacks": [StdOutCallbackHandler()],
    "run_name": "AI_Query",
    "configurable": {"timeout": 30}
}

# 测试 ainvoke 和 config 设置
async def main():
    print("测试 ainvoke 和 config 设置：")
    try:
        question = "人工智能是什么？"
        result = await chain.ainvoke(question, config=config)
        print(f"\n输入问题: {question}")
        print(f"回答: {result}")
    except Exception as e:
        print(f"错误: {e}")

# 运行异步主函数
if __name__ == "__main__":
    asyncio.run(main())

输出示例（实际输出取决于模型和网络）：

测试 ainvoke 和 config 设置：
[StdOutCallbackHandler] Started run AI_Query
[StdOutCallbackHandler] Processing prompt...
[StdOutCallbackHandler] Completed run AI_Query

输入问题: 人工智能是什么？
回答: 人工智能（AI）是计算机科学的一个分支，旨在模拟人类智能，如学习、推理和问题解决。
代码说明
  1. LLM 初始化：
    • 使用 ChatOpenAI 调用 gpt-3.5-turbo，设置 temperature=0.7。
  2. 工作流：
    • 使用 RunnableLambda 清理输入。
    • 组合 prompt、llm 和 parser 形成 LCEL 链。
  3. Config 设置：
    • tags: 标记为 "ai_query" 和 "test"。
    • metadata: 记录 user_id 和 session_id。
    • callbacks: 使用 StdOutCallbackHandler 打印日志。
    • run_name: 设置为 "AI_Query"。
    • configurable: 设置超时为 30 秒。
  4. 测试：
    • 使用 ainvoke 异步调用，传入 config。
    • 显示问题和回答，展示回调日志。
  5. 错误处理：
    • 使用 try-except 捕获 API 或链错误。

运行要求：

  • 有效的 OpenAI API 密钥：
    export OPENAI_API_KEY="your-api-key"
  • 安装依赖：
    pip install --upgrade langchain langchain-openai
  • 网络连接：访问 https://api.openai.com.

注意事项

  1. API 密钥：
    • 确保 OPENAI_API_KEY 已设置：
      echo $OPENAI_API_KEY
    • 或在代码中设置：
      llm = ChatOpenAI(api_key="your-api-key")
  2. Config 优先级：
    • 运行时 config 覆盖组件初始化配置：
      config = {"configurable": {"timeout": 60}}
result = await chain.ainvoke(input, config=config)
    • 全局配置（如 langchain.globals）优先级最低。
  3. 回调配置：
    • 自定义回调需继承 BaseCallbackHandler：
      from langchain_core.callbacks import BaseCallbackHandler
class CustomCallback(BaseCallbackHandler):
    def on_chain_start(self, serialized, inputs, **kwargs):
        print("链开始")
config = {"callbacks": [CustomCallback()]}
    • 集成 LangSmith 追踪：
      from langchain.callbacks import LangSmithCallbackHandler
config = {"callbacks": [LangSmithCallbackHandler()]}
  4. 性能优化：
    • 超时设置：通过 configurable：
      config = {"configurable": {"timeout": 15}}
    • 并发控制：结合 max_concurrency：
      config = {"max_concurrency": 3}
    • 异步批量：使用 abatch：
      results = await chain.abatch([input1, input2], config=config)
  5. 错误调试：
    • 超时错误：
      • 检查 configurable：
        print(config["configurable"])
      • 增加超时：
        config = {"configurable": {"timeout": 60}}
    • 回调失败：
      • 验证回调：
        print(config["callbacks"])
      • 测试单独回调：
        handler = StdOutCallbackHandler()
handler.on_chain_start({}, {"input": "测试"})
    • 输入错误：
      • 检查输入格式：
        print(chain.input_schema)

常见问题

Q1：如何设置超时？
A：通过 configurable：

config = {"configurable": {"timeout": 30}}
result = await chain.ainvoke(input, config=config)

Q2：如何记录执行时间？
A：使用自定义回调：

from time import time
from langchain_core.callbacks import BaseCallbackHandler
class TimingCallback(BaseCallbackHandler):
    def on_chain_start(self, serialized, inputs, **kwargs):
        self.start = time()
    def on_chain_end(self, outputs, **kwargs):
        print(f"执行耗时: {time() - self.start:.2f} 秒")
config = {"callbacks": [TimingCallback()]}

Q3：如何与代理结合？
A：传递 config 给代理：

from langchain.agents import initialize_agent, AgentType
agent = initialize_agent(tools=[tool], llm=llm, agent=AgentType.OPENAI_FUNCTIONS)
result = await agent.ainvoke({"input": "任务"}, config=config)

Q4：如何支持开源模型？
A：使用 ChatOllama：

from langchain_ollama import ChatOllama
llm = ChatOllama(model="llama3")
chain = prompt | llm | parser
result = await chain.ainvoke(question, config=config)

总结

ainvoke() 方法的 config 参数（RunnableConfig）支持以下设置：

  • tags: 任务标签，分组或过滤。
  • metadata: 元数据，记录上下文。
  • callbacks: 回调函数，监控事件。
  • run_name: 运行名称，便于跟踪。
  • max_concurrency: 并发限制，优化资源。
  • recursion_limit: 递归深度，防止循环。
  • configurable: 动态参数，如超时。
【LangChain编程：从入门到实践】invoke
AI天才研究院
06-14 767
1.背景介绍 随着区块链技术的发展，编程语言也在不断的创新和演变。LangChain是一种新型的区块链编程语言，它以其独特的设计理念和强大的功能，正在引领区块链编程的新潮流。本文将详细介绍LangChain编程语言，包括其背景、核心概念、原理、应用等内容，希望能对想要入门LangChain的读者有所帮助。 2
探索如何在LangChain中访问RunnableConfig：优化智能工具调用的高级技巧
m0_57781768的博客
09-04 196
在深入探讨之前，我们需要了解什么是。是LangChain中用于配置和管理可运行组件（Runnables）行为的核心对象。通过这个配置对象，开发者可以为特定的任务执行设置参数、控制子调用行为、以及跟踪和记录事件。这使得开发者能够在复杂的任务处理中获得更高的灵活性和控制力。例如，当一个工具调用聊天模型并需要使用特定配置进行对话生成时，可以帮助开发者精确地传递这些配置。无论是在开发阶段进行调试，还是在生产环境中进行性能优化，都能为开发者提供强大的支持。为了展示如何在LangChain中访问和使用。
LangChain实战技巧之六：一起玩转config（上篇）——ConfigurableField
Song榆钱儿的博客
06-22 854
这个是一种应用比较广泛的，消息历史相关的Runnable，可定义config传参变量，关于它的详细内容以后再给大家介绍...当然，可以直接用__fields__，这样就把整个dict（每个Field和含义内容都打印出来）基本上都是AgentExecutor简单的参数，“偷懒”就不挨个介绍，请各位看官自行实验： ）通常一些资料没告诉你的是，可以有哪些可配置的Field 这里我给大家介绍...授之以渔。细心的小伙伴会发现，上述的方式与这种方式 一毛一样。看看chain有哪些可config的field。
使用 ChatOpenAI 模型快速入门指南
最新发布
Wurenyu957的博客
06-18 362
OpenAI 的聊天模型广泛用于多种场景，包括但不限于语言翻译、信息提取、问答系统、客服机器人等。通过工具调用功能，开发者可以更方便地集成第三方服务和数据源，以实现更复杂的交互逻辑。如果遇到问题欢迎在评论区交流。
LangChain AgentExecutor invoke跟踪记录（一）
weixin_42818780的博客
06-06 1879
追踪与调用LLM相关的整条链路，用于理解langchainAgent调用LLM时整个输入输出逻辑，方便后续针对不同LLM做改造适配。
langchain学习（四）
小白的数据博客
02-24 1289
方式1通过RunnableParallel。2、component的输入输出类型表。1、langchain采用了一个叫。Interface官方文档。同时提供以上接口的异步方式。方式2通过batch接口。：流式（实时）返回结果。：通过列表进行多输入。
langchain基础（三）
2302_79795489的博客
01-28 492
prompt | model | output_parser 把提示值传给模型，又把模型输出传给解析器。链让我们组合出复杂的流程，通过langchain表达式语言，组件之间的上下游关系也能表现得很清晰明了。提示模板、聊天模型和输出解析器都实现了langchain的runnable接口，（注意：链里聊天模型可以换成语言模型，提示模板和输出解析器也不是必须有的）| 表示把前面组件的输出作为后面组件的输入，也就是“管道操作”。把对多个组件的一系列调用，称为“链”（Chain）。都具有invoke方法（
LangChain表达式LCEL(三）
weixin_43787408的博客
03-18 1652
为了尽可能简化创建自定义链的过程，我们实现了一个“Runnable”协议，这是一个标准接口，可以轻松定义自定义链并以标准方式调用它们。streaminvokebatchastreamainvokeabatch和所有可运行对象都公开输入和输出的：创建一个简单的PromptTemplate + ChatModel链。
深入解析如何在 LangChain 中调度自定义回调事件：异步与同步环境的全面实践指南
m0_57781768的博客
09-06 418
在构建复杂的 AI 应用程序时，开发者常常需要在不同任务执行的各个步骤之间调度事件，并根据这些事件做出实时响应。通过事件驱动的编程模式，我们可以跟踪任务的进展、记录日志，甚至向用户展示任务状态。在LangChain这样的框架中，回调函数（Callback）已经成为任务链管理中的关键部分。特别是，LangChain 允许开发者创建自定义回调事件，并在异步与同步环境中灵活调度这些事件。本文将详细介绍如何在LangChain中调度自定义回调事件，涵盖异步和同步两种环境。
解锁LangChain中的事件流：从工具中实时捕获动态输出
ppoojjj的博客
11-27 408
假设我们有一个自定义工具，使用链式调用的方式来处理文本输入。我们将定义一个简单的模型链，以示范如何捕获事件流。通过本文，您应已了解如何在LangChain中使用事件流以及如何处理可能出现的兼容性问题。LangChain官方文档构建使用工具的链和代理。
深入探索如何在LangChain中从工具中流式传递事件：智能任务处理的进阶技巧
m0_57781768的博客
09-04 156
事件流是一种实时监控技术，允许开发者在任务执行过程中捕获和处理发生的事件。在LangChain中，事件流可以用于跟踪工具调用、聊天模型的生成过程、检索器的查询等。这些事件可以帮助开发者了解任务的执行状态、识别潜在问题，并在必要时进行调整。实时监控和日志记录：捕捉任务执行过程中的关键事件并记录日志，以便后续分析和审计。调试和优化：通过实时查看事件流，可以更快地定位问题，优化任务执行流程。动态调整：根据捕捉到的事件实时调整任务执行参数，优化系统性能。
Langchain中chain的不同调用方法
跨过一座座山
06-19 1418
chain.invoke(context)只可传入一个参数，若传入多个参数，利用chain.invoke({‘context’: context, ‘num’:num})返回dict形式，通过添加, return_only_outputs=True，可以只返回text键。chain.run(context)这种形式只用于传入一个参数，若传入多个参数，调用形式如下。chain(context)只可传入一个参数，若传入多个参数，调用形式如下。单个或者多个输出参数，调用方式都如下，其他方式出错。
langchain入门三:memory-记忆组件,让大语言模型拥有记忆
Langchain的博客
05-21 1427
langchain入门三:memory-记忆组件,让大语言模型拥有记忆
LangChain入门教学：（2）LangChain工作流编排
jo101010的博客
02-25 1675
LangChain的接口及事件机制
LangChain系列使用指南：LangChain快速入门
数智笔记
03-16 5676
我们仅涉及了提示、模型和输出解析器的基础知识 - 要深入了解这里提到的所有内容，请参阅文档的此部分。我们只是简单介绍了检索的基础知识 - 想要深入了解这里提到的所有内容，请参阅文档的这一部分。我们只是简单介绍了代理的基础知识 - 想要深入了解这里提到的所有内容，请参阅文档的这一部分。我们将展示如何使用通过 API 提供的模型，如 OpenAI，以及本地开源模型，使用像 Ollama 这样的集成。这个链将接收一个问题，查找相关文档，然后将这些文档连同原始问题传递给一个 LLM，并要求它回答原始问题。
一文带你了解 LangChain 核心概念
2401_85373396的博客
10-16 1080
考虑如何在您的RAG系统中构建自我纠正机制。RAG系统可能会因为低质量的检索（例如，用户问题超出了索引的范围）和/或生成中的幻觉而出现问题。一个简单的检索-生成管道无法检测或自我纠正这些类型的错误。在代码生成的背景下引入了“流工程”概念：通过单元测试迭代地构建代码问题的答案，以检查和自我纠正错误。多个研究将这一概念应用于RAG系统，如Self-RAG和Corrective-RAG。在这两种情况下，都会在RAG答案生成流程中进行文档相关性、幻觉和/或答案质量的检查。
LangChain 表达式语言快速参考指南
srysduguho的博客
12-30 368
LangChain 提供了灵活的表达式语言工具，支持我们轻松地构建高效、可重用的函数调用链。这篇快速参考手册应该可以帮助你更好地理解 LCEL 的核心功能。如果大家在使用中遇到问题，欢迎在评论区交流哦~今天的技术分享就到这里，希望对大家有帮助。开发过程中遇到问题也可以在评论区交流~—END—
通过类比,十分钟掌握LangChain的快速入门
潘永强_PandaPan的博客
12-01 1244
前文提到了熟悉LangChain的架构,熟悉后, 便可以动手写DEMO了,如何写DEMO呢?本文十分钟带你上手DEMO
langchain学习（九）
小白的数据博客
03-02 888
基于输入的动态路由逻辑，通过上一步的输出选择下一步操作，允许创建非确定性链。路由保证路由间的结构和连贯。有以下两种方法执行路由。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

彬彬侠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值