模型调用

LangChain 支持多种模型类型和提供商。本章将详细介绍如何在 LangChain 中使用各种语言模型。

💡 标准模型接口 - LangChain 的核心优势

不同的模型提供商有不同的 API 格式和响应结构。LangChain 标准化了模型交互方式，让你可以：

  • ✅ 无缝切换提供商：从 OpenAI 切换到 Claude，只需改一行代码
  • ✅ 避免厂商锁定：不依赖特定提供商的 API
  • ✅ 统一的开发体验：所有模型使用相同的方法（invoke, stream, batch）

模型类型

LangChain 中有两种主要的模型类型：

LLM（大语言模型）

输入文本，输出文本的传统模型：

from langchain_openai import OpenAI

llm = OpenAI(model="gpt-3.5-turbo-instruct")
response = llm.invoke("什么是人工智能？")
print(response)  # 直接返回字符串

Chat Model（对话模型）

基于消息的对话模型（更常用）：

from langchain_openai import ChatOpenAI

chat = ChatOpenAI(model="gpt-3.5-turbo")
response = chat.invoke("什么是人工智能？")
print(response.content)  # 返回 AIMessage 对象

推荐

现代应用中，Chat Model 是主流选择。本教程主要使用 Chat Model。

常用模型配置

基础参数

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-3.5-turbo",      # 模型名称
    temperature=0.7,             # 创造性（0-2，默认1）
    max_tokens=1000,            # 最大输出 token 数
    timeout=30,                 # 超时时间（秒）
    max_retries=2,              # 最大重试次数
)

Temperature 参数

temperature 控制输出的随机性：

值效果适用场景
0确定性输出，每次相同代码生成、数据提取
0.3-0.5较低随机性问答、翻译
0.7-0.9中等随机性对话、写作
1.0+高随机性创意写作、头脑风暴
# 代码生成 - 需要精确
code_llm = ChatOpenAI(model="gpt-4", temperature=0)

# 创意写作 - 需要多样性
creative_llm = ChatOpenAI(model="gpt-4", temperature=0.9)

主流模型提供商

OpenAI

from langchain_openai import ChatOpenAI

# GPT-3.5
llm_35 = ChatOpenAI(model="gpt-3.5-turbo")

# GPT-4
llm_4 = ChatOpenAI(model="gpt-4")

# GPT-4 Turbo
llm_4_turbo = ChatOpenAI(model="gpt-4-turbo")

# GPT-4o（最新多模态模型）
llm_4o = ChatOpenAI(model="gpt-4o")

Anthropic Claude

from langchain_anthropic import ChatAnthropic

# Claude 3.5 Sonnet（推荐，性价比最高）
llm = ChatAnthropic(model="claude-sonnet-4-5-20250929")

# Claude 3 Opus（最强大）
llm = ChatAnthropic(model="claude-3-opus-20240229")

# Claude 3 Haiku（最快速）
llm = ChatAnthropic(model="claude-3-haiku-20240307")

# Claude 3.5 Haiku（快速且强大）
llm = ChatAnthropic(model="claude-3-5-haiku-20241022")

智谱 AI（国内推荐）

from langchain_zhipuai import ChatZhipuAI

# GLM-4
llm = ChatZhipuAI(model="glm-4")

# GLM-4V（多模态）
llm = ChatZhipuAI(model="glm-4v")

阿里通义千问

from langchain_community.chat_models import ChatTongyi

llm = ChatTongyi(
    model="qwen-turbo",
    # 或 "qwen-plus", "qwen-max"
)

本地模型（Ollama）

from langchain_ollama import ChatOllama

# 使用本地 Llama 3
llm = ChatOllama(model="llama3")

# 使用本地 Mistral
llm = ChatOllama(model="mistral")

消息类型详解

Chat Model 使用消息列表进行对话：

from langchain_core.messages import (
    SystemMessage,    # 系统消息 - 设定 AI 行为
    HumanMessage,     # 用户消息
    AIMessage,        # AI 回复
)

messages = [
    SystemMessage(content="你是一个专业的翻译官"),
    HumanMessage(content="请翻译：Hello World"),
    AIMessage(content="你好，世界"),
    HumanMessage(content="再翻译：Good morning")
]

response = llm.invoke(messages)
print(response.content)  # "早上好"

使用元组简化

from langchain_core.prompts import ChatPromptTemplate

# 使用元组格式
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个{role}"),
    ("human", "{input}"),
])

chain = prompt | llm
response = chain.invoke({"role": "翻译官", "input": "Hello"})

调用方式

同步调用

# invoke - 单次调用
response = llm.invoke("你好")

# batch - 批量调用
responses = llm.batch(["问题1", "问题2", "问题3"])

流式输出

# stream - 流式输出
for chunk in llm.stream("讲一个故事"):
    print(chunk.content, end="", flush=True)

异步调用

import asyncio

async def async_chat():
    # ainvoke - 异步单次调用
    response = await llm.ainvoke("你好")
    print(response.content)
    
    # astream - 异步流式
    async for chunk in llm.astream("讲一个故事"):
        print(chunk.content, end="", flush=True)

asyncio.run(async_chat())

模型回调

使用回调监控模型调用：

from langchain_core.callbacks import BaseCallbackHandler

class MyCallback(BaseCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"🚀 开始调用 LLM")
        print(f"   输入: {prompts[0][:50]}...")
    
    def on_llm_end(self, response, **kwargs):
        print(f"✅ LLM 调用完成")
        print(f"   Token 使用: {response.llm_output}")
    
    def on_llm_error(self, error, **kwargs):
        print(f"❌ LLM 调用失败: {error}")

# 使用回调
llm = ChatOpenAI(callbacks=[MyCallback()])
response = llm.invoke("你好")

获取 Token 使用量

from langchain_openai import ChatOpenAI
from langchain_core.callbacks import get_openai_callback

llm = ChatOpenAI(model="gpt-3.5-turbo")

with get_openai_callback() as cb:
    response = llm.invoke("写一首关于春天的诗")
    print(response.content)
    
print(f"\n--- Token 统计 ---")
print(f"输入 Token: {cb.prompt_tokens}")
print(f"输出 Token: {cb.completion_tokens}")
print(f"总 Token: {cb.total_tokens}")
print(f"总费用: ${cb.total_cost:.4f}")

模型参数绑定

使用 bind 预设参数：

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-3.5-turbo")

# 绑定参数
json_llm = llm.bind(response_format={"type": "json_object"})

response = json_llm.invoke("生成一个用户信息的 JSON，包含姓名和年龄")
print(response.content)
# {"name": "张三", "age": 25}

绑定停止词

# 设置停止词
llm_with_stop = llm.bind(stop=["\n\n", "END"])

response = llm_with_stop.invoke("数数：1, 2, 3,")

缓存机制

避免重复调用，节省成本：

from langchain_core.globals import set_llm_cache
from langchain_community.cache import InMemoryCache, SQLiteCache

# 内存缓存
set_llm_cache(InMemoryCache())

# SQLite 持久化缓存
set_llm_cache(SQLiteCache(database_path=".langchain.db"))

# 第一次调用（实际调用 API）
response1 = llm.invoke("什么是 Python？")

# 第二次调用（从缓存返回）
response2 = llm.invoke("什么是 Python？")

无缝切换模型提供商

LangChain 的标准接口让切换提供商变得极其简单：

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_zhipuai import ChatZhipuAI
from langchain_core.prompts import ChatPromptTemplate

# 定义通用提示词和链
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个专业的翻译官"),
    ("human", "翻译成英文：{text}")
])

# 方式一：使用 OpenAI
llm = ChatOpenAI(model="gpt-4")
chain = prompt | llm

# 方式二：切换到 Anthropic（只需改这一行！）
llm = ChatAnthropic(model="claude-sonnet-4-5-20250929")
chain = prompt | llm

# 方式三：切换到国内模型（只需改这一行！）
llm = ChatZhipuAI(model="glm-4")
chain = prompt | llm

# 使用方式完全相同！
result = chain.invoke({"text": "你好世界"})
print(result.content)

模型切换策略

构建支持多模型的应用：

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_zhipuai import ChatZhipuAI

class ModelFactory:
    """模型工厂"""
    
    @staticmethod
    def create(provider: str, model: str = None, **kwargs):
        """创建模型实例"""
        
        providers = {
            "openai": lambda: ChatOpenAI(
                model=model or "gpt-3.5-turbo", **kwargs
            ),
            "anthropic": lambda: ChatAnthropic(
                model=model or "claude-3-sonnet-20240229", **kwargs
            ),
            "zhipuai": lambda: ChatZhipuAI(
                model=model or "glm-4", **kwargs
            ),
        }
        
        if provider not in providers:
            raise ValueError(f"不支持的提供商: {provider}")
        
        return providers[provider]()

# 使用示例
llm = ModelFactory.create("openai", model="gpt-4")
# 或
llm = ModelFactory.create("zhipuai")

实战案例

案例1：智能翻译器

"""
支持多语言的智能翻译器
"""
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

def create_translator(model: str = "gpt-3.5-turbo"):
    llm = ChatOpenAI(model=model, temperature=0)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", """你是一个专业的多语言翻译官。
请将用户输入的文本翻译成指定的目标语言。
只输出翻译结果，不要添加任何解释。"""),
        ("human", "将以下内容翻译成{target_language}：\n{text}")
    ])
    
    return prompt | llm | StrOutputParser()

# 使用
translator = create_translator()

# 中译英
result = translator.invoke({
    "text": "人工智能正在改变世界",
    "target_language": "英文"
})
print(result)  # Artificial intelligence is changing the world

# 英译日
result = translator.invoke({
    "text": "Hello World",
    "target_language": "日文"
})
print(result)  # こんにちは世界

案例2：代码解释器

"""
代码解释器 - 解释任何编程语言的代码
"""
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

def create_code_explainer():
    llm = ChatOpenAI(model="gpt-4", temperature=0)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", """你是一个编程专家，擅长解释代码。
请用简洁易懂的中文解释用户提供的代码：
1. 代码的功能是什么
2. 逐行解释关键逻辑
3. 使用场景和注意事项"""),
        ("human", "请解释以下{language}代码：\n```{language}\n{code}\n```")
    ])
    
    return prompt | llm

explainer = create_code_explainer()

code = '''
def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)
'''

result = explainer.invoke({"language": "Python", "code": code})
print(result.content)

案例3：情感分析器

"""
文本情感分析 - 分析文本的情感倾向
"""
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import JsonOutputParser
from pydantic import BaseModel, Field

class SentimentResult(BaseModel):
    sentiment: str = Field(description="情感倾向：积极/消极/中性")
    confidence: float = Field(description="置信度 0-1")
    keywords: list[str] = Field(description="关键情感词汇")
    summary: str = Field(description="简短分析说明")

def create_sentiment_analyzer():
    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
    parser = JsonOutputParser(pydantic_object=SentimentResult)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", """你是一个情感分析专家。
分析用户文本的情感倾向，输出 JSON 格式。
{format_instructions}"""),
        ("human", "{text}")
    ])
    
    return prompt.partial(format_instructions=parser.get_format_instructions()) | llm | parser

analyzer = create_sentiment_analyzer()

texts = [
    "这个产品太棒了！质量超好，物流也快，五星好评！",
    "等了一周才收到，包装破损，客服态度还差，差评！",
    "还行吧，中规中矩，没什么特别的。"
]

for text in texts:
    result = analyzer.invoke({"text": text})
    print(f"文本：{text[:20]}...")
    print(f"情感：{result['sentiment']}，置信度：{result['confidence']}")
    print(f"关键词：{result['keywords']}\n")

案例4：多模型对比

"""
同时使用多个模型，对比输出结果
"""
import asyncio
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate

async def compare_models(question: str):
    prompt = ChatPromptTemplate.from_messages([
        ("human", "{question}")
    ])
    
    models = {
        "GPT-4": ChatOpenAI(model="gpt-4"),
        "GPT-3.5": ChatOpenAI(model="gpt-3.5-turbo"),
        "Claude": ChatAnthropic(model="claude-sonnet-4-5-20250929"),
    }
    
    results = {}
    for name, llm in models.items():
        chain = prompt | llm
        response = await chain.ainvoke({"question": question})
        results[name] = response.content
    
    return results

# 使用
async def main():
    question = "用一句话解释什么是量子计算"
    results = await compare_models(question)
    
    print(f"问题：{question}\n")
    for model, answer in results.items():
        print(f"【{model}】: {answer}\n")

asyncio.run(main())

完整示例

"""
多模型问答系统
"""

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.callbacks import get_openai_callback
from dotenv import load_dotenv

load_dotenv()

def create_qa_chain(model: str = "gpt-3.5-turbo", temperature: float = 0.7):
    """创建问答链"""
    
    llm = ChatOpenAI(model=model, temperature=temperature)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个专业的问答助手。请简洁准确地回答问题。"),
        ("human", "{question}")
    ])
    
    return prompt | llm | StrOutputParser()

def main():
    # 创建不同配置的链
    chains = {
        "标准": create_qa_chain("gpt-3.5-turbo", 0.7),
        "精确": create_qa_chain("gpt-3.5-turbo", 0),
        "创意": create_qa_chain("gpt-3.5-turbo", 1.0),
    }
    
    question = "为什么天空是蓝色的？"
    print(f"问题: {question}\n")
    
    for name, chain in chains.items():
        with get_openai_callback() as cb:
            response = chain.invoke({"question": question})
            print(f"【{name}模式】")
            print(f"{response}")
            print(f"(Token: {cb.total_tokens}, 费用: ${cb.total_cost:.4f})\n")

if __name__ == "__main__":
    main()

小结

本章介绍了：

✅ 标准模型接口 - LangChain 的核心优势
✅ LLM 和 Chat Model 的区别
✅ 常用模型参数（temperature、max_tokens等）
✅ 各大模型提供商的使用方法
✅ 无缝切换模型提供商
✅ 同步、异步、流式调用
✅ Token 统计和回调机制
✅ 缓存和模型切换策略
✅ 4个实战案例：

  • 智能翻译器
  • 代码解释器
  • 情感分析器
  • 多模型对比

下一步

掌握模型调用后，让我们学习如何使用提示词模板来更好地控制模型输出。

练习

  1. 对比同一问题在不同 temperature 下的回答
  2. 尝试使用不同的模型提供商（OpenAI、Claude、智谱）
  3. 实现一个带 Token 统计的对话系统
  4. 测试缓存对响应速度的影响
  5. 创建一个支持多模型切换的翻译应用