Phi-3 Mini部署教程：集成LangChain工具链实现多步骤逻辑推理流程

1. 引言：为什么选择Phi-3 Mini和LangChain？

如果你正在寻找一个既轻量又聪明的AI模型，并且希望它能像人类一样，通过调用工具、分步骤思考来完成复杂任务，那么这篇教程就是为你准备的。

今天我们要一起部署的，是微软出品的“小巨人”——Phi-3 Mini 128K Instruct模型。它只有38亿参数，体积小巧，但在逻辑推理、代码生成和数学解题上的表现，却足以让许多大它好几倍的模型刮目相看。更厉害的是，它支持长达12.8万tokens的上下文，这意味着你可以丢给它一整份长文档或复杂的代码，它都能理解。

但光有聪明的“大脑”还不够，我们还需要给它配上灵活的“双手”。这就是LangChain的用武之地。LangChain是一个强大的框架，它能将大语言模型（LLM）与各种外部工具（比如搜索引擎、计算器、数据库）连接起来，让模型学会“使用工具”，从而执行多步骤的、需要逻辑推理的任务。

想象一下这个场景：你问模型“北京今天天气怎么样，适合穿什么衣服去故宫？”。一个普通的模型可能只会根据训练数据泛泛而谈。但集成了LangChain的Phi-3 Mini可以这样做：

1. 推理：要回答这个问题，需要先获取北京的实时天气。
2. 调用工具：自动调用一个天气查询API，获取温度、湿度和天气状况。
3. 二次推理：结合故宫游览的常识（步行多、室内外温差），分析穿衣建议。
4. 整合回答：生成一个包含具体天气数据和个性化穿衣建议的完整回答。

本教程将手把手带你完成两件事：

1. 部署Phi-3 Mini：在本地或云服务器上快速启动这个高效的模型。
2. 集成LangChain：为模型装上“工具链”，让它具备多步骤推理和行动的能力。

无论你是AI开发者、技术爱好者，还是想为自己的项目添加一个智能助手，跟着步骤走，你都能在30分钟内搭建起这个强大的组合。

2. 环境准备与快速部署Phi-3 Mini

在开始集成高级功能前，我们先确保基础模型能跑起来。Phi-3 Mini对硬件要求友好，但正确的环境配置是关键。

2.1 系统与硬件要求

• 操作系统：Linux (Ubuntu 20.04+ 推荐), Windows (WSL2), macOS
• Python：3.9 或 3.10
• 内存：至少8GB RAM（运行模型本身）
• GPU（可选但强烈推荐）：
  • 最低：NVIDIA GPU with 8GB VRAM (如 RTX 3070)。
  • 推荐：NVIDIA GPU with 16GB+ VRAM (如 RTX 3090/4090) 以获得最佳体验。
  • 纯CPU：可以运行，但推理速度会慢很多，适合初步测试。

2.2 分步安装与部署

我们使用 transformers 库和 accelerate 来加载模型，这是最通用和高效的方式。

步骤1：创建并激活虚拟环境 这能避免包版本冲突。

# 创建虚拟环境
python -m venv phi3_env
# 激活环境 (Linux/macOS)
source phi3_env/bin/activate
# 激活环境 (Windows)
phi3_env\Scripts\activate

步骤2：安装核心依赖

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118  # 根据你的CUDA版本调整，此处以CUDA 11.8为例
pip install transformers accelerate sentencepiece

• torch：PyTorch深度学习框架。
• transformers：Hugging Face库，用于加载和运行模型。
• accelerate：优化模型加载，更好地利用GPU/CPU。
• sentencepiece：Phi-3模型使用的分词器。

步骤3：编写一个最简单的模型加载与对话脚本 创建一个名为 run_phi3_simple.py 的文件，内容如下：

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 指定模型路径（Hugging Face模型ID）
model_id = "microsoft/Phi-3-mini-128k-instruct"

# 加载分词器和模型
print("正在加载分词器...")
tokenizer = AutoTokenizer.from_pretrained(model_id)

print("正在加载模型...这可能需要几分钟，取决于你的网络和硬件...")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",  # 自动分配模型层到GPU/CPU
    torch_dtype=torch.float16,  # 使用半精度浮点数，节省显存
    trust_remote_code=True,
)

# 将模型设置为评估模式
model.eval()

# 准备对话
print("\n模型加载完成！开始对话吧（输入 'quit' 退出）")
while True:
    user_input = input("\n你: ")
    if user_input.lower() == 'quit':
        break

    # 构建符合Phi-3 Instruct格式的对话
    messages = [
        {"role": "user", "content": user_input},
    ]
    
    # 应用聊天模板
    inputs = tokenizer.apply_chat_template(
        messages,
        tokenize=True,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to(model.device)

    # 生成回复
    with torch.no_grad():  # 禁用梯度计算，加快推理速度
        outputs = model.generate(
            inputs,
            max_new_tokens=256,  # 生成的最大新token数
            do_sample=True,      # 启用采样，使输出更多样
            temperature=0.7,      # 控制随机性：越低越确定，越高越有创意
            top_p=0.9,           # 核采样参数，控制输出质量
        )

    # 解码并打印回复
    response = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
    print(f"Phi-3: {response}")

步骤4：运行脚本，进行首次对话 在终端中运行：

python run_phi3_simple.py

首次运行需要从Hugging Face下载模型（约8GB），请耐心等待。下载完成后，你就可以在命令行与Phi-3 Mini对话了！

至此，一个基础的Phi-3 Mini对话终端就部署成功了。接下来，我们要为它注入LangChain的灵魂。

3. 集成LangChain：为模型装备“工具链”

现在，我们的Phi-3 Mini已经可以流畅对话了。但它的能力还局限于“知识”和“推理”。LangChain能教会它“行动”——通过调用外部工具获取信息或执行操作。

3.1 理解LangChain的核心概念

你可以把LangChain想象成一个“大脑”与“世界”之间的协调中枢。

• LLM：大脑（这里是Phi-3 Mini），负责思考和规划。
• Tools：双手（各种API、函数），负责执行具体动作，如搜索、计算、查数据库。
• Agent：协调中枢，由LangChain提供。它理解大脑的指令，决定何时、调用哪个工具，并把工具的结果反馈给大脑进行下一步思考。

我们将创建一个 ReAct Agent。这是最经典的代理类型，它的思考过程是：Reason（思考）-> Act（行动）-> Observe（观察）-> Repeat（重复），直到解决问题。

3.2 安装LangChain并创建第一个工具

首先，安装必要的LangChain包：

pip install langchain langchain-community

让我们创建一个最简单的工具——一个能进行四则运算的计算器。

创建工具文件 custom_tools.py：

from langchain.tools import tool
import math

# 使用 @tool 装饰器将一个普通Python函数转换为LangChain可识别的工具
@tool
def calculator(expression: str) -> str:
    """
    执行一个数学表达式的计算。支持加(+)、减(-)、乘(*)、除(/)、乘方(**)、括号。
    
    Args:
        expression: 一个字符串形式的数学表达式，例如 "2 + 3 * (4 - 1)"。
    
    Returns:
        计算结果的字符串，或错误信息。
    """
    # 安全警告：在生产环境中，直接eval用户输入是危险的！
    # 这里仅用于演示。实际应用应使用更安全的解析库（如 ast.literal_eval 配合限制）。
    try:
        # 使用eval进行计算
        result = eval(expression, {"__builtins__": None}, {"math": math})
        return str(result)
    except Exception as e:
        return f"计算错误：{e}"

# 你可以继续定义更多工具，例如：
# @tool
# def get_weather(city: str) -> str:
#     """获取指定城市的天气信息。"""
#     # 这里调用真实的天气API
#     return f"{city}的天气是..."

3.3 构建LangChain Agent并连接Phi-3 Mini

现在，我们将Phi-3 Mini设置为LangChain的LLM，并让它使用我们刚创建的计算器工具。

创建主运行脚本 run_phi3_langchain.py：

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from langchain_huggingface import HuggingFacePipeline
from langchain.agents import initialize_agent, AgentType
from langchain.memory import ConversationBufferMemory
from custom_tools import calculator  # 导入我们自定义的工具
import torch

# 1. 加载Phi-3 Mini模型和分词器，并创建文本生成管道
model_id = "microsoft/Phi-3-mini-128k-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    device_map="auto",
    torch_dtype=torch.float16,
    trust_remote_code=True,
)

# 创建文本生成管道
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=512,
    do_sample=True,
    temperature=0.7,
    top_p=0.9,
)

# 2. 将Hugging Face管道包装成LangChain的LLM对象
llm = HuggingFacePipeline(pipeline=pipe)

# 3. 定义工具列表
tools = [calculator]  # 将计算器工具加入列表。未来可以加入更多，如 [calculator, get_weather, ...]

# 4. 初始化对话记忆（让Agent能记住上下文）
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# 5. 创建ReAct Agent
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION,  # 适合多轮对话的ReAct Agent
    verbose=True,  # 设置为True，可以看到Agent的完整思考过程（Reason和Act），非常有用！
    memory=memory,
    handle_parsing_errors=True,  # 优雅地处理解析错误
)

# 6. 运行Agent进行多轮对话
print("Phi-3 Mini + LangChain Agent 已启动！")
print("尝试问它需要计算的问题，例如：'计算一下2的10次方是多少？' 或 '125加上378再除以7等于多少？'")
print("输入 'quit' 退出。\n")

while True:
    user_input = input("你: ")
    if user_input.lower() == 'quit':
        break
    try:
        # 运行Agent
        response = agent.run(user_input)
        print(f"助手: {response}\n")
    except Exception as e:
        print(f"出错了: {e}\n")

运行这个脚本：

python run_phi3_langchain.py

当你提问时，如果设置了 verbose=True，你会在控制台看到类似下面的完整思考链，这正是多步骤推理的精髓：

你: 如果我有15个苹果，每天吃2个，一周后还剩几个？

> 进入新的AgentExecutor链...
思考：用户想知道一周后还剩多少苹果。我需要先计算一周吃掉的苹果总数，然后用总数减去。
行动：我需要使用计算器工具。一周有7天，每天吃2个，所以先计算7乘以2。
行动输入: {"expression": "7 * 2"}
观察: 14
思考：一周吃了14个苹果。现在从最初的15个苹果中减去14个。
行动输入: {"expression": "15 - 14"}
观察: 1
思考：计算结果是1。所以一周后还剩1个苹果。
最终答案: 一周后，你还剩下1个苹果。

> 链结束。
助手: 一周后，你还剩下1个苹果。

看，模型不仅回答了问题，还清晰地展示了它“先算总消耗，再算剩余”的两步推理和行动过程。

4. 实战：构建一个多工具协作的智能助手

只有一个计算器工具显然不够酷。让我们来增强它，创建一个能联网搜索并进行计算分析的智能助手。

4.1 添加新工具：DuckDuckGo搜索

我们将使用 langchain_community 中的工具来获取实时信息。

首先，安装额外依赖：

pip install duckduckgo-search

然后，更新我们的 custom_tools.py 文件，添加搜索工具：

from langchain.tools import tool
from langchain_community.tools import DuckDuckGoSearchRun
import math

# 原有的计算器工具
@tool
def calculator(expression: str) -> str:
    """执行一个数学表达式的计算。支持加(+)、减(-)、乘(*)、除(/)、乘方(**)、括号。"""
    try:
        result = eval(expression, {"__builtins__": None}, {"math": math})
        return str(result)
    except Exception as e:
        return f"计算错误：{e}"

# 初始化一个搜索工具实例
search_tool = DuckDuckGoSearchRun()

# 你也可以用@tool装饰器包装它，以提供自定义描述（可选但推荐）
@tool
def search_web(query: str) -> str:
    """
    使用DuckDuckGo在互联网上搜索最新信息。当你需要获取实时、事实性信息（如新闻、事件、定义、数据）时使用此工具。
    
    Args:
        query: 搜索查询关键词。
    """
    return search_tool.run(query)

4.2 创建更强大的智能助手脚本

更新主脚本 run_phi3_smart_agent.py，使用新的工具集：

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from langchain_huggingface import HuggingFacePipeline
from langchain.agents import initialize_agent, AgentType
from langchain.memory import ConversationBufferMemory
from custom_tools import calculator, search_web  # 导入计算器和搜索工具
import torch

# ... (模型和管道加载部分与之前相同，省略) ...
model_id = "microsoft/Phi-3-mini-128k-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto", torch_dtype=torch.float16, trust_remote_code=True)
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, max_new_tokens=512, do_sample=True, temperature=0.7, top_p=0.9)
llm = HuggingFacePipeline(pipeline=pipe)

# 定义工具列表（现在有两个工具了！）
tools = [calculator, search_web]

# 创建记忆和Agent
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION,
    verbose=True,  # 保持开启，观察思考过程
    memory=memory,
    handle_parsing_errors=True,
    max_iterations=5,  # 限制最大迭代次数，防止死循环
)

# 运行对话
print("=== 增强版 Phi-3 Mini 智能助手 ===")
print("现在我可以：1. 进行数学计算。 2. 联网搜索最新信息。")
print("试试问我：'搜索一下今天科技圈的头条新闻，然后总结成三点' 或 '特斯拉当前股价是多少美元？换算成人民币大概多少？'")
print("输入 'quit' 退出。\n")

while True:
    user_input = input("你: ")
    if user_input.lower() == 'quit':
        break
    try:
        response = agent.run(user_input)
        print(f"\n助手: {response}\n")
    except Exception as e:
        print(f"处理请求时出错: {e}\n")

4.3 体验多步骤推理流程

运行新的脚本，并尝试提出复杂问题：

python run_phi3_smart_agent.py

示例对话：

你: 特斯拉（TSLA）现在的股价是多少？如果我想买10股，大概需要多少人民币？

> 进入新的AgentExecutor链...
思考：用户问了两个问题：1. 特斯拉当前股价。2. 10股对应的人民币成本。股价是实时信息，需要搜索。人民币换算可能需要计算。
行动：我应该先搜索特斯拉的当前股价。
行动输入: {"query": "Tesla TSLA stock price today"}
观察: [搜索结果会显示实时股价，例如：Tesla Inc (TSLA) $175.21 ...]
思考：我找到了股价，大约是175.21美元一股。现在需要计算10股的总美元价格，然后换算成人民币。我需要知道当前美元对人民币的汇率。
行动：搜索当前美元兑人民币汇率。
行动输入: {"query": "USD to CNY exchange rate today"}
观察: [搜索结果会显示汇率，例如：1 US Dollar = 7.24 Chinese Yuan ...]
思考：我得到了汇率，大约是1美元兑7.24人民币。现在开始计算。
行动：首先计算10股特斯拉的总美元成本。
行动输入: {"expression": "175.21 * 10"}
观察: 1752.1
思考：10股需要1752.1美元。现在将其换算成人民币。
行动输入: {"expression": "1752.1 * 7.24"}
观察: 12685.204
思考：计算结果约为12685.2人民币。我需要整理信息并回答。
最终答案：根据最新信息，特斯拉(TSLA)股价约为175.21美元。购买10股总价约为1752.1美元。按当前汇率（1美元≈7.24人民币）计算，这大约需要12685元人民币。

> 链结束。
助手: 根据最新信息，特斯拉(TSLA)股价约为175.21美元...

看到了吗？模型自动完成了“搜索股价 -> 搜索汇率 -> 计算美元总价 -> 换算人民币”这一系列多步骤、跨工具的逻辑推理流程。这就是LangChain赋予Phi-3 Mini的“行动力”。

5. 总结与进阶探索

5.1 回顾与总结

通过这篇教程，我们完成了从零到一的跨越：

1. 成功部署了轻量级强者Phi-3 Mini：我们学会了如何在本地环境配置并运行这个参数虽小、能力却强的开源模型，体验了它的快速响应和强大推理能力。
2. 理解了LangChain的核心价值：我们不再把大模型看作一个封闭的知识库，而是通过LangChain将其升级为一个可以规划、使用工具的“智能体”（Agent）。
3. 实现了多步骤逻辑推理流程：我们亲手创建了计算器和搜索工具，并见证了Phi-3 Mini如何像人类一样，通过“思考-行动-观察”的循环（ReAct），调用不同工具来解决复杂问题。

这个组合的核心优势在于：

• 成本效益高：Phi-3 Mini部署成本低，响应快。
• 能力可扩展：通过LangChain，你可以轻松集成无数工具（数据库、API、自定义函数），无限扩展模型的能力边界。
• 过程透明可控：通过 verbose=True，你可以清晰看到模型的思考链，便于调试和信任。

5.2 下一步可以做什么？

你的智能助手现在只是一个起点，以下是几个进阶方向：

• 添加更多工具：集成天气API、日历API、邮件发送、文件读写等，打造你的个人全能助理。
• 使用更好的Agent类型：除了ReAct，尝试 Plan-and-Execute 代理，它更擅长处理需要长期规划的超复杂任务。
• 接入知识库（RAG）：使用LangChain的 Retrieval 模块，让模型能够读取你的私人文档、公司Wiki，实现基于专属知识的问答。
• 构建Web界面：使用Gradio或Streamlit，为你刚创建的智能助手打造一个像“森林晨曦实验室”一样美观的聊天界面。
• 优化性能：研究模型量化（如bitsandbytes）、使用更快的推理后端（如vLLM, TensorRT-LLM）来进一步提升速度。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。