📌 项目起源

如果说 2024 年是"百模大战"之年，那么 2025 年无疑迎来了"智能体元年"。技术焦点正在从训练更大的基础模型，转向构建更聪明的 Agent 应用。然而，系统化、实践导向的教程极为稀缺。

为此，我们发起了 Hello-Agents 项目，希望为社区提供一份从零开始构建 Agent 系统的完整指南，做到理论与实践并重。

🎯 项目定位

Hello-Agents 是来自 Datawhale 社区的系统化 Agent 学习教程。当前 Agent 开发主要分为两大流派：一是以 Dify、Coze、n8n 为代表的软件工程型 Agent，本质上是以 LLM 为数据处理后端的流程驱动软件开发；二是 AI 原生 Agent，真正由 AI 驱动的智能体。

本教程旨在引导你深入理解并构建后者——真正的 AI Native Agent。教程将带你穿透框架的表面，从 Agent 的核心原理出发，深入其核心架构，理解其经典范式，最终构建属于你自己的多 Agent 应用。

👥 目标读者

• 具有一定编程基础的 AI 开发者、软件工程师、学生
• 对前沿 AI 技术有浓厚兴趣的自学者
• 希望从"使用 LLM"升级为"构建 Agent"的开发者
• 准备 Agent 相关岗位求职的候选人

📋 前置知识

• 基本的 Python 编程能力
• 对大语言模型的基本概念理解（知道如何通过 API 调用 LLM 即可）
• 不需要深厚的算法或模型训练背景

🤖 什么是智能体（Agent）？

智能体（Agent）是一个能够感知环境、做出决策并采取行动以实现特定目标的计算实体。与传统软件不同，Agent 具有自主性、反应性、主动性和社会能力。

在 AI 领域，现代 LLM Agent 是以大语言模型为"大脑"，能够使用工具、规划任务、与环境交互并完成复杂任务的系统。

🏷️ Agent 的核心要素

1. 感知（Perception）

Agent 通过各种输入（文本、图像、传感器数据等）感知周围环境的状态。LLM Agent 通常通过用户消息、工具输出、记忆系统等获取信息。

2. 规划（Planning）

Agent 需要将复杂任务分解为可执行的子步骤，并制定行动计划。这是 LLM Agent 的核心能力，也是区别于普通 LLM 的关键。

3. 行动（Action）

Agent 通过调用工具（API、代码执行、搜索等）或与其他 Agent 交互来执行具体操作，改变环境状态。

4. 记忆（Memory）

Agent 需要维护短期记忆（当前对话上下文）和长期记忆（持久化的知识和经验），以支持连续交互和学习。

📊 Agent 的类型

• 简单反应型 Agent：根据当前感知直接做出响应，无内部状态
• 基于模型的 Agent：维护内部世界模型，考虑行动后果
• 基于目标的 Agent：以目标为导向进行规划和行动
• 基于效用的 Agent：通过效用函数权衡不同行动方案
• 学习型 Agent：能从经验中学习并改进行为
• 多 Agent 系统：多个 Agent 协同工作，解决复杂问题

🌟 LLM Agent 的应用场景

• 🔍 信息检索与研究：自动搜索、总结、分析大量信息
• 💻 代码开发辅助：代码生成、调试、测试自动化
• 📊 数据分析：自动化数据处理和洞察提取
• 🗣️ 客户服务：智能客服和问题解决
• 🎯 任务自动化：工作流程自动化和任务委托
• 🎮 游戏 NPC：具有真实行为的游戏角色

from openai import OpenAI

client = OpenAI()

def simple_agent(user_query: str) -> str:
    """一个最简单的 LLM Agent 示例"""
    messages = [
        {"role": "system", "content": "你是一个智能助手，能够回答用户的问题并执行简单任务。"},
        {"role": "user", "content": user_query}
    ]
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages
    )
    
    return response.choices[0].message.content

# 测试
result = simple_agent("帮我分析一下智能体的发展趋势")
print(result)

📅 智能体发展时间线

智能体的发展历史是 AI 研究的一条重要脉络，从早期的符号主义 AI 到今天以大语言模型为核心的现代 Agent，经历了数十年的演变。

🏛️ 第一阶段：符号主义 AI 时代（1950s-1980s）

早期 AI 研究以规则系统和专家系统为主。这些系统依赖人工编写的逻辑规则来模拟智能行为。

• STRIPS（1971）：第一个真正意义上的 AI 规划系统
• MYCIN（1974）：医疗诊断专家系统，基于约 600 条规则
• Shakey 机器人（1972）：能够感知和规划的自主机器人

🧠 第二阶段：机器学习与强化学习（1990s-2010s）

随着机器学习的兴起，Agent 开始从数据中学习行为策略，而不是依赖预先编写的规则。

• TD-Gammon（1992）：通过自我对弈学会玩西洋双陆棋
• DeepBlue（1997）：击败国际象棋世界冠军卡斯帕罗夫
• AlphaGo（2016）：击败围棋世界冠军，深度强化学习的里程碑

🌐 第三阶段：LLM Agent 时代（2020s至今）

GPT 系列大语言模型的出现彻底改变了 Agent 的设计范式。LLM 作为强大的"推理引擎"，使 Agent 获得了前所未有的通用能力。

• GPT-3（2020）：展示了 LLM 的少样本学习能力
• ChatGPT（2022）：对话式 AI 的爆发，RLHF 训练范式
• ReAct（2022）：首个将推理与行动结合的 Agent 范式
• AutoGPT（2023）：自主 Agent 概念的大规模普及
• OpenAI Assistants API（2023）：官方 Agent 构建平台
• Claude MCP（2024）：标准化 Agent 工具调用协议

🔮 发展趋势

• 从单 Agent 到多 Agent 协作系统
• 从文本输入到多模态感知（视觉、听觉）
• 从被动响应到主动规划与长期目标追求
• 从有限工具到开放式工具生态
• Agent 的自我进化与持续学习

🏗️ Transformer 架构

Transformer 是现代大语言模型的核心架构，由 Google 在 2017 年的论文《Attention is All You Need》中提出。其核心机制是自注意力（Self-Attention），允许模型在处理每个 token 时考虑序列中所有其他 token 的信息。

核心组件

• 多头自注意力（Multi-Head Self-Attention）：从多个维度捕捉 token 间的关系
• 前馈神经网络（FFN）：对每个位置独立进行非线性变换
• 层归一化（Layer Norm）：稳定训练过程
• 位置编码（Positional Encoding）：为模型提供序列顺序信息

✍️ 提示词工程（Prompt Engineering）

提示词工程是构建高效 LLM Agent 的关键技能，涉及如何设计输入，使 LLM 产生期望的输出。

主要技术

• 零样本提示（Zero-shot）：直接描述任务，无需示例
• 少样本提示（Few-shot）：提供少量示例帮助模型理解任务
• 思维链（Chain-of-Thought）：引导模型逐步推理
• 角色设定（Role Playing）：为 LLM 设定特定的身份和行为模式
• 结构化输出：指定 JSON 等结构化格式的输出

System: 你是一个专业的智能体开发专家。请按照以下格式回答：
{
  "分析": "...",
  "行动计划": ["步骤1", "步骤2", ...],
  "预期结果": "..."
}

User: 我需要构建一个能够自动整理邮件的智能体，请帮我分析并制定方案。

🤖 主流大语言模型对比

• GPT-4o（OpenAI）：多模态，强推理，Agent 生态完善
• Claude 3.5（Anthropic）：长上下文，安全性强，工具调用能力优秀
• Gemini 1.5（Google）：超长上下文，多模态，与 Google 生态深度集成
• Qwen（阿里）：中文能力强，开源版本可本地部署
• DeepSeek-V3：国产开源，性价比极高

⚠️ LLM 的局限性与 Agent 的意义

• 知识截止日期：LLM 无法获取训练数据截止后的信息 → Agent 通过搜索工具解决
• 计算局限：LLM 不擅长精确计算 → Agent 调用计算器/代码执行工具
• 无状态性：每次对话独立 → Agent 引入记忆系统
• 幻觉问题：LLM 可能产生虚假信息 → Agent 通过验证工具核实

🔄 ReAct 范式

ReAct（Reasoning + Acting）是最具影响力的 LLM Agent 范式之一，由 Yao 等人于 2022 年提出。它将推理（Reasoning）和行动（Acting）交织进行，使 Agent 能够在与环境交互中动态调整策略。

ReAct 循环

• Thought（思考）：LLM 分析当前状态，规划下一步行动
• Action（行动）：调用特定工具或执行操作
• Observation（观察）：接收工具执行结果
• 重复循环直至任务完成

import json
from openai import OpenAI

client = OpenAI()

# 定义工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "搜索互联网获取最新信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "搜索关键词"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "执行数学计算",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "数学表达式"}
                },
                "required": ["expression"]
            }
        }
    }
]

def react_agent(user_query: str) -> str:
    messages = [
        {"role": "system", "content": "你是一个智能助手。你可以使用工具来帮助用户解决问题。"},
        {"role": "user", "content": user_query}
    ]
    
    while True:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        
        message = response.choices[0].message
        
        if message.tool_calls:
            # 处理工具调用
            messages.append(message)
            for tool_call in message.tool_calls:
                result = execute_tool(tool_call)
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })
        else:
            return message.content

📋 Plan-and-Solve 范式

Plan-and-Solve 范式将任务分为两个阶段：首先制定完整计划，然后逐步执行。这种方式适合需要长期规划的复杂任务。

• 计划阶段：LLM 将任务分解为有序的子任务列表
• 执行阶段：按顺序执行每个子任务，收集结果
• 整合阶段：汇总所有子任务结果，形成最终答案

🔁 Reflection 范式

Reflection 让 Agent 能够审视自己的输出，发现错误并进行改进。这大幅提升了复杂任务的完成质量。

• 生成（Generate）：产生初始输出
• 反思（Reflect）：评估输出质量，找出问题
• 改进（Refine）：基于反思改进输出

🎛️ 为什么选择低代码平台？

低代码 Agent 平台让没有深厚编程背景的用户也能快速构建功能强大的 Agent 应用。这些平台通过可视化界面、预置组件和模板，大幅降低了 Agent 开发的门槛。

🔧 Coze（扣子）

字节跳动推出的 Agent 开发平台，提供丰富的插件生态和简单易用的对话流设计界面。

• 插件市场：数百个预置插件，覆盖搜索、计算、内容生成等
• 工作流：可视化编排复杂的多步骤任务流程
• 知识库：上传文档构建私有知识库
• 发布渠道：一键发布到微信、飞书、Discord 等平台

🔧 Dify

开源的 LLM 应用开发平台，支持私有化部署，是企业级 Agent 应用的热门选择。

• 应用类型：支持对话助手、文本生成、Agent 等多种应用类型
• RAG 能力：强大的文档处理和检索增强生成能力
• 工作流编排：可视化节点式工作流，支持条件分支和循环
• API 集成：提供标准 API，方便与现有系统集成

🔧 n8n

强大的工作流自动化平台，支持 400+ 服务集成，适合构建复杂的自动化 Agent 工作流。

• 节点连接：通过拖拽连接不同服务的节点
• 触发器：支持 Webhook、定时任务、事件驱动等多种触发方式
• 代码节点：在需要时插入自定义 JavaScript 代码
• 自托管：完全开源，可在自己的服务器上运行

⚖️ 平台对比

🔷 LangChain / LangGraph

LangChain 是最受欢迎的 LLM 应用开发框架，而 LangGraph 在其基础上增加了状态图（State Graph）概念，特别适合构建需要复杂控制流的 Agent 系统。

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from typing import TypedDict, List

class AgentState(TypedDict):
    messages: List[dict]
    next_step: str

def create_agent_graph():
    llm = ChatOpenAI(model="gpt-4o")
    graph = StateGraph(AgentState)
    
    # 添加节点
    graph.add_node("reason", reason_node)
    graph.add_node("act", action_node)
    graph.add_node("observe", observe_node)
    
    # 添加边
    graph.add_edge("reason", "act")
    graph.add_edge("act", "observe")
    graph.add_conditional_edges(
        "observe",
        should_continue,
        {"continue": "reason", "end": END}
    )
    
    graph.set_entry_point("reason")
    return graph.compile()

🔷 AutoGen

微软开源的多 Agent 对话框架，专注于多 Agent 协作场景。其核心是让多个具有不同角色的 Agent 相互对话来解决复杂问题。

• ConversableAgent：可以互相对话的基础 Agent 类型
• AssistantAgent：具有代码生成和执行能力的助手 Agent
• UserProxyAgent：代表用户参与对话的代理 Agent
• GroupChat：支持多个 Agent 参与的群体对话

🔷 AgentScope

阿里开源的多 Agent 框架，设计目标是让多 Agent 应用的开发更加简洁、可靠。

• 消息机制：基于 Msg 的统一消息格式
• Pipeline：灵活的 Agent 协作流水线
• 分布式：原生支持分布式多 Agent 系统

💡 如何选择框架？

• 需要成熟生态和大量示例 → LangChain/LangGraph
• 专注多 Agent 协作 → AutoGen
• 偏好中文文档和国内生态 → AgentScope
• 想从底层理解 Agent → 自建框架（第七章）

🎯 为什么要自建框架？

理解 Agent 框架的最好方式是自己实现一个。通过从零构建，你将深刻理解每一个组件的作用，而不是停留在"使用轮子"的阶段。本章将带你构建 HelloAgents —— 一个基于 OpenAI 原生 API 的简洁 Agent 框架。

🏗️ HelloAgents 架构设计

核心组件

• Agent 核心：包含 LLM 调用、工具管理、消息历史
• 工具系统：标准化工具注册和调用接口
• 记忆系统：短期记忆和长期记忆管理
• 规划器：任务分解和执行计划生成

🔧 使用 HelloAgents

🧠 Agent 的记忆系统

记忆是 Agent 实现持续学习和跨会话知识积累的关键。参考人类记忆系统，Agent 的记忆可以分为以下几类：

记忆类型

• 感觉记忆（Sensory Memory）：原始输入信息的短暂留存，如当前输入的 token 流
• 短期记忆（Working Memory）：当前对话上下文，即 messages 列表
• 长期记忆（Long-term Memory）：跨会话持久化的知识，存储在数据库或向量库中
• 程序性记忆：技能和行为模式，通过 few-shot 示例或 fine-tuning 实现

🔍 检索增强生成（RAG）

RAG（Retrieval-Augmented Generation）是解决 LLM 知识局限性的核心技术，通过在生成时检索相关外部知识来提升答案质量。

RAG 基础流程

• 文档处理：将文档切分为合适大小的 chunk
• 向量化：使用 Embedding 模型将 chunk 转为向量
• 存储：将向量存入向量数据库（如 Chroma、Pinecone、Faiss）
• 检索：将用户问题向量化，检索最相关的 chunk
• 生成：将检索结果注入 Prompt，LLM 据此生成答案

from openai import OpenAI
import chromadb

client = OpenAI()
chroma = chromadb.Client()
collection = chroma.create_collection("knowledge_base")

def add_documents(docs: list[str]):
    """将文档添加到知识库"""
    embeddings = client.embeddings.create(
        model="text-embedding-3-small",
        input=docs
    ).data
    
    collection.add(
        documents=docs,
        embeddings=[e.embedding for e in embeddings],
        ids=[f"doc_{i}" for i in range(len(docs))]
    )

def rag_query(question: str, top_k: int = 3) -> str:
    """RAG 问答"""
    # 检索相关文档
    q_embedding = client.embeddings.create(
        model="text-embedding-3-small",
        input=[question]
    ).data[0].embedding
    
    results = collection.query(
        query_embeddings=[q_embedding],
        n_results=top_k
    )
    
    context = "\n".join(results['documents'][0])
    
    # 生成答案
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": f"基于以下上下文回答问题：\n{context}"},
            {"role": "user", "content": question}
        ]
    )
    return response.choices[0].message.content

📈 高级 RAG 技术

• 混合检索：结合向量检索和 BM25 关键词检索
• 重排序（Reranking）：对检索结果进行二次排序
• 多跳检索：通过多次检索解决需要推理的复杂问题
• 自适应检索：根据问题类型动态调整检索策略

📐 什么是上下文工程？

上下文工程（Context Engineering）是指系统化地设计、管理和优化输入给 LLM 的上下文信息，以最大化模型在有限上下文窗口内的输出质量。

🗂️ 上下文窗口的组成

• 系统提示（System Prompt）：定义 Agent 的角色、能力和行为准则
• 工具定义：告诉 LLM 可用的工具及其参数
• 对话历史：记录用户与 Agent 的交互历史
• 外部知识：从 RAG 系统检索的相关文档
• 工具输出：之前工具调用的结果
• 用户输入：当前用户的消息

⚙️ 核心技术

1. 对话压缩

当对话历史过长超出上下文窗口时，需要对历史进行压缩：

• 滑动窗口：只保留最近 N 轮对话
• 摘要压缩：用 LLM 对历史对话生成摘要
• 重要性过滤：根据重要性评分保留关键信息

2. 动态上下文注入

根据当前问题动态决定注入哪些上下文：

• 根据用户意图检索相关记忆
• 根据任务类型选择相关工具
• 根据对话阶段调整系统提示

3. KV Cache 优化

利用 LLM 的 KV Cache 机制，将不变的系统提示和工具定义放在上下文最前面，可以显著降低 API 调用成本。

🌐 为什么需要 Agent 通信协议？

随着 Agent 系统日趋复杂，不同 Agent 之间、Agent 与工具之间的通信成为关键问题。通信协议解决了互操作性问题，让不同开发者构建的 Agent 和工具能够无缝协作。

🔌 MCP（Model Context Protocol）

由 Anthropic 提出的开放标准协议，定义了 LLM 应用与外部工具/数据源之间的通信方式。

• 核心概念：Server（工具提供方）和 Client（AI 应用）
• 传输层：支持 stdio 和 HTTP/SSE 两种传输方式
• 能力类型：Tools（工具）、Resources（资源）、Prompts（提示词模板）
• 生态：已有数百个官方和社区 MCP Server

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
import mcp.types as types

app = Server("my-mcp-server")

@app.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="get_stock_price",
            description="获取股票实时价格",
            inputSchema={
                "type": "object",
                "properties": {
                    "symbol": {"type": "string", "description": "股票代码"}
                },
                "required": ["symbol"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "get_stock_price":
        symbol = arguments["symbol"]
        # 实际调用股票 API
        price = fetch_stock_price(symbol)
        return [TextContent(type="text", text=f"{symbol} 当前价格: {price}")]

async def main():
    async with stdio_server() as streams:
        await app.run(*streams)

🤝 A2A（Agent-to-Agent）协议

Google 提出的 Agent 间通信协议，专注于不同 AI Agent 系统之间的互操作性。A2A 定义了 Agent 发现、能力声明和任务委托的标准方式。

🔗 ANP（Agent Network Protocol）

面向开放网络的 Agent 通信协议，支持 Agent 在开放互联网上进行去中心化的发现和通信。

🎓 为什么需要 Agent 训练？

通用 LLM 在特定 Agent 任务上的表现往往不够理想。通过针对性的训练，可以让模型学会更好地使用工具、进行规划和执行复杂任务。

📚 训练范式概述

1. 监督微调（SFT）

使用高质量的 Agent 轨迹数据对模型进行监督训练，让模型学习正确的行为模式。

• 数据格式：（任务，工具调用序列，最终结果）三元组
• 优势：训练稳定，数据利用效率高
• 劣势：需要大量高质量标注数据，难以超越专家演示

2. RLHF（基于人类反馈的强化学习）

通过人类对模型输出的评分来优化模型行为，ChatGPT 使用的核心训练技术。

3. GRPO（Group Relative Policy Optimization）

DeepSeek 提出的高效强化学习算法，是 DeepSeek-R1 成功的关键技术。

• 对同一问题采样多个输出，组内相对评分
• 无需单独的 Critic 模型，显著降低计算成本
• 特别适合数学、代码等有明确正确答案的任务

🛠️ Agent 训练最佳实践

• 从小模型和小数据集开始实验，验证流程正确性
• 奖励函数设计是成败关键，需要仔细思考
• 使用 Weights & Biases 等工具监控训练过程
• 定期在测试集上评估，防止过拟合

📏 为什么评估很重要？

没有评估就没有改进。在 Agent 系统中，评估尤其困难——Agent 的输出往往是多步骤的轨迹，而不是单一的答案，且很多任务没有唯一正确答案。

📊 核心评估维度

• 任务成功率（Task Success Rate）：Agent 完成任务的比例
• 步骤效率（Step Efficiency）：完成任务所需的平均步骤数
• 工具使用准确性（Tool Accuracy）：正确选择和调用工具的比例
• 幻觉率（Hallucination Rate）：模型产生虚假信息的频率
• 成本效率：每次任务的 token 消耗和 API 费用
• 延迟（Latency）：完成任务的平均时间

🏆 主流 Agent 基准测试

• GAIA：测试 Agent 在真实世界任务中的综合能力
• WebArena：评估 Agent 操作 Web 界面的能力
• SWE-bench：评估 Agent 解决真实软件工程问题的能力
• HotPotQA：多跳问答推理评估
• AgentBench：多任务 Agent 综合评测

🔧 评估框架实践

🌍 项目概述

智能旅行助手是一个综合应用 MCP 工具协议和多 Agent 协作技术的实战项目。该系统能够根据用户需求，自动规划行程、查询航班酒店、生成旅行攻略。

🏗️ 系统架构

• 主控 Agent：理解用户意图，协调其他子 Agent
• 航班查询 Agent：通过 MCP 连接航班查询 API
• 酒店推荐 Agent：根据偏好和预算推荐住宿
• 景点规划 Agent：获取目的地景点信息和推荐路线
• 预算计算 Agent：汇总并优化旅行总费用

🔧 核心 MCP 工具

• search_flights(origin, dest, date) — 搜索可用航班
• get_hotels(city, checkin, checkout, budget) — 查询酒店
• get_attractions(city, interests) — 获取景点推荐
• get_weather_forecast(city, dates) — 查询天气预报
• calculate_budget(items) — 计算旅行预算

🔬 什么是 DeepResearch Agent？

DeepResearch 是 OpenAI 推出的深度研究功能，能够自主进行多轮网络搜索、阅读文献、整合信息，最终生成专业水准的研究报告。本章将复现其核心逻辑。

🔁 核心工作流程

• 问题分析：将复杂研究问题分解为可搜索的子问题
• 迭代搜索：多轮搜索，每轮根据上一轮结果优化搜索策略
• 内容提取：从搜索结果中提取关键信息
• 知识整合：将多个来源的信息整合为连贯的知识体系
• 报告生成：基于整合的知识生成结构化研究报告

💡 关键技术点

• 问题分解：使用树状结构将复杂问题分解为子问题
• 查询优化：根据已有知识动态调整搜索查询
• 信息去重：识别和合并来自不同来源的重复信息
• 引用管理：维护信息来源引用，确保报告可溯源

🏙️ 赛博小镇是什么？

赛博小镇（Cyber Town）是受斯坦福大学 "Smallville" 论文启发的多 Agent 社会模拟项目。在一个虚拟小镇中，多个具有独立人格、记忆和目标的 Agent 共同生活，产生涌现的社会行为。

🎮 系统架构

游戏世界

• 地图系统：包含家、咖啡馆、图书馆、公园等场所
• 时间系统：模拟一天 24 小时的时间流逝
• 交互系统：Agent 可以与物品和其他 Agent 交互

Agent 设计

• 角色设定：每个 Agent 有独特的性格、职业、兴趣
• 记忆系统：Agent 记住过去的经历和对话
• 计划系统：Agent 根据目标制定每日计划
• 社交系统：Agent 可以建立关系、进行对话

🎓 毕业设计目标

恭喜你完成了 Hello-Agents 的全部学习内容！毕业设计是你综合运用所学知识，构建一个完整多 Agent 应用的机会。通过这个项目，你将：

• 综合运用 Agent 架构设计、工具调用、记忆系统、多 Agent 协作等知识
• 经历完整的 Agent 应用开发生命周期
• 积累真实的项目经验，丰富个人作品集

📋 毕业设计要求

基础要求（必须完成）

• ✅ 实现至少一个核心 Agent 功能（工具调用、规划等）
• ✅ 集成至少 3 个不同类型的工具
• ✅ 实现基本的记忆/上下文管理
• ✅ 提供清晰的代码文档和 README

进阶要求（可选）

• ⭐ 实现多 Agent 协作
• ⭐ 集成 RAG 知识库
• ⭐ 部署到云端并提供公开访问
• ⭐ 实现 Web 界面

💡 选题建议

🚀 展示与分享

完成毕业设计后，欢迎通过以下方式分享你的成果：

• 提交 PR 到 Co-creation-projects 目录
• 在 Issue 中分享你的项目链接
• 在社交媒体上分享，让更多人了解你的作品