手把手LangChain实战：从模型调用到智能响应全解析

2025年11月27日 互联网

手把手教你使用LangChain开发多功能聊天机器人：二、模型的调用以及获取大模型的响应

一、模型调用前的核心准备

在正式调用大模型前，开发者需完成三项关键准备：

  1. 模型选择与兼容性验证
    LangChain支持OpenAI GPT系列、HuggingFace Transformers、Anthropic Claude等主流模型。选择时需考虑：

    • 模型能力：文本生成、逻辑推理、多模态处理等
    • 响应速度：实时交互场景需优先选择低延迟模型
    • 成本预算：按需选择付费API或开源本地部署方案

    示例代码（验证模型可用性）：

    1. from langchain.llms import OpenAI, HuggingFaceHub
    2. try:
    3.     llm = OpenAI(model_name="gpt-3.5-turbo", temperature=0.7)
    4.     response = llm.predict("你好")
    5.     print(f"模型响应成功：{response}")
    6. except Exception as e:
    7.     print(f"模型初始化失败：{str(e)}")

  2. API密钥安全配置
    推荐使用环境变量存储敏感信息：

    1. import os
    2. from dotenv import load_dotenv
    3. load_dotenv()
    4. OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

  3. 响应格式预定义
    通过response_format参数控制输出结构：

    1. llm = OpenAI(
    2.     model_name="gpt-4",
    3.     response_format={"type": "json_object"},
    4.     max_tokens=500
    5. )

二、模型调用的四种核心方式

1. 直接调用（LLM Chain）

适用于简单问答场景：

  1. from langchain.chains import LLMChain
  2. from langchain.prompts import PromptTemplate
  4. template = """
  5. 用户问题：{question}
  6. 请用Markdown格式回答，包含步骤说明和示例代码
  7. """
  8. prompt = PromptTemplate(template=template, input_variables=["question"])
  9. chain = LLMChain(llm=llm, prompt=prompt)
  10. response = chain.run("如何用Python实现文件下载？")

2. 结构化调用（Structured Output）

通过OutputParser解析JSON响应：

  1. from langchain.output_parsers import PydanticOutputParser
  2. from pydantic import BaseModel
  4. class Answer(BaseModel):
  5.     text: str
  6.     code_example: str
  8. parser = PydanticOutputParser(pydantic_object=Answer)
  9. prompt = PromptTemplate(
  10.     template="生成包含{text}和{code_example}的JSON回答",
  11.     input_variables=[],
  12.     partial_variables={"format_instructions": parser.get_format_instructions()}
  13. )

3. 流式响应（Streaming）

实现实时打字效果：

  1. from langchain.callbacks import StreamingStdOutCallbackHandler
  3. stream_handler = StreamingStdOutCallbackHandler()
  4. llm = OpenAI(
  5.     model_name="gpt-3.5-turbo",
  6.     streaming=True,
  7.     callbacks=[stream_handler]
  8. )
  9. response = llm("生成一篇科技文章开头...")

4. 多模型协同（Router Chain）

根据问题类型动态选择模型：

  1. from langchain.chains import RouterChain
  2. from langchain.chains.router import MultiPromptRoute
  4. routes = {
  5.     "math": MultiPromptRoute(
  6.         destination_chain=MathLLMChain(),
  7.         example_input="计算1+1="
  8.     ),
  9.     "general": MultiPromptRoute(
  10.         destination_chain=GeneralLLMChain(),
  11.         example_input="今天天气如何？"
  12.     )
  13. }
  14. router = RouterChain(routes=routes)

三、响应处理与优化技巧

1. 响应质量提升策略

  • 温度参数：temperature=0.7（创意性） vs temperature=0.1（确定性）
  • Top-p采样：top_p=0.9控制输出多样性
  • 频率惩罚：frequency_penalty=0.5减少重复

2. 错误处理机制

  1. from langchain.callbacks import CallbackManager
  2. from langchain.callbacks.base import BaseCallbackHandler
  4. class ErrorHandler(BaseCallbackHandler):
  5.     def on_llm_error(self, error, **kwargs):
  6.         print(f"模型错误：{str(error)}")
  7.         # 降级策略：切换备用模型
  8.         return OpenAI(model_name="gpt-3.5-turbo-16k")
  10. manager = CallbackManager([ErrorHandler()])
  11. llm = OpenAI(model_name="gpt-4", callback_manager=manager)

3. 响应缓存优化

  1. from langchain.cache import SQLiteCache
  3. cache = SQLiteCache("llm_cache.db")
  4. llm = OpenAI(model_name="gpt-3.5-turbo", callbacks=[cache])
  5. # 相同问题第二次调用将从缓存获取

四、实战场景解析

场景1：电商客服机器人

  1. from langchain.prompts import ChatPromptTemplate
  2. from langchain.schema import HumanMessage
  4. template = """
  5. 用户：{query}
  6. 历史对话：{history}
  7. 当前角色：电商客服
  8. 必须：提供退换货政策链接
  9. """
  10. prompt = ChatPromptTemplate.from_template(template)
  11. messages = [
  12.     HumanMessage(content="我想退换刚买的手机"),
  13.     # 添加历史对话...
  14. ]
  15. response = llm.generate([prompt.format_prompt(**context)])

场景2：技术文档生成

  1. from langchain.document_loaders import TextLoader
  2. from langchain.text_splitter import RecursiveCharacterTextSplitter
  4. loader = TextLoader("api_docs.txt")
  5. documents = loader.load()
  6. text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
  7. texts = text_splitter.split_documents(documents)
  9. # 结合检索增强生成（RAG）
  10. from langchain.chains import RetrievalQA
  11. from langchain.vectorstores import FAISS
  12. from langchain.embeddings import OpenAIEmbeddings
  14. embeddings = OpenAIEmbeddings()
  15. docsearch = FAISS.from_documents(texts, embeddings)
  16. qa_chain = RetrievalQA.from_chain_type(
  17.     llm=llm,
  18.     chain_type="stuff",
  19.     retriever=docsearch.as_retriever()
  20. )
  21. response = qa_chain.run("如何调用API？")

五、性能监控与调优

  1. 响应时间分析：

    1. import time
    2. start = time.time()
    3. response = llm.predict("复杂问题")
    4. latency = time.time() - start
    5. print(f"响应耗时：{latency:.2f}秒")

  2. 令牌消耗统计：

    1. from langchain.callbacks import TokenUsageRecorder
    2. recorder = TokenUsageRecorder()
    3. llm = OpenAI(model_name="gpt-4", callbacks=[recorder])
    4. # 调用后可通过recorder.last_tokens_used获取数据

  3. A/B测试框架：

    1. def test_model_performance():
    2.     models = ["gpt-3.5-turbo", "gpt-4", "claude-2"]
    3.     results = {}
    4.     for model in models:
    5.         llm = OpenAI(model_name=model)
    6.         start = time.time()
    7.         response = llm.predict("测试问题")
    8.         results[model] = {
    9.             "time": time.time() - start,
    10.             "length": len(response)
    11.         }
    12.     return results

六、常见问题解决方案

  1. 超时问题：

    • 增加timeout参数：llm = OpenAI(timeout=30)
    • 启用异步调用：await llm.acall("问题")

  2. 内容过滤：

    1. from langchain.llms.openai import OpenAI
    2. llm = OpenAI(
    3.     model_name="gpt-3.5-turbo",
    4.     safety_settings=[
    5.         {"category": "hate", "threshold": 0.5},
    6.         {"category": "sexual", "threshold": 0.5}
    7.     ]
    8. )

  3. 多语言支持：

    1. llm = OpenAI(
    2.     model_name="gpt-3.5-turbo",
    3.     request_timeout=60,
    4.     headers={"Accept-Language": "zh-CN"}
    5. )

通过系统化的模型调用方法和响应处理策略，开发者可以构建出既稳定又高效的智能聊天机器人。实际开发中建议结合具体业务场景，通过持续监控和迭代优化达到最佳效果。

最新文章