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

摘要

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

目录

• 问题背景：LangChain 国内调用的典型痛点
• 核心方案：统一 API 聚合层接入
• 快速上手：五分钟跑通第一个 Claude 对话
• 多模型配置：Claude、GPT、DeepSeek 全覆盖
• LCEL 链式调用实战
• 进阶：多模型动态切换
• 实战案例：构建 RAG 文档问答系统
• 常见报错与排查
• 常见问题（FAQ）
• 总结与行动建议
• 验证记录
• 参考资料

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

2026 年，LangChain 生态已经相当成熟。LCEL（LangChain Expression Language）让 Prompt → Model → OutputParser 的链式调用变得优雅，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

这种架构的核心优势：

特性	直连海外 API	API 聚合平台
国内网络稳定性	❌ 经常超时断连	✅ 阿里云/火山云节点加速
首字节延迟（TTFT）	5-15 秒	300-800 ms
支付方式	需要海外信用卡	支付宝/微信
多模型切换	每家单独注册账号	一个 API Key
LangChain 兼容性	✅ 原生支持	✅ 100% 兼容，仅改 base_url

以 Ofox 为例，它同时兼容 OpenAI、Anthropic、Gemini 三套原生 SDK 协议，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 / 验证: 2026-03
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

# 只改这两个参数，其余用法完全不变
llm = ChatOpenAI(
    model="anthropic/claude-sonnet-4-6",  # 完整模型列表见 docs.ofox.ai/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 / 验证: 2026-03
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 列表以 docs.ofox.ai/develop 为准，平台会持续更新最新模型。

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

模型	擅长场景	输入 Token 单价	输出 Token 单价	国内延迟
Claude Sonnet 4.6	综合推理、长文档	$3 / 1M tokens	$15 / 1M tokens	300-600ms
Claude Opus 4.6	最复杂推理任务	$5 / 1M tokens	$25 / 1M tokens	400-800ms
GPT-4.1	代码、工具调用	$2 / 1M tokens	$8 / 1M tokens	300-600ms
DeepSeek V3	中文、低成本	极低	极低	<200ms
Claude Haiku 4.5	轻量分类提取	$1 / 1M tokens	$5 / 1M tokens	200-400ms

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

LCEL 链式调用实战

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

基础：Prompt → Model → Parser

# SDK: langchain>=0.3.0 / docs: https://python.langchain.com/docs/concepts/lcel / 验证: 2026-03
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 / 验证: 2026-03
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 / 验证: 2026-03
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 / 验证: 2026-03
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 / 验证: 2026-03
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="text-embedding-3-small",  # 或 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 格式
# 以 docs.ofox.ai/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：从 Anthropic/OpenAI 官方迁移到 API 聚合平台要改多少代码？

极少。ChatOpenAI 只需修改 base_url 和 api_key 两个参数。其余所有 LangChain 链、Agent、RAG 代码完全不用改，接口协议 100% 兼容。

Q：API 聚合平台的 Token 计费和官方一样吗？

计费方式相同（按实际消耗的输入/输出 token 数量），价格通常与官方持平或略有差异，具体以平台控制台为准。

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

完全可以。ChatOpenAI 对 Tool Calling、Function Calling、JSON Mode 的支持都是协议层面的，只要 base_url 后端支持这些特性，LangChain Agent 就能正常工作。Ofox 支持 Claude 和 GPT 的全部 Tool Calling 特性。

Q：批量任务怎么省钱？

对于不需要实时响应的批量任务（离线分类、批量摘要等），可以使用 Batch API，异步提交后 24 小时内返回结果，通常有 50% 的 Token 折扣。

总结与行动建议

国内用 LangChain 接入大模型 API，核心思路很清晰：

1. 引入 API 聚合平台作为接入层，解决网络和支付问题——代码改动极小（改两个参数）
2. 用 ChatOpenAI + 自定义 base_url 覆盖 90% 场景，一份代码支持所有主流模型
3. 按任务选模型：轻量任务用 Haiku/DeepSeek 省钱，复杂推理用 Sonnet/Opus，代码任务用 GPT-4.1
4. 用 LCEL 构建链式调用，充分利用 configurable_alternatives 做多模型切换
5. 异步并发处理批量任务，速度比串行快 4-5 倍

下一步：

• 注册 Ofox 获取 API Key，按照本文示例跑通第一个请求
• 参考 LangChain 官方文档 探索 Agent、RAG 等高级用法
• 在 Ofox 控制台查看每个模型的价格和延迟数据，选择最适合你业务的模型

验证记录

本文代码示例均已联网核验，以下为验证详情：

SDK	版本	文档链接	验证日期
langchain-openai	v0.3.x	python.langchain.com	2026-03-03
langchain	v0.3.x	python.langchain.com/docs/concepts/lcel	2026-03-03
anthropic Python SDK	v0.43+	Context7: /anthropics/anthropic-sdk-python	2026-03-03

代码变更说明：

• ChatOpenAI 的 base_url 参数：来自 LangChain 官方文档，已确认支持自定义 endpoint
• 模型 ID 格式（anthropic/claude-sonnet-4-6）：以 docs.ofox.ai/develop 为权威来源，文章中使用示例格式，请以平台实际列表为准
• LCEL 管道语法（| 操作符）：LangChain 0.3+ 稳定特性

参考资料

• LangChain ChatOpenAI 文档 — LangChain 官方
• LangChain LCEL 概念文档 — LangChain 官方
• Anthropic Python SDK — Anthropic 官方 GitHub
• Claude API 模型列表 — Anthropic 官方
• Ofox API 文档 — 模型列表与接入说明
• ChatOpenAI API Reference — LangChain API 参考