第一个应用

恭喜你完成了环境搭建！现在让我们创建第一个 LangChain 应用——一个简单但功能完整的 AI 对话助手。

目标

在本章中，你将学会：

  • 创建并调用 LLM 模型
  • 使用提示词模板
  • 处理模型输出
  • 构建一个完整的对话流程

Hello LangChain

让我们从最简单的例子开始：

from langchain_openai import ChatOpenAI
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

# 创建模型实例
llm = ChatOpenAI(model="gpt-3.5-turbo")

# 发送消息
response = llm.invoke("用一句话解释什么是人工智能")

# 输出回复
print(response.content)

运行结果示例：

人工智能是让计算机模拟人类智能行为的技术，包括学习、推理、理解语言等能力。

🎉 恭喜！你已经成功运行了第一个 LangChain 程序！

理解核心概念

消息类型

LangChain 中有三种主要的消息类型：

from langchain_core.messages import HumanMessage, AIMessage, SystemMessage

messages = [
    SystemMessage(content="你是一个友好的 AI 助手"),  # 系统消息，设定 AI 角色
    HumanMessage(content="你好！"),                   # 用户消息
    AIMessage(content="你好！有什么可以帮助你的？"),    # AI 回复
    HumanMessage(content="今天天气怎么样？")          # 新的用户消息
]

response = llm.invoke(messages)
print(response.content)

invoke vs stream

invoke 会等待完整回复，stream 则是流式输出：

# 流式输出 - 逐字显示
for chunk in llm.stream("讲一个简短的笑话"):
    print(chunk.content, end="", flush=True)

构建翻译助手

让我们构建一个实用的翻译助手：

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

load_dotenv()

# 1. 创建模型
llm = ChatOpenAI(model="gpt-3.5-turbo")

# 2. 创建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个专业的翻译官，擅长{source_lang}和{target_lang}之间的翻译。"),
    ("human", "请将以下内容从{source_lang}翻译成{target_lang}：\n\n{text}")
])

# 3. 创建输出解析器
output_parser = StrOutputParser()

# 4. 组装成链
chain = prompt | llm | output_parser

# 5. 运行
result = chain.invoke({
    "source_lang": "中文",
    "target_lang": "英文",
    "text": "人工智能正在改变我们的生活方式。"
})

print(result)
# 输出: Artificial intelligence is changing our way of life.

代码解析

这段代码展示了 LangChain 的核心模式——LCEL（LangChain Expression Language）：

chain = prompt | llm | output_parser

这个管道的数据流：

输入参数 → prompt（格式化） → llm（推理） → output_parser（解析） → 最终输出

构建问答机器人

让我们创建一个更复杂的问答机器人：

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage
from dotenv import load_dotenv

load_dotenv()

# 创建模型
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)

# 创建带有历史消息的提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个知识渊博的 AI 助手，名叫小智。
你的特点：
- 回答简洁明了
- 语气友好亲切
- 如果不确定，会诚实地说不知道"""),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

# 组装链
chain = prompt | llm

# 对话历史
history = []

def chat(user_input: str) -> str:
    """发送消息并获取回复"""
    # 调用链
    response = chain.invoke({
        "history": history,
        "input": user_input
    })
    
    # 更新历史
    history.append(HumanMessage(content=user_input))
    history.append(AIMessage(content=response.content))
    
    return response.content

# 测试对话
print("小智：你好！我是小智，有什么可以帮助你的？\n")

while True:
    user_input = input("你：")
    if user_input.lower() in ['退出', 'quit', 'exit']:
        print("小智：再见！期待下次与你交流！")
        break
    
    response = chat(user_input)
    print(f"小智：{response}\n")

添加系统参数

让机器人的行为可配置：

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from dotenv import load_dotenv

load_dotenv()

# 不同场景的系统提示词
PERSONAS = {
    "默认": "你是一个友好的 AI 助手。",
    "程序员": "你是一个经验丰富的程序员，擅长解释技术概念和编写代码。",
    "老师": "你是一个耐心的老师，擅长用简单的例子解释复杂的概念。",
    "诗人": "你是一个浪漫的诗人，喜欢用诗意的语言表达。"
}

def create_bot(persona: str = "默认", temperature: float = 0.7):
    """创建具有特定人格的聊天机器人"""
    
    llm = ChatOpenAI(
        model="gpt-3.5-turbo",
        temperature=temperature
    )
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", PERSONAS.get(persona, PERSONAS["默认"])),
        ("human", "{input}")
    ])
    
    return prompt | llm

# 测试不同人格
programmer_bot = create_bot("程序员")
response = programmer_bot.invoke({"input": "什么是递归？"})
print("程序员视角：", response.content)

teacher_bot = create_bot("老师")
response = teacher_bot.invoke({"input": "什么是递归？"})
print("\n老师视角：", response.content)

poet_bot = create_bot("诗人", temperature=0.9)
response = poet_bot.invoke({"input": "什么是递归？"})
print("\n诗人视角：", response.content)

处理异常

在实际应用中，需要处理各种异常情况：

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from openai import APIError, RateLimitError
import time

def safe_invoke(chain, inputs, max_retries=3):
    """安全地调用链，包含重试机制"""
    
    for attempt in range(max_retries):
        try:
            return chain.invoke(inputs)
        
        except RateLimitError:
            # API 速率限制，等待后重试
            wait_time = 2 ** attempt  # 指数退避
            print(f"速率限制，等待 {wait_time} 秒后重试...")
            time.sleep(wait_time)
        
        except APIError as e:
            # API 错误
            print(f"API 错误: {e}")
            if attempt == max_retries - 1:
                raise
        
        except Exception as e:
            # 其他错误
            print(f"未知错误: {e}")
            raise
    
    raise Exception("达到最大重试次数")

# 使用示例
llm = ChatOpenAI(model="gpt-3.5-turbo")
prompt = ChatPromptTemplate.from_template("回答问题：{question}")
chain = prompt | llm

try:
    response = safe_invoke(chain, {"question": "什么是机器学习？"})
    print(response.content)
except Exception as e:
    print(f"无法获取回答：{e}")

完整示例：智能助手

把所有学到的内容整合成一个完整的智能助手：

"""
智能助手 - LangChain 入门示例
"""

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.output_parsers import StrOutputParser
from dotenv import load_dotenv
from datetime import datetime

# 加载环境变量
load_dotenv()

class SmartAssistant:
    """智能助手类"""
    
    def __init__(self, name: str = "小智", model: str = "gpt-3.5-turbo"):
        self.name = name
        self.history = []
        
        # 初始化模型
        self.llm = ChatOpenAI(model=model, temperature=0.7)
        
        # 创建提示词模板
        self.prompt = ChatPromptTemplate.from_messages([
            ("system", f"""你是一个智能助手，名叫{name}。
当前时间：{datetime.now().strftime('%Y年%m月%d日 %H:%M')}

你的特点：
- 回答准确、有条理
- 语气友好、专业
- 如果不确定，会诚实地说不知道
- 能够记住之前的对话内容"""),
            MessagesPlaceholder(variable_name="history"),
            ("human", "{input}")
        ])
        
        # 组装链
        self.chain = self.prompt | self.llm | StrOutputParser()
    
    def chat(self, message: str) -> str:
        """发送消息并获取回复"""
        response = self.chain.invoke({
            "history": self.history,
            "input": message
        })
        
        # 更新对话历史
        self.history.append(HumanMessage(content=message))
        self.history.append(AIMessage(content=response))
        
        return response
    
    def clear_history(self):
        """清除对话历史"""
        self.history = []
        print(f"[{self.name}] 对话历史已清除")
    
    def run(self):
        """运行交互式对话"""
        print(f"\n{'='*50}")
        print(f"  欢迎使用 {self.name} 智能助手")
        print(f"  输入 '退出' 结束对话，'清除' 清除历史")
        print(f"{'='*50}\n")
        
        while True:
            try:
                user_input = input("你：").strip()
                
                if not user_input:
                    continue
                
                if user_input in ['退出', 'quit', 'exit']:
                    print(f"\n{self.name}：再见！期待下次交流！👋")
                    break
                
                if user_input in ['清除', 'clear']:
                    self.clear_history()
                    continue
                
                response = self.chat(user_input)
                print(f"\n{self.name}：{response}\n")
                
            except KeyboardInterrupt:
                print(f"\n\n{self.name}：检测到中断，再见！")
                break
            except Exception as e:
                print(f"\n{self.name}：抱歉，遇到了一些问题：{e}\n")


if __name__ == "__main__":
    # 创建并运行助手
    assistant = SmartAssistant(name="小智")
    assistant.run()

运行效果

==================================================
  欢迎使用 小智 智能助手
  输入 '退出' 结束对话，'清除' 清除历史
==================================================

你：你好，介绍一下你自己

小智：你好！我是小智，一个智能助手。我可以帮你回答问题、提供信息、
进行对话交流。无论是学习、工作还是日常生活中的问题，我都会尽力
帮助你。有什么想问的吗？

你：我想学习 Python，应该从哪里开始？

小智：学习 Python 是个很好的选择！这里是我建议的学习路径：

1. **基础语法** - 变量、数据类型、运算符
2. **控制流程** - if/else、for/while 循环
3. **函数** - 定义和调用函数
4. **数据结构** - 列表、字典、元组、集合
5. **文件操作** - 读写文件
6. **面向对象** - 类和对象

推荐资源：
- 官方教程：docs.python.org
- 在线练习：LeetCode、Codecademy
- 书籍：《Python编程：从入门到实践》

有任何具体问题随时问我！

你：退出

小智：再见！期待下次交流！👋

小结

在本章中，你学会了：

✅ 创建和调用 LLM 模型
✅ 使用消息类型（System、Human、AI）
✅ 创建提示词模板
✅ 使用 LCEL 组装链
✅ 实现对话历史管理
✅ 处理异常和错误
✅ 构建完整的对话应用

下一步

现在你已经能够创建基本的 LangChain 应用了。接下来，让我们深入了解模型调用的更多细节。

练习建议

  1. 修改系统提示词，创建不同风格的助手
  2. 添加更多的错误处理
  3. 尝试使用不同的模型（如 GPT-4 或国内模型）
  4. 实现对话保存功能（保存到文件）