【Agent从入门到实践】43 接口封装：将Agent封装为API服务，供其他系统调用

人工智能AI技术2026-01-29 20:16

文章目录

目前国内还是很缺AI人才的，希望更多人能真正加入到AI行业，共同促进行业进步。想要系统学习AI知识的朋友可以看看我的教程http://blog.csdn.net/jiangjunshow，教程通俗易懂，风趣幽默，从深度学习基础原理到各领域实战应用都有讲解。

本文章限时免费，整个专栏写完后将转为收费专栏，请勿转载

各位小伙伴，咱们的多Agent框架现在功能全、能打包、可部署，但说到底还是个"本地程序"------只能自己跑脚本或者在容器里执行，没法和其他系统联动。比如想做个AI写作小程序，想让公司的CRM系统调用Agent做数据分析，想让前端页面直接传参触发Agent任务，这些都需要把Agent封装成标准化的API服务。

API就像Agent的"对外窗口"，任何系统只要通过HTTP请求调用这个窗口，就能触发Agent执行任务、获取结果，不用关心Agent内部怎么运行。而Python生态里做API封装，FastAPI是2025年的绝对首选------轻量、高效、支持异步、自动生成接口文档，还能轻松实现高并发，和咱们的异步多Agent框架完美适配。

这篇咱们就全程实战，从接口设计原则 到代码实现 ，再到高并发优化、身份验证、异常统一处理 ，最后做接口测试和Docker集成，所有代码都是可直接复制的生产级版本，封装完的API满足：参数规范、响应统一、安全可靠、支持高并发，能被Java、PHP、前端、小程序等任何系统调用，还能无缝对接之前的Docker镜像，一键部署成可对外提供服务的API服务～

一、先搞懂：Agent API接口设计核心原则

封装API不是随便写个接口就行，要让其他系统能"轻松调用、放心使用"，必须遵循4个核心原则，这也是工业界的标准规范，新手照着做准没错：

  1. 参数标准化：用固定的格式定义请求参数，明确必传/可选、参数类型，避免调用方传参混乱
  2. 响应统一化：所有接口返回相同的格式，包含状态码、提示信息、数据体，调用方不用单独处理不同的返回结果
  3. 异常全局化：所有异常都统一捕获，返回标准化的错误响应，不会让调用方收到莫名其妙的报错
  4. 接口文档化：自动生成交互式接口文档，调用方不用看代码，直接在网页上测试接口、查看参数说明

同时结合咱们的多Agent框架，接口要实现两个核心功能：单任务执行 （最常用）、服务健康检查（运维必备），后续可根据需求扩展批量任务、任务查询等接口。

二、实战前置：准备工作（3分钟搞定）

封装前先做好两个准备，保证后续代码能无缝衔接之前的框架，不用改原有逻辑：

1. 确认框架目录结构

保持和之前一致的目录结构，新增api/目录存放API相关代码，最终结构如下：

复制代码 
multi-agent-framework/  # 框架根目录
├── api/                 # 新增API目录
│   └── api_server.py    # API核心封装代码（核心文件）
├── agents/              # Agent目录
├── framework/           # 框架核心目录
├── tools/               # 工具目录
├── .env                 # 环境变量（存密钥、API端口等）
├── requirements.txt     # 依赖清单
├── Dockerfile           # Docker打包配置
└── .dockerignore        # 忽略文件

2. 完善依赖清单

确保requirements.txt包含FastAPI和运行依赖，2025年最新版本如下（已包含之前的所有依赖，直接替换即可）：

txt 复制代码 
# requirements.txt 含API封装所有依赖
python>=3.8,<3.12
langchain==0.2.15
langchain-chroma==0.1.5
langchain-openai==0.2.0
sentence-transformers==3.1.0
chromadb==0.5.11
tenacity==8.5.0
psutil==6.0.0
# API核心依赖
fastapi==0.112.0
uvicorn==0.30.6  # ASGI服务器，支持高并发
python-multipart==0.0.9  # 支持表单提交（可选）
pyjwt==2.8.0     # JWT身份验证（安全必备）
python-dotenv==1.0.1
numpy==1.26.4
requests==2.32.3
pydantic==2.8.2

新增的pyjwt用于接口身份验证，避免API被恶意调用，uvicorn是FastAPI的官方运行服务器，支持异步和高并发。

三、核心实战1：基础API封装（核心功能实现）

咱们先实现最核心的健康检查接口 和Agent单任务执行接口 ，用Pydantic做参数校验，实现请求/响应的标准化，代码全部写在api/api_server.py中，全程不修改原有框架代码，做到低耦合、高复用。

1. 完整基础API封装代码

直接复制以下代码到api/api_server.py，每一行都有详细注释，新手也能看懂：

python 复制代码 
# api/api_server.py 多Agent框架API核心封装
from fastapi import FastAPI, Body, HTTPException, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field
import uvicorn
import logging
import os
import dotenv
from datetime import datetime
# 导入原有框架核心（不修改任何原有代码）
from framework.core import MultiAgentFramework
from agents.master_agent import MasterAgent
from agents.slave_agents import SearchSlaveAgent, CodeSlaveAgent, WriteSlaveAgent

# ===================== 初始化配置 =====================
# 加载环境变量（从根目录.env文件读取）
dotenv.load_dotenv(dotenv_path=os.path.join(os.path.dirname(os.path.dirname(__file__)), ".env"))
# 初始化FastAPI应用
app = FastAPI(
    title="多Agent框架API服务",
    description="2025优化版多Agent框架标准化API，支持多协作模式，可被任意系统调用",
    version="1.0.0",
    docs_url="/docs",  # 交互式接口文档地址
    redoc_url="/redoc" # 静态接口文档地址
)
# 配置日志（同时输出到控制台和文件）
os.makedirs("logs", exist_ok=True)
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    handlers=[
        logging.FileHandler(f"logs/agent_api_{datetime.now().strftime('%Y%m%d')}.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger("agent_api")
# 全局初始化Agent框架（只初始化一次，提升接口响应速度，避免重复创建）
MASTER_AGENT = MasterAgent()
SLAVE_AGENTS = [SearchSlaveAgent(), CodeSlaveAgent(), WriteSlaveAgent()]
AGENT_FRAMEWORK = MultiAgentFramework(
    collab_mode="parallel",  # 默认并行模式，可由请求参数覆盖
    agents={"master": MASTER_AGENT, "slaves": SLAVE_AGENTS}
)
# 从环境变量读取配置
API_PORT = int(os.getenv("API_PORT", 8000))
API_HOST = os.getenv("API_HOST", "0.0.0.0")

# ===================== 数据模型（参数/响应标准化） =====================
# 定义请求体模型：校验用户任务参数，明确必传/可选、类型、说明
class AgentTaskRequest(BaseModel):
    user_task: str = Field(..., min_length=5, description="Agent执行的任务描述，最少5个字符，例：写一篇AI发展趋势文章")
    collab_mode: str = Field(default="parallel", description="Agent协作模式，可选：parallel/master_slave/division/competition")

# 定义统一响应模型：所有接口返回相同格式，方便调用方解析
class BaseResponse(BaseModel):
    code: int = Field(..., description="状态码：200成功，500服务器错误，400参数错误，401未授权")
    msg: str = Field(..., description="提示信息：成功/错误原因")
    data: any = Field(None, description="返回数据体：成功时为任务结果，失败时为None")
    request_id: str = Field(..., description="请求ID：用于问题排查")
    timestamp: str = Field(..., description="响应时间：YYYY-MM-DD HH:MM:SS")

# ===================== 全局异常处理（统一错误响应） =====================
@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
    """全局异常捕获，返回标准化错误响应"""
    # 生成请求ID（简单实现，生产级可改用UUID）
    request_id = f"{datetime.now().timestamp() * 1000:.0f}"
    # 记录异常日志（包含请求ID，方便排查）
    logger.error(f"请求ID：{request_id} | 全局异常：{str(exc)}", exc_info=True)
    # 返回标准化响应
    return JSONResponse(
        status_code=200,  # 统一返回200，用code字段标识实际状态
        content=BaseResponse(
            code=500,
            msg=f"服务器内部错误：{str(exc)[:100]}",  # 截取错误信息，避免过长
            data=None,
            request_id=request_id,
            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        ).dict()
    )

# ===================== 核心接口实现 =====================
@app.get("/health", summary="服务健康检查", response_model=BaseResponse)
async def health_check(request: Request):
    """
    健康检查接口：运维必备，用于监控服务是否正常运行
    调用方可定时调用，返回200则说明服务正常
    """
    request_id = f"{datetime.now().timestamp() * 1000:.0f}"
    try:
        # 简单检查：框架是否初始化成功
        if AGENT_FRAMEWORK:
            logger.info(f"请求ID：{request_id} | 健康检查成功")
            return BaseResponse(
                code=200,
                msg="多Agent框架API服务运行正常",
                data={
                    "service_status": "running",
                    "api_version": "1.0.0",
                    "framework_mode": "async-parallel"
                },
                request_id=request_id,
                timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            )
        else:
            raise Exception("Agent框架初始化失败")
    except Exception as e:
        logger.error(f"请求ID：{request_id} | 健康检查失败：{str(e)}")
        return BaseResponse(
            code=500,
            msg=f"健康检查失败：{str(e)}",
            data=None,
            request_id=request_id,
            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        )

@app.post("/api/v1/agent/run", summary="Agent单任务执行", response_model=BaseResponse)
async def run_agent(request: Request, task: AgentTaskRequest = Body(...)):
    """
    Agent核心执行接口：接收用户任务，触发Agent执行，返回结果
    支持自定义协作模式，是最常用的核心接口
    """
    # 生成唯一请求ID（用于日志排查和调用方追溯）
    request_id = f"{datetime.now().timestamp() * 1000:.0f}"
    try:
        # 日志记录：接收请求（包含请求ID和参数）
        logger.info(f"请求ID：{request_id} | 接收Agent任务 | 模式：{task.collab_mode} | 任务：{task.user_task[:50]}...")
        # 校验协作模式是否合法
        valid_modes = ["parallel", "master_slave", "division", "competition"]
        if task.collab_mode not in valid_modes:
            raise HTTPException(status_code=400, detail=f"非法协作模式，可选：{valid_modes}")
        # 执行Agent任务（复用原有框架run方法，不修改任何逻辑）
        frame = MultiAgentFramework(collab_mode=task.collab_mode, agents={"master": MASTER_AGENT, "slaves": SLAVE_AGENTS})
        task_result = frame.run(task.user_task)
        # 日志记录：任务执行成功
        logger.info(f"请求ID：{request_id} | Agent任务执行成功")
        # 返回标准化响应
        return BaseResponse(
            code=200,
            msg="Agent任务执行成功",
            data={
                "collab_mode": task.collab_mode,
                "user_task": task.user_task,
                "task_result": task_result,
                "request_id": request_id
            },
            request_id=request_id,
            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        )
    except HTTPException as e:
        # 处理参数错误等主动抛出的异常
        logger.warning(f"请求ID：{request_id} | 任务执行失败：{e.detail}")
        return BaseResponse(
            code=400,
            msg=f"参数错误：{e.detail}",
            data=None,
            request_id=request_id,
            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        )

# ===================== 启动服务 =====================
if __name__ == "__main__":
    # 用uvicorn启动服务，支持异步、高并发，生产级标配
    uvicorn.run(
        app="api.api_server:app",
        host=API_HOST,
        port=API_PORT,
        workers=4,  # 工作进程数，建议设为CPU核心数（生产级可动态配置）
        reload=False,  # 生产环境关闭自动重载，开发环境可设为True
        log_level="info"
    )

2. 核心代码亮点解析

这段代码是生产级标准，不是简单的demo，核心亮点如下：

  • 低耦合：完全不修改原有框架代码，只做导入和调用，后续框架升级不影响API
  • 全局初始化：Agent框架只初始化一次，避免每次请求都创建实例，提升响应速度
  • 参数强校验 ：用Pydantic的AgentTaskRequest做参数校验，自动判断必传、长度、类型，不用手动写判断
  • 响应完全统一 ：所有接口都返回BaseResponse格式，调用方只需按固定结构解析，不用处理多种返回
  • 全局异常捕获：不管是框架内部错误、参数错误还是网络错误，都返回标准化响应，不会让调用方收到500/404等原生报错
  • 请求ID追踪：每个请求生成唯一ID，日志和响应都包含，出问题能快速定位
  • 自动文档：FastAPI根据代码注释自动生成交互式文档，不用手动写文档

3. 配置环境变量（.env）

在框架根目录的.env文件中新增API相关配置，避免硬编码，方便Docker部署时动态修改：

env 复制代码 
# .env 文件
# OpenAI密钥（原有）
OPENAI_API_KEY=sk-xxx
# API服务配置（新增）
API_HOST=0.0.0.0
API_PORT=8000
# JWT密钥（后续身份验证用，随便写一串随机字符）
JWT_SECRET_KEY=your_random_jwt_secret_key_2025
JWT_ALGORITHM=HS256
JWT_EXPIRE_MINUTES=120

四、核心实战2：API安全加固（身份验证，避免恶意调用）

封装的API如果对外提供服务，必须做身份验证 ，否则任何人都能调用，不仅会泄露服务，还会被恶意请求占满资源。咱们用2025年最主流的JWT（JSON Web Token） 实现身份验证，给API加一道"访问密码"，只有携带有效Token的请求才能调用核心接口。

1. 新增JWT工具类（api/jwt_tools.py）

在api/目录下创建JWT工具类，封装Token的生成和验证逻辑，代码如下：

python 复制代码 
# api/jwt_tools.py JWT身份验证工具类
import jwt
import os
import dotenv
from datetime import datetime, timedelta
from fastapi import HTTPException, Header

# 加载环境变量
dotenv.load_dotenv()
SECRET_KEY = os.getenv("JWT_SECRET_KEY")
ALGORITHM = os.getenv("JWT_ALGORITHM")
EXPIRE_MINUTES = int(os.getenv("JWT_EXPIRE_MINUTES", 120))

def create_access_token(user_id: str, roles: list = ["user"]):
    """生成JWT Token"""
    if not SECRET_KEY:
        raise Exception("JWT_SECRET_KEY未配置")
    # 定义Token过期时间
    expire = datetime.utcnow() + timedelta(minutes=EXPIRE_MINUTES)
    # 定义Token载荷（存储用户信息，不要存敏感数据）
    to_encode = {
        "exp": expire,
        "iat": datetime.utcnow(),
        "user_id": user_id,
        "roles": roles
    }
    # 生成Token
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

def verify_access_token(token: str = Header(None, alias="Authorization")):
    """验证JWT Token，作为FastAPI依赖项使用"""
    # 检查Token是否存在
    if not token:
        raise HTTPException(status_code=401, detail="未提供身份验证Token")
    # 处理Token格式：Bearer <token>
    if not token.startswith("Bearer "):
        raise HTTPException(status_code=401, detail="Token格式错误，正确格式：Bearer <token>")
    token = token[7:]
    try:
        # 验证Token并解析载荷
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        user_id: str = payload.get("user_id")
        roles: list = payload.get("roles")
        if user_id is None:
            raise HTTPException(status_code=401, detail="Token无效，用户ID不存在")
        return {"user_id": user_id, "roles": roles}
    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="Token已过期")
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Token无效")

2. 给核心接口添加身份验证

修改api/api_server.py，导入JWT工具类，给/api/v1/agent/run核心接口添加身份验证，健康检查接口可不用验证（方便运维监控）：

python 复制代码 
# 在api/api_server.py顶部新增导入
from api.jwt_tools import verify_access_token
from fastapi import Depends

# 修改run_agent接口，添加Depends(verify_access_token)
@app.post("/api/v1/agent/run", summary="Agent单任务执行", response_model=BaseResponse)
async def run_agent(
    request: Request,
    task: AgentTaskRequest = Body(...),
    user_info: dict = Depends(verify_access_token)  # 新增：身份验证依赖
):
    """
    Agent核心执行接口：接收用户任务，触发Agent执行，返回结果
    支持自定义协作模式，是最常用的核心接口
    需携带有效JWT Token才能调用
    """
    request_id = f"{datetime.now().timestamp() * 1000:.0f}"
    try:
        # 日志记录：添加用户信息
        logger.info(f"请求ID：{request_id} | 用户ID：{user_info['user_id']} | 接收Agent任务...")
        # 原有逻辑不变...
        frame = MultiAgentFramework(collab_mode=task.collab_mode, agents={"master": MASTER_AGENT, "slaves": SLAVE_AGENTS})
        task_result = frame.run(task.user_task)
        logger.info(f"请求ID：{request_id} | 用户ID：{user_info['user_id']} | Agent任务执行成功")
        # 返回结果不变...
    except Exception as e:
        # 异常处理不变...

3. 新增Token生成接口（供调用方获取Token）

在api/api_server.py中新增Token生成接口，调用方先通过该接口获取Token，再用Token调用核心接口（生产级可对接用户系统，这里做简单实现）：

python 复制代码 
# 在api/api_server.py中导入create_access_token
from api.jwt_tools import create_access_token, verify_access_token

# 新增Token生成接口（可根据实际业务对接用户登录逻辑）
@app.post("/api/v1/token/get", summary="获取访问Token", response_model=BaseResponse)
async def get_token(request: Request, user_id: str = Body(..., description="用户ID")):
    """
    获取JWT Token接口：调用方先调用此接口获取Token，再用Token调用核心接口
    生产级需对接用户登录系统，验证账号密码后再生成Token
    """
    request_id = f"{datetime.now().timestamp() * 1000:.0f}"
    try:
        # 生成Token（简单实现，生产级需验证用户身份）
        token = create_access_token(user_id=user_id, roles=["user"])
        logger.info(f"请求ID：{request_id} | 用户ID：{user_id} | Token生成成功")
        return BaseResponse(
            code=200,
            msg="Token生成成功",
            data={
                "access_token": token,
                "token_type": "Bearer",
                "expire_minutes": int(os.getenv("JWT_EXPIRE_MINUTES", 120))
            },
            request_id=request_id,
            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        )
    except Exception as e:
        logger.error(f"请求ID：{request_id} | Token生成失败：{str(e)}")
        return BaseResponse(
            code=500,
            msg=f"Token生成失败：{str(e)}",
            data=None,
            request_id=request_id,
            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        )

五、核心实战3：API高并发优化（生产级必备）

咱们的Agent框架是异步的，FastAPI也支持异步，再配合uvicorn的多进程配置，能大幅提升API的高并发处理能力，这里做3个关键优化，让API能扛住千级并发：

1. uvicorn多进程+异步配置（已实现）

代码中启动uvicorn时设置workers=4，这是生产级标配，workers数建议设为CPU核心数的2倍，比如4核CPU设为8，8核设为16，可通过环境变量动态配置：

python 复制代码 
# 从环境变量读取workers数，默认4
WORKERS = int(os.getenv("API_WORKERS", 4))
# 启动时修改
uvicorn.run(
    app="api.api_server:app",
    host=API_HOST,
    port=API_PORT,
    workers=WORKERS,  # 多进程
    reload=False,
    log_level="info"
)

同时在.env中新增API_WORKERS=4。

2. 框架实例池（可选，高并发进阶）

如果请求量极大，可实现Agent框架实例池，避免每次请求创建实例的开销，用concurrent.futures实现简单的实例池，核心思路：提前创建多个框架实例，请求过来时取一个，用完放回。

3. 禁用开发模式（生产级必做）

开发环境的reload=True会大幅降低性能，生产环境必须设为False，代码中已实现，Docker部署时也会保持关闭。

六、实战4：本地测试API服务

代码写完后，先本地测试API是否能正常运行，两步搞定：

1. 启动API服务

在框架根目录打开终端，执行以下命令启动服务：

bash 复制代码 
# 直接运行API代码
python api/api_server.py

启动成功后，终端会显示：Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)。

2. 测试接口（自动文档页面）

打开浏览器，访问http://127.0.0.1:8000/docs，进入FastAPI自动生成的交互式接口文档，所有接口都能在这里可视化测试：

  1. 测试Token生成 ：点击/api/v1/token/get→Try it out→输入user_id→Execute，会返回包含access_token的结果。
  2. 测试核心接口 ：点击/api/v1/agent/run→Try it out→先在Authorization框中输入Bearer <生成的token>→再输入user_task和collab_mode→Execute，等待几秒后会返回Agent执行的结果。
  3. 测试健康检查 ：点击/health→Execute，直接返回服务正常的结果。

测试通过后，说明API封装成功，能正常接收请求、触发Agent执行、返回结果。

七、实战5：对接Docker，实现API服务一键部署

咱们的API服务要能和之前的Docker镜像无缝对接，只需修改根目录的Dockerfile，把启动命令改为运行API服务即可，不用改其他配置，实现一键部署成可对外提供服务的API容器。

修改Dockerfile启动命令

打开根目录的Dockerfile，将最后一行的启动命令改为运行API服务，同时确保工作目录和Python路径正确：

dockerfile 复制代码 
# Dockerfile 最后一行修改为
CMD ["python", "-m", "api.api_server"]

关键说明 ：用python -m api.api_server启动，而不是python api/api_server.py，这样能保证在Docker容器中正确识别Python包路径，避免导入错误。

重新构建并运行Docker镜像

在框架根目录执行以下命令，重新构建Docker镜像并运行，实现API服务的一键部署：

bash 复制代码 
# 重新构建镜像（标签改为api-v1.0）
docker build -t multi-agent-framework:api-v1.0 .

# 生产级运行API容器（后台运行+端口映射+数据挂载+自动重启）
docker run -d \
  --name agent-api-service \
  --restart=always \
  -p 8000:8000 \
  -v $(pwd)/data:/app/data \
  -v $(pwd)/logs:/app/logs \
  -e OPENAI_API_KEY="sk-xxx" \
  multi-agent-framework:api-v1.0

运行成功后，其他系统就能通过http://你的服务器IP:8000调用API服务了，和本地测试的方式完全一致。

八、实战6：其他系统调用示例（多语言/端）

封装好的API是标准化的RESTful API，支持GET/POST请求，任何系统都能轻松调用，这里给出Python、Java、前端Axios、小程序 的简单调用示例，核心步骤都是：获取Token→携带Token调用核心接口。

1. Python调用示例（requests）

python 复制代码 
import requests
import json

# 配置API地址
API_BASE_URL = "http://你的服务器IP:8000"
# 1. 获取Token
token_response = requests.post(
    f"{API_BASE_URL}/api/v1/token/get",
    json={"user_id": "test_user_001"}
)
token = token_response.json()["data"]["access_token"]
# 2. 携带Token调用核心接口
headers = {"Authorization": f"Bearer {token}"}
task_response = requests.post(
    f"{API_BASE_URL}/api/v1/agent/run",
    headers=headers,
    json={
        "user_task": "写一篇2025年多Agent框架技术发展趋势的短文",
        "collab_mode": "parallel"
    }
)
# 解析结果
result = task_response.json()
if result["code"] == 200:
    print("Agent执行结果：", result["data"]["task_result"])
else:
    print("执行失败：", result["msg"])

2. 前端Axios调用示例

javascript 复制代码 
import axios from 'axios';

const API_BASE_URL = 'http://你的服务器IP:8000';
// 1. 获取Token
axios.post(`${API_BASE_URL}/api/v1/token/get`, { user_id: 'test_user_001' })
  .then(res => {
    const token = res.data.data.access_token;
    // 2. 调用核心接口
    return axios.post(
      `${API_BASE_URL}/api/v1/agent/run`,
      {
        user_task: '写一篇2025年多Agent框架技术发展趋势的短文',
        collab_mode: 'parallel'
      },
      { headers: { Authorization: `Bearer ${token}` } }
    );
  })
  .then(res => {
    if (res.data.code === 200) {
      console.log('执行结果：', res.data.data.task_result);
    } else {
      console.error('执行失败：', res.data.msg);
    }
  })
  .catch(err => console.error('请求失败：', err));

3. Java OkHttp调用示例（简化版）

java 复制代码 
// 需引入OkHttp和Gson依赖
OkHttpClient client = new OkHttpClient();
// 1. 获取Token
RequestBody tokenBody = RequestBody.create(MediaType.parse("application/json"), "{\"user_id\":\"test_user_001\"}");
Request tokenRequest = new Request.Builder()
        .url("http://你的服务器IP:8000/api/v1/token/get")
        .post(tokenBody)
        .build();
Response tokenResponse = client.newCall(tokenRequest).execute();
String token = new Gson().fromJson(tokenResponse.body().string(), Map.class).get("data").get("access_token");

// 2. 调用核心接口
RequestBody taskBody = RequestBody.create(MediaType.parse("application/json"), 
        "{\"user_task\":\"写一篇2025年多Agent框架技术发展趋势的短文\",\"collab_mode\":\"parallel\"}");
Request taskRequest = new Request.Builder()
        .url("http://你的服务器IP:8000/api/v1/agent/run")
        .addHeader("Authorization", "Bearer " + token)
        .post(taskBody)
        .build();
Response taskResponse = client.newCall(taskRequest).execute();
System.out.println(taskResponse.body().string());

九、生产级优化建议（必做）

以上代码已经实现了API的核心功能，生产环境部署时，还需要做以下优化，让API更稳定、更安全、更易维护：

  1. 配置HTTPS：绑定域名并配置SSL证书，所有请求用HTTPS，避免Token和数据被劫持。
  2. 添加接口限流 ：用slowapi实现接口限流，比如每个用户每分钟最多调用10次，防止恶意刷接口。
  3. 完善日志系统：用ELK/PLG栈收集日志，实现日志的检索、分析、可视化，方便问题排查。
  4. 添加监控指标：用Prometheus采集API的QPS、响应时间、错误率等指标，Grafana做可视化监控。
  5. 实现任务异步处理：如果Agent执行任务耗时较长，可将任务放入消息队列（如Redis/RabbitMQ），返回任务ID，调用方通过任务ID查询结果，避免请求超时。
  6. 对接用户系统：将Token生成接口对接公司的用户登录系统，验证账号密码后再生成Token，提升安全性。
  7. 添加接口版本管理 ：用/api/v1/、/api/v2/做版本管理，后续升级API时不影响旧版本调用。
  8. 实现数据持久化：将Agent执行的任务和结果存入数据库（如MySQL/MongoDB），方便追溯和统计。

十、实战总结

这篇咱们用FastAPI把多Agent框架封装成了标准化的RESTful API服务，实现了参数标准化、响应统一化、异常全局化、接口文档化、身份验证化，核心成果如下：

  1. 打造了Agent的"对外窗口"，能被Python、Java、前端、小程序等任何系统无缝调用，实现了Agent和其他业务系统的联动。
  2. 全程低耦合开发，不修改原有框架代码，后续框架升级不影响API服务。
  3. 无缝对接Docker镜像，一键部署成可对外提供服务的API容器，部署后立马能用。
  4. 实现了生产级的安全和性能优化，包含JWT身份验证、多进程高并发、全局异常处理。

到这里，咱们的多Agent框架已经从"本地程序"进化成了"标准化的云服务API"，能真正融入企业的业务系统，为实际业务创造价值～

目前国内还是很缺AI人才的，希望更多人能真正加入到AI行业，共同促进行业进步。想要系统学习AI知识的朋友可以看看我的教程http://blog.csdn.net/jiangjunshow，教程通俗易懂，风趣幽默，从深度学习基础原理到各领域实战应用都有讲解。

相关推荐
hjs_deeplearning2 小时前
文献阅读篇#14：自动驾驶中的基础模型：场景生成与场景分析综述（5）
人工智能·机器学习·自动驾驶
nju_spy2 小时前
离线强化学习（一）BCQ 批量限制 Q-learning
人工智能·强化学习·cvae·离线强化学习·双 q 学习·bcq·外推泛化误差
副露のmagic2 小时前
深度学习基础复健
人工智能·深度学习
番茄大王sc2 小时前
2026年科研AI工具深度测评（一）：文献调研与综述生成领域，维普科创助手领跑学术严谨性
人工智能·深度学习·考研·学习方法·论文笔记
Darkershadow2 小时前
蓝牙学习之Time Set
python·学习·蓝牙·ble·mesh
代码丰2 小时前
SpringAI+RAG向量库+知识图谱+多模型路由+Docker打造SmartHR智能招聘助手
人工智能·spring·知识图谱
m0_736919103 小时前
超越Python：下一步该学什么编程语言？
jvm·数据库·python
学习中的DGR3 小时前
[极客大挑战 2019]Http 1 新手解题过程
网络·python·网络协议·安全·http
独处东汉3 小时前
freertos开发空气检测仪之输入子系统结构体设计
数据结构·人工智能·stm32·单片机·嵌入式硬件·算法
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Clawdbot 中文汉化版 接入微信、飞书04一种新的LCA算法05【网络安全测试】Burp Suite工具使用说明、配置及常见问题（有关必回）06Claude Code Skills 实用使用手册07在Trae中使用Pencil MCP08零门槛部署本地 AI 助手：Clawdbot/Meltbot 部署深度保姆级教程09struts2 XML外部实体注入漏洞复现（CVE-2025-68493）10UV安装并设置国内源