AI 智能体构建全景指南：九大核心技术深度拆解与落地实战

AI 智能体（AI Agent）已从概念走向实用，成为连接大模型与真实场景的核心载体。一个成熟的智能体并非单一技术的堆叠，而是由基础架构、协作机制、知识增强、工具集成等多维度技术构成的复杂系统。

本文将系统拆解 AI 智能体的九大核心技术，补充详细的技术原理、实战案例、选型建议和落地避坑指南，帮你从“理解概念”到“动手构建”，全方位掌握智能体开发的关键环节。

一、AI 智能体（AI Agent）：自主决策的核心架构

AI 智能体是具备“感知-决策-执行”闭环能力的软件实体，能自主理解需求、规划步骤、调用工具，无需人类持续干预。其核心架构由四大组件构成，形成高效的自主运行机制。

1. 核心组件解析

• Prompt 工程：不仅是简单的指令，更是智能体的“行为准则”——需明确工具集、输出格式（如 JSON）、决策逻辑，引导大模型（LLM）生成可解析的行动指令；
• 决策调度（Switch 机制）：解析 LLM 输出的行动指令，判断下一步操作（调用工具、直接回答、终止流程），是智能体的“中枢神经”；
• 上下文管理：累积历史操作、工具返回结果、用户反馈，为后续决策提供依据，避免重复劳动或逻辑断层；
• 循环驱动（For 循环）：推动“感知-决策-执行”流程反复运行，直至 LLM 返回终止信号（如“任务完成”标记），确保复杂任务的闭环执行。

2. 最简实现代码（Python 示例）

import json
from openai import OpenAI

client = OpenAI(api_key="你的 API Key")

# 1. 定义工具集与 Prompt 模板
TOOL_DEFINITIONS = [
    {
        "name": "weather_query",
        "description": "查询指定城市的实时天气",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "城市名称"}
            },
            "required": ["city"]
        }
    }
]

PROMPT_TEMPLATE = f"""
你是一个智能助手，可使用以下工具完成任务：
{json.dumps(TOOL_DEFINITIONS, indent=2)}

输出格式要求：
- 若需要调用工具，返回 JSON：{{"action": "tool", "name": "工具名", "parameters": {{参数}}}}
- 若无需调用工具，直接回答，返回 JSON：{{"action": "answer", "content": "回答内容"}}
- 若任务完成，返回 JSON：{{"action": "terminal", "content": "任务总结"}}
"""

# 2. 工具实现
def weather_query(city: str) -> str:
    """模拟天气查询工具"""
    return f"{city} 实时天气：晴，25℃，微风"

# 3. 智能体核心循环
def ai_agent(user_query: str):
    context = []  # 累积上下文
    while True:
        # 构建完整 Prompt
        prompt = PROMPT_TEMPLATE + "\n历史上下文：" + str(context) + "\n用户需求：" + user_query

        # LLM 生成决策
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )

        # 解析决策
        try:
            decision = json.loads(response.choices[0].message.content)
        except json.JSONDecodeError:
            print("决策解析失败，重新尝试...")
            continue

        # 执行对应操作
        if decision["action"] == "tool":
            tool_name = decision["name"]
            params = decision["parameters"]
            # 调用工具
            if tool_name == "weather_query":
                result = weather_query(**params)
            else:
                result = f"未知工具：{tool_name}"
            # 更新上下文
            context.append({"action": "tool", "name": tool_name, "params": params, "result": result})
            print(f"工具调用结果：{result}")

        elif decision["action"] == "answer":
            print(f"智能体回答：{decision['content']}")
            context.append({"action": "answer", "content": decision["content"]})
            break

        elif decision["action"] == "terminal":
            print(f"任务完成：{decision['content']}")
            context.append({"action": "terminal", "content": decision["content"]})
            break

# 测试
ai_agent("查询北京的天气，然后告诉我是否适合户外活动")

3. 关键设计原则

• 输出格式必须标准化（如 JSON），避免 LLM 生成不可解析的内容；
• 上下文需精简，仅保留关键信息（如工具结果、核心决策），避免 Token 浪费；
• 增加异常处理（如工具调用失败、格式解析错误），提升鲁棒性。

二、Agentic AI：多智能体协作的系统架构

单体智能体难以应对复杂任务（如科研协作、企业级流程自动化），Agentic AI 通过多智能体分工协作，实现“1+1>2”的效果，其架构类似“交响乐团”，各角色各司其职、动态配合。

1. 核心特性

• 动态任务分解：将复杂任务拆分为子任务（如“市场分析报告”拆分为“数据采集→数据分析→报告撰写”），分配给专业智能体；
• 持久化记忆共享：多智能体共享任务状态、历史数据，避免信息孤岛；
• 灵活任务编排：支持串行（按顺序执行）、并行（同时执行）、条件分支（按结果判断流程）等复杂编排逻辑；
• 自适应协作：根据任务进展动态调整智能体角色与协作方式，应对突发情况（如数据采集失败时自动切换数据源）。

2. 典型应用场景

• 医疗诊断：分诊智能体负责初步问诊，专科智能体负责深度分析，用药智能体负责方案制定；
• 科研协作：文献检索智能体、数据处理智能体、论文撰写智能体协同完成研究工作；
• 企业运营：财务智能体、人事智能体、业务智能体协作处理日常运营流程。

3. 协作模式实战（CrewAI 示例）

from crewai import Agent, Task, Crew

# 1. 定义智能体角色
data_collector = Agent(
    role="数据采集专家",
    goal="收集指定行业的最新市场数据，包括规模、增长率、头部企业",
    backstory="具备丰富的市场数据检索经验，熟悉各类行业报告平台",
    verbose=True
)

data_analyst = Agent(
    role="数据分析专家",
    goal="分析采集到的市场数据，提炼核心趋势与关键洞察",
    backstory="擅长数据可视化与趋势分析，能从复杂数据中发现商业价值",
    verbose=True
)

report_writer = Agent(
    role="报告撰写专家",
    goal="将数据分析结果整理为结构化报告，语言专业且易懂",
    backstory="具备多年商业报告撰写经验，熟悉行业报告规范",
    verbose=True
)

# 2. 定义任务
task1 = Task(
    description="收集 2025 年中国 AI 医疗行业的市场数据",
    agent=data_collector
)

task2 = Task(
    description="分析收集到的市场数据，重点关注增长率、政策影响、竞争格局",
    agent=data_analyst,
    dependencies=[task1]  # 依赖前一个任务的结果
)

task3 = Task(
    description="根据数据分析结果，撰写 2025 年 AI 医疗行业市场分析报告",
    agent=report_writer,
    dependencies=[task2]
)

# 3. 启动多智能体协作
crew = Crew(agents=[data_collector, data_analyst, report_writer], tasks=[task1, task2, task3])
result = crew.kickoff()
print(result)

4. 落地关键

• 明确智能体角色边界，避免功能重叠；
• 设计清晰的信息传递格式，确保数据共享准确；
• 建立冲突解决机制（如智能体意见不一致时，引入决策智能体仲裁）。

三、工作流（WorkFlow）：可控可靠的任务拆解

复杂任务中，智能体的自主规划可能出现逻辑跳跃或错误，WorkFlow 技术通过“预定义步骤+严格执行”，提升任务处理的可靠性，尤其适用于高合规、高精准要求的场景。

1. 核心价值

• 避免“幻觉”：按固定流程执行，减少 LLM 自主决策的不确定性；
• 可追溯：每一步操作都有明确记录，便于问题排查；
• 易扩展：支持在流程中插入新步骤（如审批、校验）；
• 高可靠：适用于金融、医疗等对准确性要求极高的场景。

2. 常见工作流模式

模式	适用场景	示例
串行流程	步骤依赖强，需按顺序执行	订单处理：下单→支付→发货→通知
并行流程	多个步骤可同时进行，提升效率	市场调研：收集用户反馈+分析竞品+整理数据
条件分支流程	按结果动态选择后续步骤	贷款审批：通过→放款；不通过→拒绝通知
循环流程	需要重复执行某步骤直至满足条件	数据同步：同步数据→校验→失败则重试

3. 可视化工作流搭建（LangGraph 示例）

from langgraph.graph import Graph
from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(model="gpt-3.5-turbo")
graph = Graph()

# 1. 定义流程节点
def step1_order_create(user_info):
    """步骤1：创建订单"""
    print("创建订单...")
    return {"order_id": "ORD123", "status": "created", "user_info": user_info}

def step2_payment_check(order_data):
    """步骤2：支付校验"""
    print("校验支付状态...")
    # 模拟支付成功
    order_data["status"] = "paid"
    return order_data

def step3_delivery(order_data):
    """步骤3：发货处理"""
    print("安排发货...")
    order_data["delivery_id"] = "DEL456"
    return order_data

def step4_notify(order_data):
    """步骤4：通知用户"""
    print("通知用户订单发货...")
    return f"订单 {order_data['order_id']} 已发货，物流单号：{order_data['delivery_id']}"

# 2. 构建工作流
graph.add_node("order_create", step1_order_create)
graph.add_node("payment_check", step2_payment_check)
graph.add_node("delivery", step3_delivery)
graph.add_node("notify", step4_notify)

# 定义流程顺序
graph.add_edge("order_create", "payment_check")
graph.add_edge("payment_check", "delivery")
graph.add_edge("delivery", "notify")

# 设置入口
graph.set_entry_point("order_create")
# 设置出口
graph.set_finish_point("notify")

# 3. 执行工作流
app = graph.compile()
result = app.invoke({"user_info": {"name": "张三", "product": "AI 课程"}})
print(result)

4. 落地建议

• 复杂流程优先采用可视化工具（如 LangGraph、n8n）搭建，降低维护成本；
• 关键步骤添加“人工审核”节点，平衡自动化与可靠性；
• 记录每一步的执行日志，便于追溯与优化。

四、RAG（检索增强生成）：智能体的“知识储备库”

大模型存在知识过时、幻觉等问题，RAG 技术通过检索外部知识库的精准信息，增强生成结果的准确性，是智能体必备的知识增强方案。

1. 核心流程（两阶段）

（1）知识库构建阶段

1. 数据采集：收集文档、网页、数据库等多源数据；
2. 文本分块：将长文本拆分为语义完整的小块（如 512 Token/块），避免信息碎片化；
3. 向量化编码：通过嵌入模型（如 BGE-M3、Sentence-BERT）将文本块转为向量；
4. 向量存储：将向量存入向量数据库（如 Chroma、Milvus），建立索引。

（2）检索生成阶段

1. 查询处理：将用户问题转为向量；
2. 相似检索：在向量数据库中查找与查询最相关的文本块；
3. 上下文构建：将检索到的文本块作为上下文，与用户问题拼接；
4. 生成回答：LLM 基于上下文生成准确回答，避免幻觉。

2. 关键优化点

• 分块策略：按语义边界（如段落、句子）分块，而非固定长度，提升相关性；
• 嵌入模型选型：中文场景优先选择 BGE-M3、通义千问嵌入模型；
• 向量数据库选择：小规模场景用 Chroma（轻量），大规模场景用 Milvus（分布式）；
• 重排序：检索后用 Cross-Encoder 模型对结果重排序，提升精准度。

3. 实战：构建企业知识库 RAG 系统

# 1. 安装依赖
# pip install langchain chromadb sentence-transformers pypdf

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import SentenceTransformerEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQAWithSourcesChain
from langchain.chat_models import ChatOpenAI

# 2. 构建知识库
loader = PyPDFLoader("企业产品手册.pdf")
documents = loader.load()

# 文本分块
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,
    chunk_overlap=64,
    length_function=len
)
chunks = text_splitter.split_documents(documents)

# 向量化与存储
embeddings = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")
db = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")
db.persist()

# 3. 构建 RAG 链
llm = ChatOpenAI(model="gpt-3.5-turbo")
chain = RetrievalQAWithSourcesChain.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=db.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True
)

# 4. 测试
query = "产品A的定价是多少？"
result = chain({"question": query})
print(f"回答：{result['answer']}")
print(f"信息来源：{[doc.metadata['source'] for doc in result['source_documents']]}")

五、微调（Fine-tuning）：让智能体适配特定场景

预训练大模型的通用能力强，但在垂直领域（如医疗、金融）可能表现不佳。微调通过在领域数据上进一步训练，让智能体适配特定场景的需求。

1. 微调的核心场景

• 领域适配：模型缺乏专业知识（如法律条款、医疗术语）；
• 风格统一：需要生成符合企业风格的内容（如官方话术、报告格式）；
• 数据安全：敏感数据无法通过 API 调用外部模型，需本地微调；
• 性能优化：提升特定任务的响应速度与准确性。

2. 微调类型与选型

类型	特点	适用场景	成本
全参数微调	调整模型所有参数，效果好	数据充足、预算充足的核心场景	高（需大量 GPU 资源）
高效参数微调（PEFT）	仅调整部分参数（如 LoRA），成本低	数据有限、预算紧张的场景	低（普通 GPU 即可）
提示微调（Prompt Tuning）	仅优化提示词相关参数	轻量级适配，无需大量数据	极低

3. 微调完整流程（OpenAI 示例）

（1）数据准备（JSON 格式）

[
  {
    "messages": [
      {"role": "system", "content": "你是金融行业智能助手，回答需专业、准确"},
      {"role": "user", "content": "什么是科创板？"},
      {"role": "assistant", "content": "科创板是上海证券交易所设立的独立于现有主板市场的板块，专为科技型和创新型中小企业服务..."}
    ]
  },
  // 更多训练样本...
]

（2）上传数据与启动微调

# 1. 上传训练数据
curl https://api.openai.com/v1/files \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F "purpose=fine-tune" \
  -F "file=@training_data.json"

# 2. 启动微调任务（记录上传后的 file_id）
curl https://api.openai.com/v1/fine-tuning/jobs \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "training_file": "file-xxx",
    "model": "gpt-3.5-turbo"
  }'

（3）使用微调后的模型

from openai import OpenAI

client = OpenAI(api_key="你的 API Key")
response = client.chat.completions.create(
    model="ft:gpt-3.5-turbo:your-fine-tuned-model-id",
    messages=[{"role": "user", "content": "科创板的上市条件是什么？"}]
)
print(response.choices[0].message.content)

4. 微调避坑指南

• 数据质量优先：高质量、结构化的数据比海量低质数据更重要；
• 先尝试 RAG：简单场景用 RAG 即可满足需求，无需盲目微调；
• 控制训练步数：避免过拟合（训练损失下降但验证损失上升）；
• 小批量测试：微调后先进行小范围测试，验证效果再推广。

六、函数调用（Function Calling）：智能体的“工具之手”

函数调用让智能体具备调用外部 API、数据库、工具的能力，突破 LLM 自身的能力边界（如获取实时数据、执行计算、操作硬件）。

1. 核心流程

1. 工具定义：明确函数名称、描述、参数类型、返回格式，让 LLM 理解如何调用；
2. 需求识别：LLM 分析用户需求，判断是否需要调用工具（如“查询天气”需调用天气 API）；
3. 参数生成：LLM 从用户需求中提取参数（如从“查询北京天气”中提取 city=“北京”）；
4. 工具执行：开发者根据 LLM 输出的函数调用指令，执行实际工具；
5. 结果整合：将工具返回结果反馈给 LLM，生成最终回答。

2. 实战：智能体调用天气 API

import json
import requests
from openai import OpenAI

client = OpenAI(api_key="你的 API Key")

# 1. 定义天气 API 函数
def get_weather(city: str) -> str:
    """调用天气 API 获取实时天气"""
    api_key = "你的天气 API Key"
    url = f"https://api.seniverse.com/v3/weather/now.json?key={api_key}&location={city}&language=zh-Hans&unit=c"
    response = requests.get(url)
    data = response.json()
    if "results" in data:
        now = data["results"][0]["now"]
        return f"{city} 实时天气：{now['text']}，温度 {now['temperature']}℃，{now['wind_direction']}风 {now['wind_scale']}级"
    return f"无法查询 {city} 的天气"

# 2. 定义函数描述（给 LLM 看）
FUNCTION_DESCRIPTIONS = [
    {
        "name": "get_weather",
        "description": "查询指定城市的实时天气",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "城市名称，如北京、上海"}
            },
            "required": ["city"]
        }
    }
]

# 3. 智能体函数调用逻辑
def agent_with_function_calling(user_query: str):
    # 第一步：让 LLM 判断是否需要调用工具
    prompt = f"""
    你可以调用以下工具：{json.dumps(FUNCTION_DESCRIPTIONS, indent=2)}
    请分析用户需求，若需要调用工具，返回 JSON 格式：{{"name": "工具名", "parameters": {{参数}}}}
    若无需调用工具，直接返回自然语言回答。
    用户需求：{user_query}
    """

    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3
    )

    # 第二步：解析响应
    try:
        function_call = json.loads(response.choices[0].message.content)
        # 调用工具
        if function_call["name"] == "get_weather":
            result = get_weather(**function_call["parameters"])
            # 第三步：生成最终回答
            final_response = client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "user", "content": user_query},
                    {"role": "assistant", "content": f"工具调用结果：{result}"},
                    {"role": "user", "content": "请整理工具结果，用自然语言回答用户"}
                ]
            )
            print(final_response.choices[0].message.content)
    except json.JSONDecodeError:
        # 无需调用工具，直接输出回答
        print(response.choices[0].message.content)

# 测试
agent_with_function_calling("查询广州的实时天气，是否适合穿短袖？")

3. 常见问题与解决方案

问题	解决方案
参数提取错误	优化函数描述，明确参数格式（如“城市名称为中文全称”）
无需调用却调用	在 Prompt 中明确工具适用场景，避免过度调用
跨模型不兼容	采用标准化的函数定义格式（如 OpenAI 规范）
工具调用失败	添加重试机制、错误处理，返回友好提示

七、MCP（模型上下文协议）：工具集成的标准化方案

不同工具的 API 格式、调用方式各异，导致智能体集成工具时需重复适配。MCP（模型上下文协议）通过标准化工具描述、通信流程，实现“一次开发，多平台复用”。

1. 核心价值

• 标准化接口：统一工具的描述格式、调用方式，降低集成成本；
• 跨平台兼容：支持 LangChain、LlamaIndex 等主流智能体框架；
• 安全可控：通过协议层隔离工具与智能体，提升安全性；
• 生态丰富：越来越多工具支持 MCP 协议，可直接接入。

2. MCP 架构组成

• MCP 主机（Host）：智能体运行环境（如 IDE、AI 工具）；
• MCP 客户端（Client）：管理与 MCP 服务器的连接，解析工具调用指令；
• MCP 服务器（Server）：提供标准化工具服务，封装具体工具逻辑；
• 数据源/服务：工具依赖的本地数据（文件、数据库）或远程服务（API、云服务）。

3. 实战：开发 MCP 工具服务器（Python）

# 安装依赖：pip install mcp-server fastapi uvicorn
from mcp.server.fastmcp import FastMCP

# 初始化 MCP 服务器
mcp = FastMCP("weather-mcp-server")

# 定义 MCP 工具
@mcp.tool()
def get_weather(city: str) -> str:
    """查询指定城市的实时天气（MCP 标准化工具）"""
    # 复用之前的 get_weather 函数逻辑
    api_key = "你的天气 API Key"
    url = f"https://api.seniverse.com/v3/weather/now.json?key={api_key}&location={city}&language=zh-Hans&unit=c"
    response = requests.get(url)
    data = response.json()
    if "results" in data:
        now = data["results"][0]["now"]
        return f"{city} 实时天气：{now['text']}，温度 {now['temperature']}℃"
    return f"无法查询 {city} 的天气"

# 启动 MCP 服务器（SSE 传输方式，支持远程调用）
if __name__ == "__main__":
    mcp.run(transport="sse", host="0.0.0.0", port=8000)

4. 智能体接入 MCP 工具

from mcp.client import MCPClient

async def agent_call_mcp_tool(user_query: str):
    # 连接 MCP 服务器
    client = MCPClient("http://localhost:8000/mcp")
    await client.connect()

    # 获取可用工具
    tools = await client.list_tools()
    # 转换为 LLM 可理解的格式
    tool_descriptions = [
        {
            "name": tool["name"],
            "description": tool["description"],
            "parameters": tool["inputSchema"]
        }
        for tool in tools
    ]

    # 后续流程与函数调用类似，通过 MCP 客户端调用工具
    # ...（省略 LLM 决策、参数提取步骤）

    # 调用 MCP 工具
    result = await client.call_tool(
        name="get_weather",
        arguments={"city": "深圳"}
    )
    print(result.content[0]["text"])

八、A2A（智能体间通信协议）：多智能体协作的“语言”

多智能体协作需解决“如何发现对方能力”“如何传递信息”“如何协同任务”等问题，A2A 协议通过标准化通信方式，实现智能体间的无缝协作。

1. 核心机制

• 能力发现：智能体通过“Agent Card”公开自身能力（如“擅长数据分析”“支持天气查询”），其他智能体可自动发现；
• 任务管理：支持长/短任务的分配、进度跟踪、结果反馈；
• 协作通信：标准化的消息格式，传递上下文、任务指令、执行结果；
• 安全适配：支持身份认证、权限控制，保障企业级协作安全。

2. 协议核心特性

• 基于标准协议：构建在 HTTP、SSE、JSON-RPC 等成熟标准之上，兼容性强；
• 双向通信：支持智能体主动发起请求、被动接收任务；
• 灵活扩展：支持自定义消息类型，适配复杂协作场景；
• 跨框架兼容：无论智能体基于 LangChain 还是 LlamaIndex 开发，均可通过 A2A 协作。

3. 典型应用场景

• 跨团队协作：市场部智能体与技术部智能体协同完成产品发布会筹备；
• 跨地域协作：不同地区的智能体协同处理本地化任务（如区域市场调研）；
• 跨领域协作：医疗智能体与金融智能体协同完成健康保险方案定制。

4. 落地建议

• 优先采用成熟的 A2A 实现（如 CrewAI 的协作协议），避免重复造轮子；
• 明确智能体的“Agent Card”格式，确保能力发现准确；
• 设计消息重试机制，应对网络波动或智能体离线；
• 对敏感信息进行加密传输，保障数据安全。

九、AG-UI（智能体用户交互协议）：前端与智能体的“桥梁”

智能体的前端交互需解决“如何传递用户需求”“如何展示流式响应”“如何处理用户反馈”等问题，AG-UI 协议通过标准化前端与智能体的通信方式，避免重复开发。

1. 核心价值

• 标准化交互：统一前端与智能体的事件格式、传输方式，降低开发成本；
• 双向通信：支持前端发送用户输入、上下文，智能体流式返回响应；
• 多传输支持：兼容 SSE（流式响应）、WebSocket（实时通信）等方式；
• 体验一致：不同智能体的前端交互逻辑统一，提升用户体验。

2. 核心事件类型

AG-UI 协议定义了 16 种标准事件，覆盖主流交互场景：

• 用户输入事件（user_input）：前端传递用户文本、语音、图片等输入；
• 智能体响应事件（agent_response）：智能体返回流式响应；
• 工具调用事件（tool_call）：智能体通知前端工具调用状态；
• 任务状态事件（task_status）：智能体同步任务进度（如“处理中”“已完成”）；
• 错误事件（error）：传递错误信息（如“工具调用失败”）。

3. 实战：前端与智能体的 AG-UI 通信（JavaScript 示例）

// 前端通过 SSE 与智能体通信
const sse = new EventSource('http://your-agent-server/ag-ui/sse');

// 1. 监听智能体响应事件
sse.addEventListener('agent_response', (event) => {
  const data = JSON.parse(event.data);
  // 流式展示响应内容
  document.getElementById('response').innerText += data.content;
});

// 2. 监听任务状态事件
sse.addEventListener('task_status', (event) => {
  const data = JSON.parse(event.data);
  document.getElementById('status').innerText = `任务状态：${data.status}`;
});

// 3. 发送用户输入
function sendUserInput(input) {
  fetch('http://your-agent-server/ag-ui/input', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      event: 'user_input',
      data: { content: input, context: {} }
    })
  });
}

// 测试：发送用户需求
sendUserInput('查询上海的天气，然后推荐适合的户外活动');

4. 前端开发建议

• 采用流式响应：通过 SSE 或 WebSocket 实现实时交互，提升用户体验；
• 处理加载状态：显示智能体“思考中”“调用工具中”等状态，避免用户困惑；
• 支持多模态输入：兼容文本、语音、图片等输入方式；
• 提供反馈入口：允许用户标记回答是否准确，帮助智能体优化。

十、总结：智能体构建的核心逻辑与落地路径

AI 智能体的九大核心技术并非孤立存在，而是相互协同的有机整体：

• 基础层：AI Agent（核心架构）、WorkFlow（流程控制）；
• 增强层：RAG（知识增强）、微调（场景适配）；
• 工具层：函数调用（工具集成）、MCP（标准化工具）；
• 协作层：Agentic AI（多智能体）、A2A（通信协议）；
• 交互层：AG-UI（前端交互）。

落地路径建议

1. 明确场景：从单一任务（如天气查询、文档问答）入手，避免盲目追求复杂功能；
2. 技术选型：优先使用成熟框架（如 LangChain、CrewAI），降低开发成本；
3. 迭代优化：先实现核心功能，再逐步添加 RAG、微调、多智能体协作等增强特性；
4. 注重实用：以“解决实际问题”为目标，避免过度设计。

随着技术的演进，智能体将朝着更自主、更协同、更易用的方向发展。掌握这九大核心技术，不仅能构建当前需求的智能体，更能适应未来技术迭代，在 AI 应用落地中占据主动。

除非注明，否则均为李锋镝的博客原创文章，转载必须以链接形式标明本文链接

本文链接：https://www.lifengdi.com/ren-gong-zhi-neng/4591