【LangChain】langchain.globals 模块：管理全局配置和状态（如缓存策略、日志级别、并发限制等）

langchain.globals 模块是 LangChain 库中的一个模块，用于管理 LangChain 的全局配置和状态，如缓存、日志级别等设置。

本文基于 LangChain 0.3.x，详细介绍 langchain.globals 模块的结构、核心函数及其功能，并提供一个独立示例，展示如何使用 langchain.globals 设置全局缓存以优化人工智能主题的问答工作流，示例突出模块在性能优化中的作用。（ LangChain API 文档)

---

langchain.globals 模块概览

langchain.globals 模块是 LangChain 库的核心部分，提供了管理全局配置和状态的工具。它允许开发者设置和访问 LangChain 的全局变量，如缓存策略、日志级别、并发限制等，从而优化性能、调试和资源管理。该模块主要通过函数接口操作，适用于需要统一配置的工作流。

核心功能：

• 管理全局缓存，减少重复 LLM 调用。
• 设置日志级别，控制调试信息输出。
• 配置全局并发限制，优化资源使用。
• 提供线程安全的全局状态管理。

适用场景：

• 缓存 LLM 或工具调用结果，降低 API 成本和延迟。
• 调整日志输出，调试复杂工作流。
• 在多线程或分布式环境中统一配置 LangChain 行为。
• 优化大规模应用中的性能和资源分配。

模块位置：

• 源码路径：langchain/globals/
• 文档参考：LangChain Globals API

---

模块中的主要函数

以下是 langchain.globals 模块中的核心函数（基于 LangChain 0.3.x），包括功能和典型用法。

1. set_llm_cache / get_llm_cache

• 功能：
  • set_llm_cache(cache: Optional[BaseCache]) -> None: 设置全局 LLM 缓存。
  • get_llm_cache() -> Optional[BaseCache]: 获取当前全局 LLM 缓存。
• 参数：
  • cache（Optional[BaseCache]）：缓存实例，如 InMemoryCache、SQLiteCache。
• 使用场景：缓存 LLM 响应，减少重复调用。
• 示例：

  from langchain.globals import set_llm_cache, get_llm_cache
  from langchain.cache import InMemoryCache
  set_llm_cache(InMemoryCache())
  cache = get_llm_cache()
  

2. set_verbose / get_verbose

• 功能：
  • set_verbose(verbose: bool) -> None: 设置全局 verbose 模式，控制日志详细程度。
  • get_verbose() -> bool: 获取当前 verbose 状态。
• 使用场景：启用详细日志，调试链或代理。
• 示例：

  from langchain.globals import set_verbose, get_verbose
  set_verbose(True)
  print(get_verbose())  # 输出: True
  

3. set_debug / get_debug

• 功能：
  • set_debug(debug: bool) -> None: 设置全局 debug 模式，输出更详细的调试信息。
  • get_debug() -> bool: 获取当前 debug 状态。
• 使用场景：深入调试 LangChain 内部逻辑。
• 示例：

  from langchain.globals import set_debug, get_debug
  set_debug(True)
  print(get_debug())  # 输出: True
  

4. set_max_concurrency / get_max_concurrency

• 功能：
  • set_max_concurrency(max_concurrency: Optional[int]) -> None: 设置全局最大并发限制。
  • get_max_concurrency() -> Optional[int]: 获取当前最大并发设置。
• 使用场景：控制多线程或异步调用的并发量。
• 示例：

  from langchain.globals import set_max_concurrency, get_max_concurrency
  set_max_concurrency(10)
  print(get_max_concurrency())  # 输出: 10
  

其他全局变量

• langchain.llm_cache: 全局 LLM 缓存对象，可直接访问/修改（不推荐，建议用 set_llm_cache）。
• langchain.verbose: 全局 verbose 标志。
• langchain.debug: 全局 debug 标志。

关键特性：

• 函数操作线程安全，适合多线程环境。
• 缓存支持多种后端（如内存、SQLite、Redis）。
• 日志和并发设置影响所有 LangChain 组件。

---

使用方式

以下是使用 langchain.globals 模块的通用步骤。

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. 配置全局设置

from langchain.globals import set_llm_cache, set_verbose
from langchain.cache import InMemoryCache
set_llm_cache(InMemoryCache())
set_verbose(True)

4. 构建链

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
llm = ChatOpenAI(model="gpt-3.5-turbo")
prompt = ChatPromptTemplate.from_template("回答: {input}")
chain = prompt | llm

5. 调用链

response = chain.invoke({"input": "什么是 AI？"})
print(response.content)

---

使用 langchain.globals 的示例

以下是一个独立示例，展示如何使用 langchain.globals 设置全局缓存以优化人工智能主题的问答工作流。通过 set_llm_cache 配置 InMemoryCache，减少重复的 LLM 调用，提高性能。

准备环境：

• 获取 OpenAI API 密钥：OpenAI Platform。
• 设置环境变量：

  export OPENAI_API_KEY="your-api-key"
  

• 安装依赖：

  pip install --upgrade langchain langchain-openai
  

代码：

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.globals import set_llm_cache, get_llm_cache
from langchain.cache import InMemoryCache
import time

# 设置全局缓存
set_llm_cache(InMemoryCache())
print(f"全局缓存已设置为: {get_llm_cache().__class__.__name__}")

# 初始化 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
)

# 测试全局缓存效果
print("测试 langchain.globals 和全局缓存：")
try:
    question = "人工智能是什么？"
    
    # 第一次调用（无缓存）
    start_time = time.time()
    result = chain.invoke(question)
    first_time = time.time() - start_time
    print(f"\n输入问题: {question}")
    print(f"第一次调用回答: {result}")
    print(f"第一次调用耗时: {first_time:.2f} 秒")
    
    # 第二次调用（使用缓存）
    start_time = time.time()
    result = chain.invoke(question)
    second_time = time.time() - start_time
    print(f"\n第二次调用回答: {result}")
    print(f"第二次调用耗时: {second_time:.2f} 秒")
except Exception as e:
    print(f"错误: {e}")

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

全局缓存已设置为: InMemoryCache

测试 langchain.globals 和全局缓存：

输入问题: 人工智能是什么？
第一次调用回答: 人工智能（AI）是计算机科学的一个分支，旨在模拟人类智能，如学习、推理和问题解决。
第一次调用耗时: 1.23 秒

第二次调用回答: 人工智能（AI）是计算机科学的一个分支，旨在模拟人类智能，如学习、推理和问题解决。
第二次调用耗时: 0.01 秒

代码说明

1. 全局缓存设置：
   • 使用 set_llm_cache(InMemoryCache()) 配置内存缓存。
   • 通过 get_llm_cache() 验证设置。
2. LLM 初始化：
   • 使用 ChatOpenAI 调用 gpt-3.5-turbo，设置 temperature=0.7。
3. 工作流：
   • 使用 RunnableLambda 清理输入。
   • 组合 prompt、llm 和 parser 形成 LCEL 链。
4. 测试：
   • 测试相同问题两次，比较第一次（无缓存）和第二次（使用缓存）的耗时。
   • 显示问题、回答和耗时，展示缓存效果。
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. 缓存选择：
   • InMemoryCache: 适合临时测试，内存占用高：

     set_llm_cache(InMemoryCache())
     

   • SQLiteCache: 适合持久化存储：

     from langchain.cache import SQLiteCache
     set_llm_cache(SQLiteCache(database_path="cache.db"))
     

   • 禁用缓存：

     set_llm_cache(None)
     

3. 日志配置：
   • 启用详细日志：

     set_verbose(True)
     

   • 深入调试：

     set_debug(True)
     

4. 性能优化：
   • 异步调用：使用 ainvoke：

     result = await chain.ainvoke(question)
     

   • 并发限制：设置 max_concurrency：

     set_max_concurrency(5)
     

   • 缓存清理：手动清空 InMemoryCache：

     cache = get_llm_cache()
     cache.clear()
     

5. 错误调试：
   • 缓存失效：
     • 检查缓存设置：

       print(get_llm_cache())
       

     • 验证缓存命中：

       print(chain.invoke(question) == chain.invoke(question))
       

   • API 错误：
     • 检查密钥：

       print(os.environ.get("OPENAI_API_KEY"))
       

     • 增加超时：

       llm = ChatOpenAI(timeout=30)
       

   • 日志输出：
     • 启用调试：

       set_debug(True)
       chain.invoke(question)
       

---

常见问题

Q1：如何使用 SQLite 缓存？
A：配置 SQLiteCache：

from langchain.cache import SQLiteCache
set_llm_cache(SQLiteCache(database_path="cache.db"))
chain.invoke("什么是 AI？")  # 结果缓存到 cache.db

Q2：如何结合代理？
A：设置缓存后使用代理：

from langchain.agents import initialize_agent, AgentType
set_llm_cache(InMemoryCache())
agent = initialize_agent(tools=[tool], llm=llm, agent=AgentType.OPENAI_FUNCTIONS)
result = agent.run("查询任务")

Q3：如何禁用日志？
A：设置 verbose 和 debug 为 False：

set_verbose(False)
set_debug(False)

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

from langchain_ollama import ChatOllama
set_llm_cache(InMemoryCache())
llm = ChatOllama(model="llama3")
chain = prompt | llm | parser
result = chain.invoke("什么是 AI？")

---

总结

langchain.globals 模块是 LangChain 中管理全局配置的核心，包含以下关键函数：

• set_llm_cache / get_llm_cache: 配置和获取 LLM 缓存。
• set_verbose / get_verbose: 控制日志详细程度。
• set_debug / get_debug: 启用深入调试。
• set_max_concurrency / get_max_concurrency: 限制并发量。