大模型应用开发入门：用VSCode跑通第一个LangChain程序

从零开始：完整实战指南

第一章：环境准备与配置

1.1 安装Python和VSCode

Python安装：

python 复制代码

# Windows用户
1. 访问 https://python.org 下载Python 3.10+
2. 安装时勾选"Add Python to PATH"

# Mac用户
brew install python@3.10

# Linux用户
sudo apt update
sudo apt install python3.10 python3.10-venv

VSCode安装：

访问 https://code.visualstudio.com 下载安装
安装必要的扩展：
- Python
- Jupyter
- Pylance
- GitLens

1.2 创建项目文件夹结构

bash 复制代码

# 创建项目目录
mkdir my-first-langchain
cd my-first-langchain

# 创建文件结构
mkdir -p src/tools src/chains src/agents
touch README.md requirements.txt .env.example
touch src/hello_langchain.py src/chat_bot.py

项目结构预览：

html 复制代码

my-first-langchain/
├── .env                    # 环境变量（不提交到Git）
├── .env.example           # 环境变量模板
├── requirements.txt       # 依赖包列表
├── README.md             # 项目说明
└── src/
    ├── hello_langchain.py  # 第一个程序
    ├── chat_bot.py        # 聊天机器人
    ├── tools/            # 工具模块
    └── chains/           # 链模块

第二章：配置开发环境

2.1 创建虚拟环境

bash 复制代码

# Windows
python -m venv venv
venv\Scripts\activate

# Mac/Linux
python3 -m venv venv
source venv/bin/activate

# 确认激活（应该显示(venv)前缀）
which python
# 输出: /path/to/my-first-langchain/venv/bin/python

2.2 安装依赖包

创建 requirements.txt：

html 复制代码

# LangChain核心
langchain>=0.0.340
langchain-community>=0.0.10
langchain-openai>=0.0.2

# 模型提供商
openai>=1.3.0

# 向量数据库（可选）
chromadb>=0.4.15

# Web框架（可选）
fastapi>=0.104.0
uvicorn>=0.24.0

# 工具类
python-dotenv>=1.0.0
pydantic>=2.5.0

# 开发工具
jupyter>=1.0.0
ipython>=8.17.0
black>=23.11.0
pylint>=3.0.3

安装依赖：

bash 复制代码

# 升级pip
python -m pip install --upgrade pip

# 安装依赖包
pip install -r requirements.txt

# 检查安装
pip list | grep langchain
# 应该显示类似：langchain 0.0.340

2.3 配置API密钥

创建 .env 文件：

bash 复制代码

# 复制环境变量模板
cp .env.example .env

# 编辑 .env 文件
# Windows: notepad .env
# Mac: nano .env
# Linux: vim .env

.env 文件内容：

bash 复制代码

# OpenAI API配置
OPENAI_API_KEY=your-openai-api-key-here

# 可选的备用API（如有）
ANTHROPIC_API_KEY=
COHERE_API_KEY=
GOOGLE_API_KEY=

# 应用配置
DEBUG=true
LOG_LEVEL=INFO

# 代理设置（如需要）
HTTP_PROXY=http://127.0.0.1:7890
HTTPS_PROXY=http://127.0.0.1:7890

获取API密钥：

访问 https://platform.openai.com/api-keys
点击 "Create new secret key"
复制密钥到 .env 文件

第三章：第一个LangChain程序

3.1 Hello LangChain!

创建 src/hello_langchain.py：

python 复制代码

#!/usr/bin/env python3
"""
第一个LangChain程序
功能：使用OpenAI模型生成文本
"""

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage

# 1. 加载环境变量
print("🔧 步骤1：加载环境变量...")
load_dotenv()

# 检查API密钥
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
    print("❌ 错误：未找到OPENAI_API_KEY")
    print("请检查 .env 文件是否正确配置")
    exit(1)
else:
    print(f"✅ API密钥加载成功（前10位：{api_key[:10]}...）")

# 2. 初始化模型
print("\n🚀 步骤2：初始化ChatGPT模型...")
try:
    # 创建ChatGPT实例
    llm = ChatOpenAI(
        model="gpt-3.5-turbo",  # 使用gpt-3.5-turbo模型（性价比高）
        temperature=0.7,        # 创造性：0（确定性）到1（创造性）
        max_tokens=500,         # 最大输出长度
        api_key=api_key
    )
    print("✅ 模型初始化成功！")
except Exception as e:
    print(f"❌ 模型初始化失败：{e}")
    exit(1)

# 3. 测试模型
print("\n💬 步骤3：测试模型...")
test_message = HumanMessage(content="请用中文简单介绍一下人工智能")
print(f"发送消息：'{test_message.content}'")

try:
    response = llm.invoke([test_message])
    print("\n🤖 ChatGPT回复：")
    print("-" * 50)
    print(response.content)
    print("-" * 50)
except Exception as e:
    print(f"❌ 请求失败：{e}")

# 4. 交互式对话
print("\n🎮 步骤4：开始交互式对话（输入 'quit' 退出）")
print("-" * 50)

while True:
    try:
        user_input = input("\n🧑‍💻 你：").strip()
        
        if user_input.lower() in ['quit', 'exit', 'q']:
            print("👋 再见！")
            break
        
        if not user_input:
            continue
        
        # 创建消息
        message = HumanMessage(content=user_input)
        
        # 获取回复
        print("⏳ 思考中...", end="", flush=True)
        response = llm.invoke([message])
        print("\r✅ 完成！" + " " * 20)
        
        # 显示回复
        print(f"\n🤖 AI：{response.content}")
        
    except KeyboardInterrupt:
        print("\n\n👋 用户中断，程序退出")
        break
    except Exception as e:
        print(f"\n❌ 错误：{e}")
        continue

print("\n🎉 第一个LangChain程序运行成功！")

3.2 运行程序

bash 复制代码

# 进入项目目录
cd my-first-langchain

# 激活虚拟环境（如果还没激活）
# Windows: venv\Scripts\activate
# Mac/Linux: source venv/bin/activate

# 运行程序
python src/hello_langchain.py

预期输出：

html 复制代码

🔧 步骤1：加载环境变量...
✅ API密钥加载成功（前10位：sk-123456789...）

🚀 步骤2：初始化ChatGPT模型...
✅ 模型初始化成功！

💬 步骤3：测试模型...
发送消息：'请用中文简单介绍一下人工智能'

🤖 ChatGPT回复：
--------------------------------------------------
人工智能（AI）是计算机科学的一个分支，旨在创建能够...
--------------------------------------------------

🎮 步骤4：开始交互式对话（输入 'quit' 退出）
--------------------------------------------------

🧑‍💻 你：你好！
⏳ 思考中...
✅ 完成！

🤖 AI：你好！我是AI助手，很高兴为你服务！

第四章：进阶功能 - 聊天机器人

4.1 创建聊天机器人

创建 src/chat_bot.py：

python 复制代码

#!/usr/bin/env python3
"""
LangChain聊天机器人
功能：带记忆的连续对话
"""

import os
import sys
from datetime import datetime
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate

class SimpleChatBot:
    """简单的聊天机器人"""
    
    def __init__(self, model_name="gpt-3.5-turbo"):
        """初始化聊天机器人"""
        print("🤖 初始化聊天机器人...")
        
        # 加载环境变量
        load_dotenv()
        self.api_key = os.getenv("OPENAI_API_KEY")
        
        if not self.api_key:
            print("❌ 错误：未设置OPENAI_API_KEY")
            sys.exit(1)
        
        # 初始化模型
        self.llm = ChatOpenAI(
            model=model_name,
            temperature=0.8,
            api_key=self.api_key
        )
        
        # 创建记忆系统
        self.memory = ConversationBufferMemory(
            memory_key="history",
            return_messages=True,
            max_token_limit=1000  # 限制记忆长度
        )
        
        # 自定义提示模板
        self.prompt_template = PromptTemplate(
            input_variables=["history", "input"],
            template="""你是一个友好的AI助手。请用中文回答用户的问题。
            
            当前对话历史：
            {history}
            
            用户：{input}
            AI助手："""
        )
        
        # 创建对话链
        self.conversation = ConversationChain(
            llm=self.llm,
            memory=self.memory,
            prompt=self.prompt_template,
            verbose=False  # 设为True可查看详细处理过程
        )
        
        print(f"✅ 聊天机器人初始化完成！使用模型：{model_name}")
        print("-" * 50)
    
    def chat(self, user_input):
        """处理用户输入"""
        try:
            response = self.conversation.predict(input=user_input)
            return response
        except Exception as e:
            return f"抱歉，我遇到了一个错误：{str(e)}"
    
    def clear_memory(self):
        """清除对话记忆"""
        self.memory.clear()
        print("🧹 对话记忆已清除")
    
    def get_memory_summary(self):
        """获取记忆摘要"""
        messages = self.memory.buffer
        if not messages:
            return "暂无对话记忆"
        
        summary = []
        for i, message in enumerate(messages, 1):
            role = "用户" if i % 2 == 1 else "AI"
            content = message.content[:50] + "..." if len(message.content) > 50 else message.content
            summary.append(f"{role}: {content}")
        
        return "\n".join(summary)

def main():
    """主函数"""
    print("=" * 60)
    print("🤖 LangChain聊天机器人 v1.0")
    print("=" * 60)
    
    # 创建机器人实例
    bot = SimpleChatBot()
    
    # 显示帮助信息
    print("""
可用命令：
  /help     - 显示帮助信息
  /clear    - 清除对话记忆
  /memory   - 显示当前记忆
  /model    - 显示当前模型
  /quit     - 退出程序
""")
    
    conversation_count = 0
    
    while True:
        try:
            # 获取用户输入
            user_input = input("\n🧑‍💻 你：").strip()
            
            # 处理特殊命令
            if user_input.lower() in ['/quit', '/exit', '/q']:
                print(f"\n👋 再见！本次共进行了 {conversation_count} 轮对话")
                break
            
            elif user_input.lower() == '/help':
                print("""
帮助菜单：
  直接输入问题 - 与AI对话
  /clear      - 重置对话记忆
  /memory     - 查看对话历史
  /model      - 显示AI模型信息
  /quit       - 退出程序
                """)
                continue
            
            elif user_input.lower() == '/clear':
                bot.clear_memory()
                continue
            
            elif user_input.lower() == '/memory':
                print("\n📝 对话记忆：")
                print("-" * 30)
                print(bot.get_memory_summary())
                print("-" * 30)
                continue
            
            elif user_input.lower() == '/model':
                print(f"\n🔧 当前模型：gpt-3.5-turbo")
                print(f"   记忆长度：{len(bot.memory.buffer)} 条消息")
                continue
            
            # 空输入检查
            if not user_input:
                print("⚠️  请输入内容")
                continue
            
            # 获取AI回复
            print("⏳ 思考中...", end="", flush=True)
            response = bot.chat(user_input)
            print("\r" + " " * 30, end="")  # 清除"思考中"提示
            print(f"\r🤖 AI：{response}")
            
            conversation_count += 1
            
        except KeyboardInterrupt:
            print("\n\n⚠️  用户中断，程序退出")
            break
        except Exception as e:
            print(f"\n❌ 错误：{e}")

if __name__ == "__main__":
    main()

4.2 运行聊天机器人

bash 复制代码

# 运行聊天机器人
python src/chat_bot.py

示例对话：

html 复制代码

🤖 LangChain聊天机器人 v1.0
============================================================

可用命令：
  /help     - 显示帮助信息
  /clear    - 清除对话记忆
  /memory   - 显示当前记忆
  /model    - 显示当前模型
  /quit     - 退出程序

🧑‍💻 你：你好，我是小明
🤖 AI：你好，小明！很高兴认识你。我是AI助手，有什么可以帮助你的吗？

🧑‍💻 你：你能记住我的名字吗？
🤖 AI：当然可以！我已经记住了你的名字是"小明"。在后续的对话中，我会记得你的名字。有什么其他问题或需要帮助的地方吗？

🧑‍💻 你：/memory
📝 对话记忆：
------------------------------
用户: 你好，我是小明
AI: 你好，小明！很高兴认识你。我是AI助手，有什么可以帮助你的吗？
用户: 你能记住我的名字吗？
AI: 当然可以！我已经记住了你的名字是"小明"。在后续的对话中，我会记得你的名字。有什么其他问题或需要帮助的地方吗？
------------------------------

第五章：LangChain核心概念实践

5.1 理解LangChain核心组件

创建 src/core_concepts.py：

python 复制代码

#!/usr/bin/env python3
"""
LangChain核心概念演示
1. Models (模型)
2. Prompts (提示)
3. Chains (链)
4. Memory (记忆)
5. Agents (代理)
"""

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
from langchain.schema import SystemMessage
from langchain.chains import LLMChain, SequentialChain
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import Tool

class LangChainCoreDemo:
    """LangChain核心概念演示"""
    
    def __init__(self):
        """初始化"""
        load_dotenv()
        self.api_key = os.getenv("OPENAI_API_KEY")
        
        # 1. 模型 (Models)
        self.llm = ChatOpenAI(
            model="gpt-3.5-turbo",
            temperature=0.7,
            api_key=self.api_key
        )
        
        print("✅ LangChain核心组件初始化完成")
        print("-" * 50)
    
    def demo_models(self):
        """演示：模型使用"""
        print("\n1️⃣ 模型演示 (Models)")
        print("-" * 30)
        
        # 直接调用模型
        response = self.llm.invoke("用一句话解释什么是机器学习")
        print(f"🤖 模型回复：{response.content}")
        
        # 批量调用
        messages = [
            "什么是深度学习？",
            "什么是神经网络？",
            "什么是强化学习？"
        ]
        
        print("\n📚 批量处理：")
        for i, msg in enumerate(messages, 1):
            response = self.llm.invoke(msg)
            print(f"{i}. {msg}")
            print(f"   回答：{response.content[:50]}...")
    
    def demo_prompts(self):
        """演示：提示模板"""
        print("\n2️⃣ 提示模板演示 (Prompts)")
        print("-" * 30)
        
        # 创建提示模板
        template = ChatPromptTemplate.from_messages([
            SystemMessage(content="你是一个资深{role}，用{language}回答问题。"),
            HumanMessagePromptTemplate.from_template("{question}")
        ])
        
        # 填充模板
        formatted_prompt = template.format_messages(
            role="机器学习工程师",
            language="中文",
            question="请解释Transformer模型的核心思想"
        )
        
        print("📝 生成的提示：")
        for msg in formatted_prompt:
            print(f"  {msg.type}: {msg.content}")
        
        # 使用模板生成回复
        response = self.llm.invoke(formatted_prompt)
        print(f"\n🤖 模型回复：\n{response.content[:200]}...")
    
    def demo_chains(self):
        """演示：链"""
        print("\n3️⃣ 链演示 (Chains)")
        print("-" * 30)
        
        # 创建简单的链
        from langchain.prompts import PromptTemplate
        
        # 链1：生成问题
        question_prompt = PromptTemplate(
            input_variables=["topic"],
            template="请生成一个关于{topic}的面试问题"
        )
        question_chain = LLMChain(
            llm=self.llm,
            prompt=question_prompt,
            output_key="question"
        )
        
        # 链2：生成答案
        answer_prompt = PromptTemplate(
            input_variables=["question"],
            template="请回答这个问题：{question}"
        )
        answer_chain = LLMChain(
            llm=self.llm,
            prompt=answer_prompt,
            output_key="answer"
        )
        
        # 组合链
        overall_chain = SequentialChain(
            chains=[question_chain, answer_chain],
            input_variables=["topic"],
            output_variables=["question", "answer"],
            verbose=False
        )
        
        # 运行链
        result = overall_chain({"topic": "人工智能伦理"})
        
        print(f"📌 主题：{result['topic']}")
        print(f"❓ 生成的问题：{result['question']}")
        print(f"✅ 生成的答案：{result['answer'][:200]}...")
    
    def demo_simple_agent(self):
        """演示：简单代理"""
        print("\n4️⃣ 代理演示 (Agents)")
        print("-" * 30)
        
        # 自定义工具
        def calculate_tool(expression: str) -> str:
            """计算数学表达式"""
            try:
                # 安全计算（实际项目中需要更严格的安全检查）
                import math
                
                # 只允许安全的数学操作
                safe_dict = {
                    'abs': abs, 'round': round, 'min': min, 'max': max,
                    'sum': sum, 'len': len, 'math': math
                }
                
                # 移除危险函数
                expression = expression.replace('__', '')  # 防止访问私有属性
                
                result = eval(expression, {"__builtins__": None}, safe_dict)
                return str(result)
            except Exception as e:
                return f"计算错误：{str(e)}"
        
        # 创建工具
        tools = [
            Tool(
                name="Calculator",
                func=calculate_tool,
                description="用于计算数学表达式，例如：'3 + 4 * 2'"
            )
        ]
        
        print("🛠️ 可用工具：")
        for tool in tools:
            print(f"  - {tool.name}: {tool.description}")
        
        # 测试工具
        print("\n🔧 测试工具：")
        test_expressions = ["3 + 4 * 2", "abs(-10)", "round(3.14159, 2)"]
        
        for expr in test_expressions:
            result = calculate_tool(expr)
            print(f"  {expr} = {result}")
        
        print("\n💡 提示：完整代理需要更复杂的设置，这里演示了工具的基本概念")

def main():
    """主函数"""
    print("=" * 60)
    print("🧠 LangChain核心概念演示")
    print("=" * 60)
    
    # 创建演示实例
    demo = LangChainCoreDemo()
    
    # 运行各个演示
    demo.demo_models()
    demo.demo_prompts()
    demo.demo_chains()
    demo.demo_simple_agent()
    
    print("\n" + "=" * 60)
    print("🎉 演示完成！")
    print("=" * 60)
    
    print("""
学习要点：
1. Models: 与LLM交互的核心
2. Prompts: 控制模型输出的模板
3. Chains: 组合多个组件的管道
4. Agents: 使用工具的高级系统
5. Memory: 维持对话状态
    """)

if __name__ == "__main__":
    main()

第六章：使用Jupyter Notebook交互学习

6.1 创建学习笔记本

创建 notebooks/langchain_tutorial.ipynb：

python 复制代码

# %% [markdown]
# # LangChain 入门教程
# 使用Jupyter Notebook学习LangChain

# %%
# 1. 安装和导入
import sys
import os

# 添加项目根目录到路径
sys.path.append('..')

from dotenv import load_dotenv
load_dotenv()

print("✅ 环境加载完成")

# %%
# 2. 基础模型调用
from langchain_openai import ChatOpenAI

# 初始化模型
llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.7
)

# %%
# 3. 第一个调用
response = llm.invoke("用一句话介绍Python语言")
print(response.content)

# %%
# 4. 带格式的提示
from langchain.prompts import ChatPromptTemplate

template = ChatPromptTemplate.from_messages([
    ("system", "你是一个{role}"),
    ("human", "{question}")
])

prompt = template.format_messages(
    role="Python编程专家",
    question="如何学习Python最快？"
)

# %%
response = llm.invoke(prompt)
print(response.content)

# %%
# 5. 创建对话链
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory

# 创建记忆
memory = ConversationBufferMemory()

# 创建链
chain = LLMChain(
    llm=llm,
    prompt=template,
    memory=memory,
    verbose=True  # 显示详细过程
)

# %%
# 6. 测试对话链
result1 = chain.invoke({
    "role": "编程导师",
    "question": "Python中的列表和元组有什么区别？"
})
print("回答:", result1['text'])

# %%
# 查看记忆
print("当前记忆:")
print(memory.buffer)

# %%
# 继续对话
result2 = chain.invoke({
    "role": "编程导师", 
    "question": "能举例说明吗？"
})
print("回答:", result2['text'])

# %%
# 7. 保存和加载记忆
# 保存记忆
memory_dict = memory.dict()
print("记忆内容:", memory_dict)

# %%
# 8. 使用不同的模型
# 尝试不同的temperature值
for temp in [0.1, 0.5, 0.9]:
    print(f"\n🌡️ Temperature = {temp}")
    creative_llm = ChatOpenAI(temperature=temp)
    response = creative_llm.invoke("写一个关于AI的短故事开头")
    print(f"结果: {response.content[:100]}...")

# %%
# 9. 批量处理
questions = [
    "什么是机器学习？",
    "什么是深度学习？",
    "什么是强化学习？"
]

print("📚 批量问答:")
for q in questions:
    response = llm.invoke(q)
    print(f"Q: {q}")
    print(f"A: {response.content}\n")

第七章：调试和常见问题解决

7.1 常见问题解决方案

创建 src/troubleshooting.py：

python 复制代码

#!/usr/bin/env python3
"""
LangChain常见问题解决指南
"""

import os
import sys

def check_environment():
    """检查环境配置"""
    print("🔍 环境检查")
    print("-" * 40)
    
    issues = []
    
    # 1. 检查Python版本
    python_version = sys.version_info
    if python_version.major < 3 or (python_version.major == 3 and python_version.minor < 10):
        issues.append(f"❌ Python版本过低：{sys.version}，需要3.10+")
    else:
        print(f"✅ Python版本：{sys.version}")
    
    # 2. 检查虚拟环境
    if not hasattr(sys, 'real_prefix') and not sys.prefix.endswith('venv'):
        issues.append("⚠️  未检测到虚拟环境，建议使用venv")
    else:
        print("✅ 虚拟环境已激活")
    
    # 3. 检查依赖包
    try:
        import langchain
        print(f"✅ LangChain版本：{langchain.__version__}")
    except ImportError:
        issues.append("❌ LangChain未安装")
    
    try:
        import openai
        print(f"✅ OpenAI库版本：{openai.__version__}")
    except ImportError:
        issues.append("❌ OpenAI库未安装")
    
    # 4. 检查API密钥
    from dotenv import load_dotenv
    load_dotenv()
    
    api_key = os.getenv("OPENAI_API_KEY")
    if not api_key:
        issues.append("❌ 未设置OPENAI_API_KEY")
    elif api_key.startswith("your-"):
        issues.append("❌ API密钥未正确配置（还是模板值）")
    else:
        print("✅ API密钥配置正确")
    
    # 5. 检查网络连接
    try:
        import urllib.request
        urllib.request.urlopen("https://api.openai.com", timeout=5)
        print("✅ 网络连接正常")
    except:
        issues.append("⚠️  网络连接可能有问题，无法访问OpenAI API")
    
    # 显示所有问题
    if issues:
        print("\n⚠️  发现的问题：")
        for issue in issues:
            print(f"  {issue}")
        
        print("\n🛠️  解决方案：")
        print("  1. 重新安装依赖：pip install -r requirements.txt")
        print("  2. 检查 .env 文件配置")
        print("  3. 检查网络代理设置")
        print("  4. 确保虚拟环境已激活")
    else:
        print("\n🎉 所有检查通过！可以正常运行程序。")

def common_errors():
    """常见错误及其解决方案"""
    print("\n🚨 常见错误及解决方案")
    print("-" * 40)
    
    errors = {
        "ModuleNotFoundError": [
            "原因：缺少依赖包",
            "解决：pip install langchain openai python-dotenv"
        ],
        "AuthenticationError": [
            "原因：API密钥无效或过期",
            "解决：检查 .env 文件，重新生成API密钥"
        ],
        "RateLimitError": [
            "原因：API调用频率超限",
            "解决：等待1分钟后重试，或升级API套餐"
        ],
        "ConnectionError": [
            "原因：网络连接问题",
            "解决：检查网络，设置代理（如有需要）"
        ],
        "ImportError": [
            "原因：版本不兼容",
            "解决：使用指定版本：pip install langchain==0.0.340"
        ]
    }
    
    for error, solutions in errors.items():
        print(f"\n❌ {error}:")
        for solution in solutions:
            print(f"  {solution}")

def test_api_connection():
    """测试API连接"""
    print("\n🧪 测试API连接")
    print("-" * 40)
    
    try:
        from openai import OpenAI
        from dotenv import load_dotenv
        load_dotenv()
        
        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
        
        # 测试调用
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": "Hello"}],
            max_tokens=10
        )
        
        print("✅ API连接成功！")
        print(f"   模型：{response.model}")
        print(f"   使用token数：{response.usage.total_tokens}")
        
    except Exception as e:
        print(f"❌ API连接失败：{type(e).__name__}: {str(e)}")
        
        if "rate limit" in str(e).lower():
            print("💡 提示：触发速率限制，请稍后重试")
        elif "auth" in str(e).lower():
            print("💡 提示：请检查API密钥是否正确")

def main():
    """主函数"""
    print("=" * 60)
    print("🛠️  LangChain调试助手")
    print("=" * 60)
    
    check_environment()
    common_errors()
    test_api_connection()
    
    print("\n" + "=" * 60)
    print("💡 如果仍有问题，可以尝试：")
    print("1. 创建全新的虚拟环境")
    print("2. 使用 requirements.txt 重新安装所有依赖")
    print("3. 检查Python版本是否为3.10+")
    print("4. 访问 https://platform.openai.com 检查API密钥状态")
    print("=" * 60)

if __name__ == "__main__":
    main()

第八章：项目实践 - 构建知识问答系统

8.1 简单的文档问答系统

创建 src/document_qa.py：

python 复制代码

#!/usr/bin/env python3
"""
文档问答系统
功能：读取文本文件并回答问题
"""

import os
import sys
from pathlib import Path
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader

class DocumentQASystem:
    """文档问答系统"""
    
    def __init__(self, model_name="gpt-3.5-turbo"):
        """初始化系统"""
        print("📚 初始化文档问答系统...")
        
        # 加载环境变量
        load_dotenv()
        api_key = os.getenv("OPENAI_API_KEY")
        
        if not api_key:
            print("❌ 错误：未设置OPENAI_API_KEY")
            sys.exit(1)
        
        # 初始化模型
        self.llm = ChatOpenAI(
            model=model_name,
            temperature=0,
            api_key=api_key
        )
        
        # 初始化嵌入模型
        self.embeddings = OpenAIEmbeddings(
            model="text-embedding-ada-002",
            api_key=api_key
        )
        
        self.vector_store = None
        self.qa_chain = None
        
        print("✅ 系统初始化完成")
    
    def load_documents(self, file_path: str):
        """加载文档"""
        print(f"\n📄 正在加载文档：{file_path}")
        
        if not os.path.exists(file_path):
            print(f"❌ 文件不存在：{file_path}")
            return False
        
        try:
            # 加载文档
            loader = TextLoader(file_path, encoding='utf-8')
            documents = loader.load()
            
            print(f"✅ 文档加载成功，共 {len(documents)} 个文档")
            
            # 分割文档
            text_splitter = RecursiveCharacterTextSplitter(
                chunk_size=500,      # 每块500字符
                chunk_overlap=50,    # 重叠50字符
                length_function=len
            )
            
            chunks = text_splitter.split_documents(documents)
            print(f"📝 分割为 {len(chunks)} 个文本块")
            
            # 创建向量存储
            self.vector_store = Chroma.from_documents(
                chunks,
                self.embeddings,
                persist_directory="./chroma_db"
            )
            
            print("💾 向量数据库创建完成")
            return True
            
        except Exception as e:
            print(f"❌ 加载文档失败：{e}")
            return False
    
    def create_qa_chain(self):
        """创建问答链"""
        if not self.vector_store:
            print("❌ 请先加载文档")
            return False
        
        print("\n🔗 创建问答链...")
        
        # 创建检索器
        retriever = self.vector_store.as_retriever(
            search_kwargs={"k": 3}  # 返回最相关的3个文档块
        )
        
        # 创建问答链
        self.qa_chain = RetrievalQA.from_chain_type(
            llm=self.llm,
            chain_type="stuff",  # 简单合并文档
            retriever=retriever,
            return_source_documents=True,
            verbose=False
        )
        
        print("✅ 问答链创建完成")
        return True
    
    def ask_question(self, question: str):
        """提问"""
        if not self.qa_chain:
            print("❌ 问答链未创建")
            return None
        
        try:
            print(f"\n❓ 问题：{question}")
            print("🔍 检索中...", end="", flush=True)
            
            result = self.qa_chain.invoke({"query": question})
            
            print("\r✅ 检索完成！" + " " * 20)
            
            # 显示答案
            print(f"\n💡 答案：{result['result']}")
            
            # 显示来源
            if result['source_documents']:
                print("\n📚 参考来源：")
                for i, doc in enumerate(result['source_documents'], 1):
                    source = doc.metadata.get('source', '未知')
                    content = doc.page_content[:100] + "..." if len(doc.page_content) > 100 else doc.page_content
                    print(f"{i}. [{source}] {content}")
            
            return result
            
        except Exception as e:
            print(f"\n❌ 回答问题失败：{e}")
            return None

def create_sample_document():
    """创建示例文档"""
    content = """
# 人工智能基础知识

## 什么是人工智能？
人工智能（AI）是计算机科学的一个分支，旨在创建能够执行通常需要人类智能的任务的机器。
这些任务包括学习、推理、问题解决、感知和语言理解。

## 机器学习
机器学习是人工智能的一个子领域，它使计算机能够在没有明确编程的情况下学习。
机器学习算法使用统计技术使计算机能够通过经验"学习"。

### 监督学习
在监督学习中，算法在标记的训练数据上训练，并根据该训练数据对新数据做出预测。

### 无监督学习
无监督学习在未标记的数据中查找模式，无需预先存在的标签。

### 深度学习
深度学习是机器学习的一个子集，使用称为神经网络的多层算法。
这些网络从大量数据中学习，可以识别复杂的模式。

## 自然语言处理（NLP）
自然语言处理是人工智能的一个分支，专注于计算机和人类语言之间的交互。
NLP技术用于聊天机器人、翻译系统和情感分析等应用。

## 计算机视觉
计算机视觉使计算机能够从数字图像、视频和其他视觉输入中获取高级理解。
应用包括面部识别、物体检测和图像分类。

## 人工智能伦理
随着AI技术的发展，伦理考虑变得越来越重要。
关键问题包括偏见、隐私、透明度和问责制。

## AI的未来
人工智能正在迅速发展，未来可能包括通用人工智能（AGI）和超级智能。
这些发展带来了巨大的机遇和挑战。
"""
    
    # 保存文档
    doc_path = "sample_ai_document.txt"
    with open(doc_path, "w", encoding="utf-8") as f:
        f.write(content)
    
    print(f"✅ 示例文档已创建：{doc_path}")
    return doc_path

def main():
    """主函数"""
    print("=" * 60)
    print("📚 文档问答系统")
    print("=" * 60)
    
    # 创建系统实例
    qa_system = DocumentQASystem()
    
    # 创建示例文档
    doc_path = create_sample_document()
    
    # 加载文档
    if not qa_system.load_documents(doc_path):
        return
    
    # 创建问答链
    if not qa_system.create_qa_chain():
        return
    
    # 示例问题
    questions = [
        "什么是人工智能？",
        "机器学习有哪些类型？",
        "什么是深度学习？",
        "人工智能有哪些伦理问题？"
    ]
    
    print("\n" + "=" * 60)
    print("🧪 测试问答系统")
    print("=" * 60)
    
    for question in questions:
        qa_system.ask_question(question)
        print("-" * 40)
    
    # 交互模式
    print("\n🎮 交互模式（输入 'quit' 退出）")
    print("-" * 40)
    
    while True:
        try:
            question = input("\n❓ 请输入问题：").strip()
            
            if question.lower() in ['quit', 'exit', 'q']:
                print("👋 再见！")
                break
            
            if not question:
                continue
            
            qa_system.ask_question(question)
            
        except KeyboardInterrupt:
            print("\n\n👋 用户中断，程序退出")
            break
        except Exception as e:
            print(f"\n❌ 错误：{e}")

if __name__ == "__main__":
    main()

第九章：部署与扩展

9.1 创建Web API接口

创建 src/web_api.py：

python 复制代码

#!/usr/bin/env python3
"""
LangChain Web API
功能：提供HTTP接口的AI服务
"""

import os
import json
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

# 加载环境变量
load_dotenv()

# 创建FastAPI应用
app = FastAPI(
    title="LangChain API",
    description="基于LangChain的AI服务API",
    version="1.0.0"
)

# 添加CORS中间件
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # 生产环境应限制来源
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# 数据模型
class Message(BaseModel):
    content: str
    temperature: float = 0.7
    max_tokens: int = 500

class ChatRequest(BaseModel):
    messages: list[Message]
    model: str = "gpt-3.5-turbo"

# 初始化模型
api_key = os.getenv("OPENAI_API_KEY")
if not api_key:
    raise ValueError("请设置OPENAI_API_KEY环境变量")

llm = ChatOpenAI(
    api_key=api_key,
    temperature=0.7
)

@app.get("/")
async def root():
    """根路径"""
    return {
        "message": "LangChain API服务运行中",
        "version": "1.0.0",
        "endpoints": [
            "/chat - 聊天接口",
            "/health - 健康检查",
            "/models - 可用模型列表"
        ]
    }

@app.get("/health")
async def health_check():
    """健康检查"""
    return {"status": "healthy", "service": "langchain-api"}

@app.get("/models")
async def list_models():
    """获取可用模型"""
    return {
        "models": [
            {"id": "gpt-3.5-turbo", "name": "GPT-3.5 Turbo"},
            {"id": "gpt-4", "name": "GPT-4"},
            {"id": "gpt-4-turbo", "name": "GPT-4 Turbo"}
        ]
    }

@app.post("/chat")
async def chat(request: ChatRequest):
    """聊天接口"""
    try:
        # 构建消息
        messages = []
        for msg in request.messages:
            if msg.content:
                messages.append({"role": "user", "content": msg.content})
        
        if not messages:
            raise HTTPException(status_code=400, detail="消息内容不能为空")
        
        # 调用模型
        response = llm.invoke(messages[0]["content"])
        
        return {
            "success": True,
            "response": response.content,
            "model": request.model,
            "usage": {
                "prompt_tokens": len(messages[0]["content"]),
                "completion_tokens": len(response.content)
            }
        }
    
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.post("/ask")
async def ask_question(message: Message):
    """简单问答接口"""
    try:
        # 设置模型参数
        llm.temperature = message.temperature
        llm.max_tokens = message.max_tokens
        
        # 调用模型
        response = llm.invoke(message.content)
        
        return {
            "success": True,
            "question": message.content,
            "answer": response.content,
            "temperature": message.temperature
        }
    
    except Exception as e:
        return {
            "success": False,
            "error": str(e)
        }

if __name__ == "__main__":
    import uvicorn
    
    print("🚀 启动LangChain Web API...")
    print(f"📡 服务地址：http://localhost:8000")
    print("📚 API文档：http://localhost:8000/docs")
    print("🔧 按 Ctrl+C 停止服务")
    
    uvicorn.run(
        "web_api:app",
        host="0.0.0.0",
        port=8000,
        reload=True  # 开发模式下自动重载
    )

第十章：项目总结与后续学习

10.1 项目总结

创建项目总结文档 README.md：

html 复制代码

# My First LangChain 项目

一个完整的LangChain入门项目，包含从基础到进阶的多个示例。

## 🚀 功能特性

- ✅ 基础模型调用
- ✅ 对话机器人（带记忆）
- ✅ LangChain核心概念演示
- ✅ 文档问答系统
- ✅ Web API接口
- ✅ Jupyter Notebook教程
- ✅ 调试工具

## 📁 项目结构

my-first-langchain/

├── .env # 环境变量配置

├── requirements.txt # Python依赖包

├── README.md # 项目说明

├── src/ # 源代码

│ ├── hello_langchain.py # 第一个程序

│ ├── chat_bot.py # 聊天机器人

│ ├── core_concepts.py # 核心概念演示

│ ├── document_qa.py # 文档问答系统

│ ├── web_api.py # Web API服务

│ └── troubleshooting.py # 调试工具

└── notebooks/ # Jupyter Notebook

└── langchain_tutorial.ipynb

html 复制代码

## 🛠️ 快速开始

### 1. 环境配置
```bash
# 克隆项目
git clone <repository-url>
cd my-first-langchain

# 创建虚拟环境
python -m venv venv

# 激活虚拟环境
# Windows: venv\Scripts\activate
# Mac/Linux: source venv/bin/activate

# 安装依赖
pip install -r requirements.txt

# 配置API密钥
cp .env.example .env
# 编辑 .env 文件，填入你的OpenAI API密钥

2. 运行示例

基础程序

bash 复制代码

python src/hello_langchain.py

聊天机器人

bash 复制代码

python src/chat_bot.py

Web API服务

bash 复制代码

python src/web_api.py
# 访问 http://localhost:8000/docs

学习路径

新手入门 (hello_langchain.py)
- 基础模型调用
- API密钥配置
- 简单对话
进阶功能 (chat_bot.py)
- 对话记忆
- 提示模板
- 链式调用
核心概念 (core_concepts.py)
- Models, Prompts, Chains
- Memory, Agents
项目实践 (document_qa.py)
- 文档加载
- 向量数据库
- 检索增强生成
部署应用 (web_api.py)
- RESTful API
- FastAPI框架
- 服务部署

调试帮助

bash 复制代码

# 运行调试工具
python src/troubleshooting.py

# 检查环境
python -c "import langchain; print(f'LangChain版本: {langchain.__version__}')"

学习建议

动手实践：每学一个概念，立即写代码验证
循序渐进：从简单程序开始，逐步增加复杂度
查阅文档：遇到问题先查官方文档
加入社区：参与LangChain社区讨论
持续学习：AI技术日新月异，保持学习

你已经完成了第一个LangChain程序的学习！接下来可以：

尝试修改代码，添加新功能
学习更多LangChain高级特性
构建自己的AI应用
参与开源项目

记住：学习AI开发的最好方式就是动手实践。现在，开始你的AI之旅吧！