LangChain 接入国内大模型 API：Claude、GPT、DeepSeek 完整配置教程（2026）

LangChain 是构建 AI 应用最流行的 Python 框架，但国内开发者直连 OpenAI、Anthropic 等海外 API 端点时经常遇到延迟高、不稳定甚至完全不通的问题。本文的方案：通过 OpenAI 兼容协议的 API 聚合平台作为接入层，LangChain 代码只改两个参数，即可在国内低延迟调用 Claude Sonnet 4.6、GPT-4.1、DeepSeek V3 等模型。包含完整 Python 代码、LCEL 链式调用示例、多模型切换方案和常见报错处理。

问题背景：LangChain 国内调用的典型痛点

LangChain 的 LCEL 链式调用、RAG、Agent、Tool Calling 等功能已经很成熟，但对国内开发者来说有一道绕不开的坎：

直连海外 API 的成功率太低了。

典型报错现场：

# 最常见的三种错误
requests.exceptions.ConnectTimeout: HTTPSConnectionPool(host='api.anthropic.com', port=443): Max retries exceeded
openai.APIConnectionError: Connection error.
httpx.ConnectError: [SSL: CERTIFICATE_VERIFY_FAILED]

原因很直接：OpenAI（api.openai.com）、Anthropic（api.anthropic.com）、Google（generativelanguage.googleapis.com）的 API 服务器都部署在海外，国内网络直连经常遭遇：

• 连接超时：TCP 握手或 SSL 握手失败，LangChain 默认 60 秒超时直接报错
• Streaming 断流：流式输出中途断开，partial response 处理复杂
• 高延迟：首字节延迟（TTFT）动辄 5-15 秒，Streaming 场景下用户体验极差
• 配额问题：即使网络通了，OpenAI/Anthropic 的注册和支付门槛对国内开发者不友好

怎么解？

核心方案：统一 API 聚合层接入

最简单也最稳定的方案是引入一层 API 聚合平台作为中间层：

你的 LangChain 代码
    ↓
API 聚合平台（国内节点，低延迟）
    ↓ （对应转发）
Claude API / OpenAI API / Gemini API / DeepSeek API

这种架构的核心优势：

以 Ofox 为例，兼容 OpenAI 协议，LangChain 侧改动量极小。

快速上手：五分钟跑通第一个 Claude 对话

1. 安装依赖

# langchain-openai >= 0.2.0 | 文档: https://python.langchain.com/docs/integrations/chat/openai
pip install -U langchain langchain-openai langchain-anthropic

2. 通过 OpenAI 兼容协议调用 Claude

Ofox 等聚合平台统一暴露 OpenAI 兼容接口（/v1/chat/completions），因此可以直接用 ChatOpenAI，只需修改 base_url 和 api_key：

# SDK: langchain-openai v0.3+ / docs: https://python.langchain.com/docs/integrations/chat/openai
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

# 只改这两个参数，其余用法完全不变
llm = ChatOpenAI(
    model="anthropic/claude-sonnet-4.6",  # 完整模型列表见 ofox.ai/zh/docs/develop
    base_url="https://api.ofox.ai/v1",
    api_key="your-ofox-api-key",          # Ofox 控制台获取
    temperature=0.7,
    max_tokens=2048,
)

# 普通调用
response = llm.invoke([HumanMessage(content="用一句话解释什么是 LangChain")])
print(response.content)
# 输出: LangChain 是一个用于构建大语言模型驱动应用的开源框架...

# 流式输出
for chunk in llm.stream([HumanMessage(content="写一首关于代码的俳句")]):
    print(chunk.content, end="", flush=True)

3. 用环境变量管理密钥（推荐）

import os
from langchain_openai import ChatOpenAI

# 推荐在 .env 或环境变量中配置，不要硬编码密钥
llm = ChatOpenAI(
    model=os.getenv("LLM_MODEL", "anthropic/claude-sonnet-4.6"),
    base_url=os.getenv("OPENAI_API_BASE", "https://api.ofox.ai/v1"),
    api_key=os.getenv("OFOX_API_KEY"),
)

对应的 .env 文件：

OFOX_API_KEY=your-ofox-api-key-here
LLM_MODEL=anthropic/claude-sonnet-4.6
OPENAI_API_BASE=https://api.ofox.ai/v1

💡 为什么用环境变量？ 方便在不同环境（开发/生产）切换模型和端点，同时避免密钥泄露到代码仓库。

多模型配置：Claude、GPT、DeepSeek 全覆盖

通过 API 聚合平台，同一套代码可以切换所有主流模型：

# SDK: langchain-openai v0.3+ / docs: https://python.langchain.com/docs/integrations/chat/openai
from langchain_openai import ChatOpenAI

BASE_URL = "https://api.ofox.ai/v1"
API_KEY = "your-ofox-api-key"

# Claude Sonnet 4.6 — 综合能力强，适合复杂推理和长文档处理
claude_sonnet = ChatOpenAI(
    model="anthropic/claude-sonnet-4.6",
    base_url=BASE_URL,
    api_key=API_KEY,
)

# Claude Opus 4.6 — 最强推理，适合需要深度分析的任务
claude_opus = ChatOpenAI(
    model="anthropic/claude-opus-4.6",
    base_url=BASE_URL,
    api_key=API_KEY,
)

# GPT-4.1 — OpenAI 旗舰，代码和工具调用体验好
gpt4 = ChatOpenAI(
    model="openai/gpt-4.1",
    base_url=BASE_URL,
    api_key=API_KEY,
)

# DeepSeek V3 — 国产之光，价格极低，中文理解强
deepseek = ChatOpenAI(
    model="deepseek/deepseek-chat",
    base_url=BASE_URL,
    api_key=API_KEY,
)

# Haiku 4.5 — 超快超便宜，适合分类、提取等轻量任务
claude_haiku = ChatOpenAI(
    model="anthropic/claude-haiku-4.5",
    base_url=BASE_URL,
    api_key=API_KEY,
)

完整模型 ID 列表以 ofox.ai/zh/docs/develop 为准。

2026 主流模型能力与价格对比

注：以上价格为参考，实际以各平台控制台显示为准。

LCEL 链式调用实战

LangChain 0.3+ 推荐使用 LCEL（| 管道语法）构建调用链：

基础：Prompt → Model → Parser

# SDK: langchain>=0.3.0 / docs: https://python.langchain.com/docs/concepts/lcel
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(
    model="anthropic/claude-sonnet-4.6",
    base_url="https://api.ofox.ai/v1",
    api_key="your-ofox-api-key",
)

# 构建 Prompt 模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个专业的 {role}，用简洁的中文回答问题。"),
    ("human", "{question}"),
])

# LCEL 管道：Prompt → LLM → 字符串输出
chain = prompt | llm | StrOutputParser()

# 调用
result = chain.invoke({
    "role": "Python 开发专家",
    "question": "解释 asyncio 和多线程的区别，什么时候用哪个？"
})
print(result)

进阶：结构化输出

# SDK: langchain>=0.3.0, pydantic>=2.0
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from pydantic import BaseModel, Field
from typing import List

llm = ChatOpenAI(
    model="anthropic/claude-sonnet-4.6",
    base_url="https://api.ofox.ai/v1",
    api_key="your-ofox-api-key",
)

# 定义输出结构
class CodeReview(BaseModel):
    issues: List[str] = Field(description="发现的代码问题列表")
    suggestions: List[str] = Field(description="改进建议")
    severity: str = Field(description="严重程度: low/medium/high")

# 绑定结构化输出
structured_llm = llm.with_structured_output(CodeReview)

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是资深代码审查专家，请对以下代码进行审查。"),
    ("human", "代码：\n```python\n{code}\n```"),
])

chain = prompt | structured_llm

result = chain.invoke({
    "code": """
def get_user(id):
    sql = f"SELECT * FROM users WHERE id = {id}"
    return db.execute(sql)
"""
})

print(f"严重程度: {result.severity}")
print(f"问题: {result.issues}")
print(f"建议: {result.suggestions}")
# 输出:
# 严重程度: high
# 问题: ['存在 SQL 注入风险', '缺少参数验证', '没有错误处理']
# 建议: ['使用参数化查询', '添加 id 类型检查', '添加 try-except 捕获数据库异常']

异步并发调用

# SDK: langchain>=0.3.0
import asyncio
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(
    model="anthropic/claude-haiku-4.5",  # 轻量任务用 Haiku，更快更便宜
    base_url="https://api.ofox.ai/v1",
    api_key="your-ofox-api-key",
)

prompt = ChatPromptTemplate.from_messages([
    ("human", "用 5 个词描述以下产品的核心卖点：{product}"),
])
chain = prompt | llm | StrOutputParser()

async def batch_analyze(products: list[str]):
    """并发分析多个产品"""
    tasks = [chain.ainvoke({"product": p}) for p in products]
    results = await asyncio.gather(*tasks)
    return dict(zip(products, results))

# 并发跑 5 个任务，比串行快 4-5 倍
products = ["Claude API", "GPT-4", "DeepSeek", "Gemini", "LangChain"]
results = asyncio.run(batch_analyze(products))
for product, keywords in results.items():
    print(f"{product}: {keywords}")

进阶：多模型动态切换

实际业务中，不同任务适合不同模型。LangChain 支持在运行时动态切换：

# SDK: langchain>=0.3.0 / docs: https://python.langchain.com/docs/how_to/configure
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import ConfigurableField

BASE_CONFIG = {"base_url": "https://api.ofox.ai/v1", "api_key": "your-ofox-api-key"}

# 默认使用 Sonnet，允许在运行时切换
llm = ChatOpenAI(model="anthropic/claude-sonnet-4.6", **BASE_CONFIG).configurable_alternatives(
    ConfigurableField(id="model"),
    default_key="sonnet",
    opus=ChatOpenAI(model="anthropic/claude-opus-4.6", **BASE_CONFIG),
    haiku=ChatOpenAI(model="anthropic/claude-haiku-4.5", **BASE_CONFIG),
    gpt4=ChatOpenAI(model="openai/gpt-4.1", **BASE_CONFIG),
    deepseek=ChatOpenAI(model="deepseek/deepseek-chat", **BASE_CONFIG),
)

prompt = ChatPromptTemplate.from_messages([("human", "{question}")])
chain = prompt | llm | StrOutputParser()

# 默认 Sonnet
response = chain.invoke({"question": "分析这段代码的时间复杂度..."})

# 切换到 Opus 处理复杂任务
response = chain.with_config(configurable={"model": "opus"}).invoke({
    "question": "设计一个分布式任务调度系统的架构方案..."
})

# 切换到 Haiku 处理简单分类任务（便宜快速）
response = chain.with_config(configurable={"model": "haiku"}).invoke({
    "question": "判断这条评论的情感倾向：positive/negative/neutral"
})

实战案例：构建 RAG 文档问答系统

这是 LangChain 最常见的应用场景之一：

# SDK: langchain>=0.3.0, langchain-community>=0.3.0, faiss-cpu
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_community.vectorstores import FAISS
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

BASE_URL = "https://api.ofox.ai/v1"
API_KEY = "your-ofox-api-key"

# 1. 向量化文档（用 Embedding 模型）
embeddings = OpenAIEmbeddings(
    model="openai/text-embedding-3-small",
    base_url=BASE_URL,
    api_key=API_KEY,
)

# 2. 加载和切割文档
loader = TextLoader("your_document.txt", encoding="utf-8")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(docs)

# 3. 建立向量库
vectorstore = FAISS.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# 4. 构建 QA 链
llm = ChatOpenAI(
    model="anthropic/claude-sonnet-4.6",
    base_url=BASE_URL,
    api_key=API_KEY,
)

prompt = ChatPromptTemplate.from_messages([
    ("system", "根据以下上下文回答问题，如果无法从上下文中找到答案，请明确说明。\n\n上下文：{context}"),
    ("human", "{question}"),
])

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# 提问
answer = rag_chain.invoke("产品的退款政策是什么？")
print(answer)

常见报错与排查

遇到问题时，按以下顺序排查：

1. AuthenticationError: 401

# 检查 API Key 是否正确传入
print(llm.openai_api_key)  # 不要在日志中打印，仅用于本地调试

# 常见原因：环境变量 OPENAI_API_KEY 被优先读取覆盖了自定义 key
# 解决：显式传入 api_key 参数
llm = ChatOpenAI(model="...", base_url="...", api_key="your-key")

2. openai.NotFoundError: model not found

# 检查模型 ID 格式是否正确
# 通常是 provider/model-name 格式
# 以 ofox.ai/zh/docs/develop 上的模型列表为准

3. Connection timeout / SSL Error

import httpx
from langchain_openai import ChatOpenAI

# 增加超时时间（默认 60s，Streaming 场景可适当调大）
llm = ChatOpenAI(
    model="anthropic/claude-sonnet-4.6",
    base_url="https://api.ofox.ai/v1",
    api_key="your-key",
    http_client=httpx.Client(timeout=120.0),
)

4. RateLimitError: 429

from langchain_openai import ChatOpenAI
from tenacity import retry, stop_after_attempt, wait_exponential

llm = ChatOpenAI(
    model="anthropic/claude-sonnet-4.6",
    base_url="https://api.ofox.ai/v1",
    api_key="your-key",
    max_retries=3,  # LangChain 内置重试
)

常见问题（FAQ）

Q：LangChain 国内调用 Claude/GPT API 需要特殊网络配置吗？

不需要。通过 API 聚合平台接入，仅需修改 base_url，国内网络直连，首字节延迟 300-800ms。

Q：从官方迁移到 API 聚合平台要改多少代码？

ChatOpenAI 只需修改 base_url 和 api_key 两个参数，其余代码完全不用改。

Q：LangChain 的 Agent 和 Tool Calling 也能用吗？

可以。Tool Calling、Function Calling、JSON Mode 的支持都是协议层面的，只要 base_url 后端支持这些特性就能正常工作。

Q：API 聚合平台的模型 ID 格式是什么？

provider/model-name 格式，例如 anthropic/claude-sonnet-4.6、openai/gpt-4.1。完整列表以 ofox.ai/zh/docs/develop 为准。

Q：批量任务怎么省钱？

使用 Batch API 异步提交，通常有 50% 的 Token 折扣，适合离线分类、批量摘要等场景。

总结

国内用 LangChain 接入大模型 API 的核心思路：

1. 用 API 聚合平台作为接入层，解决网络和支付问题，代码只改 base_url 和 api_key 两个参数
2. 用 ChatOpenAI + 自定义 base_url 覆盖绝大多数场景，一份代码支持所有主流模型
3. 按任务选模型：轻量任务用 Haiku/DeepSeek，复杂推理用 Sonnet/Opus，代码任务用 GPT-4.1
4. 用 LCEL + configurable_alternatives 实现运行时多模型动态切换