Phi-3-mini-128k-instruct构建微信小程序智能客服：后端API开发全流程

最近不少做小程序的朋友都在琢磨，怎么给自家的小程序加个智能客服。人工客服成本高，响应慢，用户问个简单问题还得排队，体验确实不好。市面上现成的SaaS客服方案要么太贵，要么不够灵活，想自己搞又担心大模型成本太高、部署太复杂。

其实，现在有个挺不错的思路：用微软开源的Phi-3-mini-128k-instruct模型。这模型别看名字里带个“mini”，能力可不弱，关键是它对硬件要求不高，128K的超长上下文意味着它能记住很长的对话历史，特别适合客服这种需要“记住”用户之前说了什么的场景。更重要的是，它能在普通的云服务器甚至小程序云开发环境里跑起来，成本可控。

今天，我就带你走一遍完整的实战流程，看看怎么用Phi-3-mini作为“大脑”，从零开始搭建一个属于你自己的微信小程序智能客服后端。我们会聊到怎么部署模型服务、设计API、处理上下文，最后安全地接到微信小程序里。整个过程，我会尽量用大白话讲清楚，并提供能直接跑的代码。

1. 为什么选择Phi-3-mini-128k-instruct？

在动手之前，咱们先得搞清楚，为什么选这个模型，而不是别的。

首先，成本是硬道理。很多功能强大的大模型，比如GPT-4，效果是好，但API调用费用不菲，而且数据还得出境，有合规风险。自己部署像Llama 3这样的70亿参数模型，对服务器内存要求又很高（至少需要14GB以上），一个月光服务器费用就得好几百甚至上千。Phi-3-mini只有38亿参数，经过优化后，在4GB甚至更少内存的服务器上就能流畅运行，云服务器成本每月可能几十块钱就够了，如果用小程序云开发的云函数，成本更低。

其次，128K上下文是王牌。普通客服对话，用户可能会东拉西扯，问题一个接一个。如果模型只能记住最近几条消息，那它很可能变成“金鱼记忆”，回答得前言不搭后语。128K的上下文长度，意味着它能记住非常长的对话历史，保证回复的连贯性和准确性，用户体验会好很多。

再者，“instruct”指令微调是关键。这个版本是专门针对遵循人类指令进行过优化的。你告诉它“你现在是一个客服助手，要礼貌、专业、简洁”，它就能很好地扮演这个角色，生成符合要求的回复。这比用基础语言模型自己瞎猜要靠谱得多。

最后，部署简单。得益于像Ollama、vLLM这样的高效推理框架，现在部署一个开源模型变得非常容易。你不需要是深度学习专家，跟着步骤走，几条命令就能把服务跑起来。

所以，总结一下，选它就是因为：够用、便宜、好部署、能记住事儿。对于大多数小程序的客服场景，它提供的智能水平已经绰绰有余了。

2. 环境准备与模型服务部署

模型选好了，接下来就得给它找个“家”，让它能对外提供服务。这里我给你提供两种主流方案：自有服务器部署和小程序云开发部署。你可以根据自身的技术储备和预算来选择。

2.1 方案一：使用自有服务器（推荐，更灵活）

如果你有自己熟悉的云服务器（比如腾讯云、阿里云的轻量应用服务器），这种方式控制力最强，后续扩展也方便。

第一步：准备服务器 建议选择至少2核4GB内存的Linux服务器（Ubuntu 20.04/22.04）。4GB内存是运行Phi-3-mini的底线，如果想更流畅，建议上4核8GB。

登录服务器后，先更新系统并安装必要的依赖：

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-pip python3-venv git curl

第二步：使用Ollama一键部署（最简单） Ollama是目前部署本地大模型最省心的工具之一。

  1. 下载并安装Ollama：

    curl -fsSL https://ollama.com/install.sh | sh

  2. 拉取并运行Phi-3-mini模型：

    ollama run phi3:mini-128k-instruct

    第一次运行会自动下载模型（约2.3GB），需要一些时间。运行成功后，Ollama会在本地11434端口启动一个API服务。

  3. 测试一下API是否正常：

    curl http://localhost:11434/api/generate -d '{
  "model": "phi3:mini-128k-instruct",
  "prompt": "你好，请介绍一下你自己。",
  "stream": false
}'

    如果看到返回了一段JSON，里面包含模型的自我介绍，那就成功了。

第三步：配置API服务端（让外部能访问） Ollama默认只允许本地访问。我们需要一个简单的Python FastAPI应用作为中间层，一来可以对外提供更规范的API，二来可以增加安全控制和业务逻辑。

  1. 创建项目目录并安装依赖：

    mkdir phi3_customer_service && cd phi3_customer_service
python3 -m venv venv
source venv/bin/activate
pip install fastapi uvicorn httpx python-dotenv

  2. 创建一个main.py文件：

    from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
import httpx
import os
from typing import List, Optional
import time

app = FastAPI(title="Phi-3智能客服API")

# 允许跨域请求（方便本地小程序开发工具调试）
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # 生产环境请替换为具体的小程序域名
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# 配置Ollama服务地址
OLLAMA_API_URL = "http://localhost:11434/api/generate"

class ChatMessage(BaseModel):
    role: str  # "user" 或 "assistant"
    content: str

class ChatRequest(BaseModel):
    messages: List[ChatMessage]
    max_tokens: Optional[int] = 500
    temperature: Optional[float] = 0.7

@app.post("/v1/chat/completions")
async def chat_completion(request: ChatRequest):
    """
    处理聊天补全请求。
    将对话历史格式化为Phi-3能理解的Prompt，并调用Ollama API。
    """
    # 构建给Phi-3的Prompt。Phi-3-instruct模型使用特殊的对话格式。
    formatted_prompt = ""
    for msg in request.messages:
        if msg.role == "user":
            formatted_prompt += f"<|user|>\n{msg.content}<|end|>\n"
        elif msg.role == "assistant":
            formatted_prompt += f"<|assistant|>\n{msg.content}<|end|>\n"
    # 添加最后的助理提示，让模型开始生成回复
    formatted_prompt += "<|assistant|>\n"

    try:
        async with httpx.AsyncClient(timeout=30.0) as client:
            payload = {
                "model": "phi3:mini-128k-instruct",
                "prompt": formatted_prompt,
                "stream": False,
                "options": {
                    "num_predict": request.max_tokens,
                    "temperature": request.temperature,
                }
            }
            response = await client.post(OLLAMA_API_URL, json=payload)
            response.raise_for_status()
            result = response.json()

            # 从Ollama的响应中提取生成的回复
            generated_text = result.get("response", "").strip()
            # 清理可能残留的格式标记
            generated_text = generated_text.replace("<|end|>", "").strip()

            return {
                "id": f"chatcmpl-{int(time.time())}",
                "object": "chat.completion",
                "created": int(time.time()),
                "model": "phi3-mini-128k-instruct",
                "choices": [{
                    "index": 0,
                    "message": {
                        "role": "assistant",
                        "content": generated_text
                    },
                    "finish_reason": "stop"
                }]
            }
    except httpx.RequestError as e:
        raise HTTPException(status_code=500, detail=f"模型服务调用失败: {str(e)}")

@app.get("/health")
async def health_check():
    """健康检查端点"""
    return {"status": "healthy", "model": "phi3-mini-128k-instruct"}

  3. 使用PM2等工具让服务在后台运行：

    pip install pm2
pm2 start uvicorn --name phi3-api --interpreter python3 -- main:app --host 0.0.0.0 --port 8000
pm2 save
pm2 startup

    现在，你的模型API服务就在http://你的服务器IP:8000上运行了。可以通过访问/health端点测试。

2.2 方案二：使用小程序云开发（更省心）

如果你不想管理服务器，微信小程序云开发是个不错的选择。它提供了云函数和云托管服务。不过要注意，云函数有运行时长和内存限制，部署和加载2GB多的模型可能会比较慢甚至超时。更推荐使用云托管服务。

  1. 开通云托管：在小程序开发者后台开通云托管服务。

  2. 编写Dockerfile：云托管基于容器。我们需要创建一个Docker镜像，里面包含Ollama和我们的FastAPI应用。

    # Dockerfile
FROM ubuntu:22.04

RUN apt-get update && apt-get install -y curl python3-pip

# 安装Ollama
RUN curl -fsSL https://ollama.com/install.sh | sh

# 复制Python API应用
COPY . /app
WORKDIR /app

RUN pip3 install -r requirements.txt

# 启动脚本：先启动Ollama拉取模型，然后启动FastAPI
COPY start.sh /start.sh
RUN chmod +x /start.sh
CMD ["/start.sh"]

    start.sh脚本内容：

    #!/bin/bash
# 启动Ollama服务
ollama serve &
# 等待Ollama启动
sleep 5
# 拉取模型（如果尚未拉取）
ollama pull phi3:mini-128k-instruct &
# 等待模型拉取完成（首次部署需要较长时间）
sleep 30
# 启动FastAPI应用
uvicorn main:app --host 0.0.0.0 --port 80

  3. 构建并部署：在云托管控制台，关联你的代码仓库，配置构建规则，然后部署。云托管会自动分配一个可访问的域名给你。

两种方案各有优劣。自有服务器性能好、控制细，适合有一定运维能力的团队。云托管不用管服务器，集成方便，适合快速上线。我个人更倾向于方案一，后期优化和排查问题都更顺手。

3. 设计智能客服后端API

模型服务跑起来了，但它现在只是个“裸奔”的对话机器。一个真正的客服后端，还需要对话管理、上下文记忆、限流鉴权等一大堆功能。我们来设计几个核心的API。

我们的后端API除了调用模型，主要承担两个核心任务：管理对话上下文和对接微信消息。我建议设计以下主要端点：

  • POST /api/chat: 核心对话处理接口。
  • POST /api/wechat/callback: 微信服务器消息推送接口。
  • GET /api/session/{session_id}: 获取某个会话的历史记录（用于客服端查看）。
  • POST /api/feedback: 接收用户对某条回复的反馈（好评/差评），用于后续优化。

这里我们重点实现最核心的/api/chat接口。我们需要一个地方来存储用户的对话历史，这里为了简单演示，我们用内存字典，实际生产环境一定要用Redis或数据库。

# 在main.py中继续添加
from collections import defaultdict
import json

# 简单的内存存储，用于演示。生产环境请使用Redis。
conversation_store = defaultdict(list)
SESSION_TTL = 3600  # 会话过期时间1小时
MAX_HISTORY_LENGTH = 20  # 最大保存历史消息条数

class ChatRequestV2(BaseModel):
    session_id: str  # 会话ID，可以用用户OpenID或随机生成
    message: str     # 用户当前消息
    user_info: Optional[dict] = None  # 可选用户信息

@app.post("/api/chat")
async def handle_chat(request: ChatRequestV2):
    """
    智能客服聊天接口。
    1. 根据session_id获取历史对话。
    2. 将新消息加入历史。
    3. 调用模型服务生成回复。
    4. 将回复存入历史并返回。
    """
    session_id = request.session_id
    user_message = request.message

    # 1. 获取历史消息
    history = conversation_store.get(session_id, [])

    # 2. 添加用户新消息到历史
    history.append({"role": "user", "content": user_message})

    # 3. 调用模型服务（复用之前的函数，但传入格式化后的历史）
    chat_req = ChatRequest(messages=[ChatMessage(**msg) for msg in history[-10:]])  # 只发送最近10条作为上下文，避免过长
    try:
        model_response = await chat_completion(chat_req)
        assistant_reply = model_response["choices"][0]["message"]["content"]
    except Exception as e:
        assistant_reply = "抱歉，我暂时无法处理您的请求，请稍后再试。"
        # 这里可以加入日志记录错误

    # 4. 添加助理回复到历史
    history.append({"role": "assistant", "content": assistant_reply})

    # 5. 限制历史记录长度，并保存
    if len(history) > MAX_HISTORY_LENGTH:
        history = history[-MAX_HISTORY_LENGTH:]
    conversation_store[session_id] = history

    # 6. 返回结果
    return {
        "reply": assistant_reply,
        "session_id": session_id,
        "history_length": len(history)
    }

这个接口已经具备了基本的对话记忆能力。session_id是关键，微信小程序端可以用用户的openid或者自己生成的唯一ID来标识一个会话。这样，同一个用户在不同时间打开小程序，只要session_id不变，客服就能“记得”之前聊过什么。

4. 接入微信小程序客服消息

后端API准备好了，现在要让它能和微信小程序“说上话”。微信官方提供了客服消息接口，但这里我们采用更灵活、更可控的云函数/HTTPS回调方式。

核心逻辑是：当用户在小程序里发送消息时，小程序端不直接调用我们的模型API，而是先发给微信服务器，微信服务器再通过一个我们配置好的URL（就是我们的/api/wechat/callback）把消息推给我们。我们处理完，生成回复，再通过微信提供的客服消息接口发回给用户。

第一步：小程序端配置

  1. 在小程序管理后台 -> 功能 -> 客服消息里，启用“消息推送”。
  2. 填写服务器地址（URL），也就是你部署的后端API的/api/wechat/callback这个地址。
  3. 设置Token、EncodingAESKey等，用于验证消息来源。

第二步：实现回调接口 这个接口需要做两件事：验证微信服务器的配置请求，以及处理用户消息。

# 在main.py中添加
import hashlib
import xml.etree.ElementTree as ET
from fastapi import Request, Response

# 这里填写你在微信后台设置的Token
WECHAT_TOKEN = "your_wechat_token"

@app.get("/api/wechat/callback")
async def wechat_verify(signature: str, timestamp: str, nonce: str, echostr: str):
    """验证微信服务器配置"""
    tmp_list = sorted([WECHAT_TOKEN, timestamp, nonce])
    tmp_str = ''.join(tmp_list).encode('utf-8')
    hash_str = hashlib.sha1(tmp_str).hexdigest()
    if hash_str == signature:
        return Response(content=echostr)
    else:
        raise HTTPException(status_code=403, detail="验证失败")

@app.post("/api/wechat/callback")
async def wechat_message_callback(request: Request):
    """接收和处理微信服务器推送的用户消息"""
    body = await request.body()
    xml_data = body.decode('utf-8')
    root = ET.fromstring(xml_data)

    msg_type = root.find('MsgType').text
    from_user = root.find('FromUserName').text  # 用户的OpenID
    to_user = root.find('ToUserName').text
    content = root.find('Content').text if root.find('Content') is not None else ""

    # 只处理文本消息
    if msg_type != 'text':
        # 可以回复一个提示，或者忽略
        reply_xml = f"""
        <xml>
            <ToUserName><![CDATA[{from_user}]]></ToUserName>
            <FromUserName><![CDATA[{to_user}]]></FromUserName>
            <CreateTime>{int(time.time())}</CreateTime>
            <MsgType><![CDATA[text]]></MsgType>
            <Content><![CDATA[暂不支持此类型消息哦，请发送文本。]]></Content>
        </xml>
        """
        return Response(content=reply_xml, media_type="application/xml")

    # 调用我们的智能客服接口生成回复
    # 使用用户的OpenID作为session_id，保证同一用户对话连贯
    chat_payload = {
        "session_id": from_user,
        "message": content
    }
    async with httpx.AsyncClient() as client:
        try:
            # 注意：这里调用的是我们自己的 /api/chat 接口
            resp = await client.post("http://localhost:8000/api/chat", json=chat_payload, timeout=10)
            resp_data = resp.json()
            ai_reply = resp_data.get("reply", "思考中...")
        except Exception:
            ai_reply = "服务有点忙，请稍后再试。"

    # 构造XML格式的回复消息
    reply_xml = f"""
    <xml>
        <ToUserName><![CDATA[{from_user}]]></ToUserName>
        <FromUserName><![CDATA[{to_user}]]></FromUserName>
        <CreateTime>{int(time.time())}</CreateTime>
        <MsgType><![CDATA[text]]></MsgType>
        <Content><![CDATA[{ai_reply}]]></Content>
    </xml>
    """
    return Response(content=reply_xml, media_type="application/xml")

这样，整个消息通路就打通了：用户在小程序发消息 -> 微信服务器 -> 我们的后端 -> Phi-3模型生成回复 -> 我们的后端 -> 微信服务器 -> 用户小程序。全程都是我们自己的服务在处理，安全可控。

5. 关键优化技巧：安全与速度

一个能上线的服务，光有基础功能还不够，还得稳、快、安全。这里分享几个关键优化点。

1. 安全性优化

  • API密钥鉴权：给你的/api/chat接口加上API Key验证，防止被恶意调用。 
    API_KEYS = {"your_secret_key_here"}
@app.post("/api/chat")
async def handle_chat(request: ChatRequestV2, api_key: str = Header(None)):
    if api_key not in API_KEYS:
        raise HTTPException(status_code=403, detail="无效的API Key")
    # ... 原有逻辑
  • 输入检查与过滤：对用户输入的内容进行敏感词过滤，防止模型被诱导生成不当内容。可以接入一些内容安全API，或者在Prompt里加入严格的系统指令，例如：“你是一个专业的客服助手，必须拒绝回答任何与政治、色情、暴力等无关或有害的问题。”
  • 频率限制：使用像slowapi这样的库，对IP或session_id进行限流，防止恶意刷接口。 
    pip install slowapi

2. 响应速度优化

  • 模型量化：使用GGUF格式的量化模型（如Q4_K_M），可以在几乎不损失精度的情况下，显著减少内存占用和提高推理速度。Ollama支持直接拉取量化版phi3:mini-128k-instruct-q4_K_M。
  • 上下文窗口管理：虽然模型支持128K，但每次都将全部历史喂给它会极大拖慢速度。实践中，只选取最近10-20轮对话作为上下文，或者使用更高级的“摘要”技术，将长历史压缩成一段摘要再输入。
  • 异步与流式响应：对于较长的回复，可以考虑使用流式传输（Streaming），让用户边等边看，体验更好。Ollama和FastAPI都支持Server-Sent Events (SSE)。
  • 缓存：对于常见、重复的问题（如“营业时间？”“地址在哪？”），可以将答案缓存起来，直接返回，无需调用模型。

3. 提示词工程优化 客服的表现很大程度上取决于你如何“调教”它。在调用模型前，我们可以在Prompt里插入系统指令：

system_prompt = """你是一个专业、友好、乐于助人的电商客服助手。你的名字叫“小智”。
请遵守以下规则：
1. 用简洁明了的语言回答用户关于产品、订单、物流、售后的问题。
2. 如果不知道答案，请引导用户联系人工客服或提供相关查询渠道。
3. 保持礼貌，不要生成任何有害、偏见或无关的内容。
4. 如果用户的问题超出你的知识范围，请礼貌地表示无法回答。
当前对话历史：
"""
# 然后将 system_prompt + 格式化后的历史对话，一起传给模型。

一个好的系统提示词，能极大地提升回复的准确性和专业性。

6. 总结

走完这一整套流程，一个由Phi-3-mini-128k-instruct驱动的微信小程序智能客服后端就初具雏形了。我们从头到尾经历了：选型决策、模型部署、API设计、微信对接，再到安全与性能优化。

实际用下来，这套方案最大的优势就是性价比高和自主可控。模型效果对于常见的客服问答场景足够用了，成本却比调用商业API低一个数量级。所有的代码、数据、逻辑都掌握在自己手里，想怎么改就怎么改，想加什么功能就加什么功能。

当然，这只是一个起点。要让它真正成为一个生产可用的系统，你还需要考虑更多，比如：接入知识库让客服更专业、加入情感分析来应对用户投诉、设计一个后台来查看对话记录和优化模型、建立反馈闭环来持续训练模型等等。

但无论如何，你已经有了一个完全在自己掌控之中、能够理解长对话、成本低廉的智能客服“大脑”。接下来，就根据你小程序的实际情况，去打磨细节，让它更好地为用户服务吧。如果遇到问题，多看看模型的日志，调整一下提示词，或者优化一下上下文处理策略，效果会越来越好的。

获取更多AI镜像

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

# 微信小程序 # 后端开发
Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

cover

活动回顾｜支付的下一个十年圆满落幕，BlockSec 携手 Interlace 共探支付新秩序

avatar AI Agent技术社区
cover

AI Agent Context 压缩策略选型

avatar AI Agent技术社区
cover

从“能说会道”到“使命必达”：AI智能体如何真正进入企业工作流

avatar AI Agent技术社区