A2UI与AG-UI深度对比：两大AI界面协议的异同与选择

名字相似，目标不同：一个让AI画界面，一个让AI连接应用

开篇：一个容易混淆的问题

如果你最近在关注AI智能体技术，可能会遇到两个名字非常相似的协议：A2UI和AG-UI。

第一次看到这两个名字，很多人都会困惑：

• 这是同一个东西吗？

• 如果不是，它们有什么区别？

• 我应该用哪一个？

这种困惑是完全可以理解的。毕竟，它们的名字只差一个字母，都和"AI"、"UI"有关，而且都是2024-2025年才出现的新协议。

但实际上，A2UI和AG-UI是两个完全不同的协议，解决的是不同层面的问题。

让我用一个简单的比喻来说明：

• A2UI就像是一种"UI设计语言"，告诉前端"应该画一个什么样的界面"

• AG-UI就像是一条"通信管道"，负责在智能体和前端应用之间传递各种信息

一个关注"画什么"，一个关注"怎么传"。

一、核心定位：解决的问题完全不同

1.1 A2UI：UI生成规范

A2UI（Agent-to-User Interface）是Google开源的UI生成协议。

核心问题：如何让AI智能体安全地生成用户界面？

解决方案：提供一种声明式的JSON格式，让智能体可以描述UI结构，而不是直接生成可执行代码。

类比：A2UI就像是建筑设计图纸。智能体是建筑师，画出设计图（JSON），施工队（渲染器）按图施工，建出房子（UI界面）。

// A2UI的典型消息
{
  "surfaceUpdate": {
    "components": [
      {
        "id": "welcome-card",
        "component": {
          "Card": {
            "child": "card-content"
          }
        }
      }
    ]
  }
}

1.2 AG-UI：智能体交互协议

AG-UI（Agent-User Interaction Protocol）是CopilotKit团队开源的智能体交互协议。

核心问题：如何让智能体和前端应用进行实时、双向的通信？

解决方案：提供一套基于事件的协议，标准化智能体和应用之间的所有交互。

类比：AG-UI就像是电话线。它不关心你们聊什么内容（可以是文字、UI、数据等），只负责确保双方能顺畅通话。

// AG-UI的典型事件
{
  type: "message",
  role: "assistant",
  content: "正在为您查找餐厅…"
}

{
  type: "state_sync",
  state: {
    searchResults: […]
  }
}

1.3 关键区别总结

二、技术架构：设计理念的差异

2.1 A2UI的架构：专注UI描述

A2UI的架构非常清晰，专注于UI生成这一件事：

智能体 → 生成A2UI JSON → 传输 → 渲染器 → 原生UI组件

核心组件：

设计特点：

• 纯声明式，无代码执行

• 跨平台，一次生成多处渲染

• 安全第一，白名单机制

2.2 AG-UI的架构：全面的交互层

AG-UI的架构更加复杂，因为它要处理智能体和应用之间的所有交互：

前端应用 ←→ AG-UI协议 ←→ 中间件 ←→ 智能体框架

核心组件：

设计特点：

• 事件驱动，实时双向通信

• 灵活的中间件，适配各种框架

• 全面覆盖，不仅仅是UI

2.3 架构对比

A2UI的架构：

┌─────────────┐
│   智能体    │
└──────┬──────┘
       │ 生成A2UI JSON
       ↓
┌─────────────┐
│  传输层     │ (任意方式)
└──────┬──────┘
       │
       ↓
┌─────────────┐
│  渲染器     │
└──────┬──────┘
       │
       ↓
┌─────────────┐
│  原生UI     │
└─────────────┘

AG-UI的架构：

┌─────────────┐         ┌─────────────┐
│  前端应用   │←─事件─→│  AG-UI协议  │
└─────────────┘         └──────┬──────┘
                               │
                        ┌──────┴──────┐
                        │  中间件层   │
                        └──────┬──────┘
                               │
                        ┌──────┴──────┐
                        │ 智能体框架  │
                        └─────────────┘

三、功能范围：一个专注，一个全面

3.1 A2UI的功能：纯粹的UI生成

A2UI专注于UI生成，提供的功能都围绕这个核心：

1. UI组件定义

{
  "id": "restaurant-card",
  "component": {
    "Card": {
      "child": "card-content"
    }
  }
}

2. 数据绑定

{
  "id": "restaurant-name",
  "component": {
    "Text": {
      "text": {"path": "/restaurant/name"}
    }
  }
}

3. 动态列表

{
  "id": "restaurant-list",
  "component": {
    "List": {
      "children": {
        "template": {
          "componentId": "restaurant-card",
          "dataBinding": "/restaurants"
        }
      }
    }
  }
}

4. 用户交互

{
  "id": "book-button",
  "component": {
    "Button": {
      "action": {"name": "book_restaurant"}
    }
  }
}

仅此而已。A2UI不关心：

• 消息如何传输

• 状态如何管理

• 工具如何调用

• 会话如何维护

这些都是其他层的责任。

3.2 AG-UI的功能：全面的交互支持

AG-UI提供了智能体和应用交互所需的几乎所有功能：

1. 流式聊天

{
  type: "message",
  role: "assistant",
  content: "正在为您查找…",
  streaming: true
}

2. 状态同步

{
  type: "state_sync",
  state: {
    searchQuery: "中餐厅",
    results: […]
  }
}

3. 生成式UI

{
  type: "generative_ui",
  component: "RestaurantCard",
  props: {…}
}

4. 工具调用

{
  type: "tool_call",
  tool: "search_restaurants",
  arguments: {…}
}

5. 前端工具

{
  type: "frontend_action",
  action: "open_map",
  params: {…}
}

6. 人机协作（HITL）

{
  type: "interrupt",
  reason: "需要用户确认",
  options: […]
}

7. 思考步骤

{
  type: "thinking",
  content: "正在分析用户需求…"
}

8. 多模态支持

{
  type: "message",
  content: "这是餐厅照片",
  attachments: [{
    type: "image",
    url: "…"
  }]
}

AG-UI几乎涵盖了智能体应用的所有交互需求。

3.3 功能对比表

四、生态系统：不同的发展路径

4.1 A2UI的生态：跨平台渲染

A2UI的生态围绕渲染器展开：

已支持的渲染器：

• Lit（Web Components）：框架无关

• Angular：完整集成

• Flutter（GenUI SDK）：跨平台

• React：开发中（2026 Q1）

计划中的渲染器：

• SwiftUI（iOS/macOS）

• Jetpack Compose（Android）

• Vue

• ShadCN

集成方式：

// 使用Lit渲染器
import { A2UIRenderer } from '@a2ui/lit';

const renderer = new A2UIRenderer();
renderer.processMessage(a2uiMessage);

特点：

• 专注于渲染层

• 跨平台是核心优势

• 与智能体框架无关

4.2 AG-UI的生态：智能体框架集成

AG-UI的生态围绕智能体框架展开：

合作伙伴：

• LangGraph：官方支持

• CrewAI：官方支持

一方支持：

• Microsoft Agent Framework

• Google ADK

• AWS Strands Agents

• Mastra

• Pydantic AI

• Agno

• LlamaIndex

• AG2

社区支持：

• Vercel AI SDK

• OpenAI Agent SDK（开发中）

• Cloudflare Agents（开发中）

集成方式：

# 使用LangGraph中间件
from copilotkit import CopilotKitSDK

sdk = CopilotKitSDK(
    agents=[my_langgraph_agent]
)

特点：

• 专注于智能体集成

• 广泛的框架支持

• 提供完整的交互能力

4.3 生态对比

A2UI的生态图：

        A2UI协议
           │
    ┌──────┼──────┐
    │      │      │
  Lit   Angular Flutter
    │      │      │
  Web    Web   跨平台

AG-UI的生态图：

           AG-UI协议
               │
    ┌──────────┼──────────┐
    │          │          │
LangGraph   CrewAI    其他框架
    │          │          │
  Python    Python   多语言

五、使用场景：各有所长

5.1 A2UI适合的场景

场景1：跨平台UI生成

如果你需要同一个智能体在多个平台上运行：

智能体生成A2UI
  ├─ Web端：Lit渲染
  ├─ 移动端：Flutter渲染
  └─ 桌面端：React渲染

场景2：安全要求高的环境

如果你不信任智能体生成的代码：

• 金融应用

• 医疗系统

• 企业内部工具

A2UI的白名单机制提供了最高级别的安全保障。

场景3：UI为主的应用

如果你的应用主要是展示和收集信息：

• 表单生成

• 数据可视化

• 内容展示

A2UI提供了丰富的UI组件和灵活的布局能力。

场景4：与现有系统集成

如果你已经有了智能体后端，只需要UI生成能力：

现有智能体 → 添加A2UI生成 → 前端渲染

5.2 AG-UI适合的场景

场景1：全功能智能体应用

如果你需要构建完整的智能体应用：

• 实时聊天

• 状态同步

• 工具调用

• 人机协作

AG-UI提供了一站式解决方案。

场景2：使用主流智能体框架

如果你正在使用：

• LangGraph

• CrewAI

• Microsoft Agent Framework

• Google ADK

AG-UI提供了开箱即用的集成。

场景3：复杂的交互流程

如果你的应用有复杂的交互：

• 多轮对话

• 中断和恢复

• 子智能体调用

• 前端工具执行

AG-UI的事件系统可以优雅地处理这些场景。

场景4：快速原型开发

如果你想快速搭建智能体应用：

npx create-ag-ui-app my-app

AG-UI提供了完整的脚手架和示例。

5.3 场景对比表

六、协议栈位置：互补而非竞争

6.1 智能体协议栈

要理解A2UI和AG-UI的关系，需要先了解完整的智能体协议栈：

┌─────────────────────────────────┐
│      用户界面层                  │
│  (A2UI专注于这一层)              │
├─────────────────────────────────┤
│      交互协议层                  │
│  (AG-UI专注于这一层)             │
├─────────────────────────────────┤
│      智能体编排层                │
│  (A2A协议)                      │
├─────────────────────────────────┤
│      工具和数据层                │
│  (MCP协议)                      │
└─────────────────────────────────┘

各层职责：

6.2 A2UI和AG-UI的关系

它们不是竞争关系，而是互补关系。

方式1：AG-UI可以传输A2UI消息

// AG-UI事件中包含A2UI消息
{
  type: "generative_ui",
  format: "a2ui",
  content: {
    surfaceUpdate: {
      components: […]
    }
  }
}

AG-UI的generative_ui事件可以使用A2UI作为UI描述格式。

方式2：A2UI可以通过AG-UI传输

智能体 → 生成A2UI → AG-UI协议传输 → 前端渲染

A2UI消息可以作为AG-UI事件流的一部分传输。

方式3：独立使用

// 只用A2UI
智能体 → A2UI → HTTP/WebSocket → 渲染器

// 只用AG-UI
智能体 → AG-UI → 前端应用

它们也可以完全独立使用。

6.3 实际集成示例

示例1：AG-UI + A2UI

# 智能体端（Python）
from copilotkit import CopilotKitSDK
from a2ui import A2UIGenerator

# 生成A2UI消息
a2ui_message = A2UIGenerator.create_card(
    title="餐厅推荐",
    content="…"
)

# 通过AG-UI发送
sdk.emit_event({
    "type": "generative_ui",
    "format": "a2ui",
    "content": a2ui_message
})

// 前端（TypeScript）
import { useCopilotKit } from '@copilotkit/react';
import { A2UIRenderer } from '@a2ui/react';

function MyApp() {
  const { events } = useCopilotKit();
  
  return events.map(event => {
    if (event.type === 'generative_ui' && event.format === 'a2ui') {
      return <A2UIRenderer message={event.content} />;
    }
  });
}

示例2：只用A2UI

# 智能体端
from a2ui import A2UIGenerator

a2ui_message = A2UIGenerator.create_form(…)

# 通过任意方式发送（HTTP、WebSocket等）
send_to_client(a2ui_message)

// 前端
import { A2UIRenderer } from '@a2ui/lit';

const renderer = new A2UIRenderer();
renderer.processMessage(a2ui_message);

七、开发体验：不同的学习曲线

7.1 A2UI的学习曲线

入门难度：⭐⭐⭐（中等）

需要学习：

优势：

• 概念清晰，专注UI

• 文档完善

• 示例丰富

挑战：

• 邻接表模型对初学者不直观

• 需要理解声明式UI的思维方式

学习路径：

1. 理解基本概念（1-2小时）
2. 运行官方Demo（30分钟）
3. 学习组件定义（2-3小时）
4. 掌握数据绑定（2-3小时）
5. 实践项目（1-2天）

7.2 AG-UI的学习曲线

入门难度：⭐⭐（较低）

需要学习：

优势：

• 快速上手，脚手架完善

• 与主流框架集成简单

• 社区活跃，资源丰富

挑战：

• 功能多，需要时间掌握全部特性

• 不同框架的集成方式略有差异

学习路径：

1. 快速开始（30分钟）
   npx create-ag-ui-app my-app
   
2. 理解核心概念（1-2小时）
3. 学习事件系统（2-3小时）
4. 掌握状态管理（2-3小时）
5. 探索高级特性（3-5天）

7.3 开发体验对比

八、性能考量：各有优化重点

8.1 A2UI的性能特点

优势：

性能优化：

// 只更新变化的数据
{
  "dataModelUpdate": {
    "path": "/restaurant/rating",
    "contents": [
      {"key": "rating", "valueNumber": 4.8}
    ]
  }
}

性能瓶颈：

• 大量组件时，JSON解析可能成为瓶颈

• 复杂的数据绑定可能影响渲染性能

优化建议：

8.2 AG-UI的性能特点

优势：

性能优化：

// 流式发送事件
for await (const chunk of agent.stream()) {
  sdk.emit_event({
    type: "message",
    content: chunk,
    streaming: true
  });
}

性能瓶颈：

• 大量事件时，事件处理可能成为瓶颈

• 状态同步的冲突解决可能影响性能

优化建议：

8.3 性能对比

九、社区和支持：不同的发展阶段

9.1 A2UI的社区状态

发起方：Google

开源时间：2024年底（v0.8公开预览）

开源协议：Apache 2.0

社区规模：

• GitHub Stars：~1k+

• 贡献者：Google团队 + 社区

• 活跃度：中等

主要贡献者：

• Google核心团队

• Flutter团队（GenUI SDK）

• Angular团队

• CopilotKit团队（AG UI集成）

社区资源：

• 官方文档：完善

• 示例项目：丰富

• Discord社区：活跃度中等

发展阶段：早期，快速迭代中

9.2 AG-UI的社区状态

发起方：CopilotKit

开源时间：2024年中（从CopilotKit演化而来）

开源协议：MIT

社区规模：

• GitHub Stars：~11k+

• 贡献者：60+

• 活跃度：非常活跃

主要贡献者：

• CopilotKit团队

• LangChain/LangGraph团队

• CrewAI团队

• 广泛的社区贡献者

社区资源：

• 官方文档：非常完善

• 示例项目：非常丰富（AG-UI Dojo）

• Discord社区：非常活跃

• 双周工作组会议

发展阶段：成熟，生态丰富

9.3 社区对比

十、未来发展：不同的路线图

10.1 A2UI的发展规划

短期（2026 Q1-Q2）：

长期（2026 Q4+）：

10.2 AG-UI的发展规划

短期（2026 Q1-Q2）：

长期（2026+）：

10.3 发展趋势对比

十一、选择建议：如何做决策

11.1 决策树

开始
  │
  ├─ 只需要UI生成？
  │   └─ 是 → 考虑A2UI
  │       ├─ 需要跨平台？
  │       │   └─ 是 → 强烈推荐A2UI
  │       └─ 安全要求高？
  │           └─ 是 → 强烈推荐A2UI
  │
  └─ 需要完整的智能体交互？
      └─ 是 → 考虑AG-UI
          ├─ 使用主流框架？
          │   └─ 是 → 强烈推荐AG-UI
          └─ 需要快速原型？
              └─ 是 → 强烈推荐AG-UI

11.2 具体场景建议

场景1：企业内部工具

需求：
– 安全性要求高
– 需要跨平台（Web + 移动）
– UI为主，交互简单

推荐：A2UI
理由：安全性高，跨平台能力强

场景2：智能客服系统

需求：
– 实时对话
– 复杂的交互流程
– 需要人机协作
– 使用LangGraph

推荐：AG-UI
理由：功能全面，LangGraph集成完善

场景3：数据分析助手

需求：
– 动态生成图表
– 跨平台展示
– 安全性要求高

推荐：A2UI
理由：专注UI生成，跨平台能力强

场景4：AI助手应用

需求：
– 多轮对话
– 工具调用
– 状态同步
– 快速开发

推荐：AG-UI
理由：一站式解决方案，开发效率高

场景5：混合使用

需求：
– 需要AG-UI的交互能力
– 需要A2UI的跨平台UI

推荐：AG-UI + A2UI
理由：两者可以完美结合

11.3 技术栈考量

如果你的技术栈是：

11.4 团队能力考量

团队特点与选择：

十二、实战对比：同一个需求的不同实现

让我们通过一个实际案例，看看两个协议如何实现同样的功能。

12.1 需求描述

场景：餐厅推荐智能体

功能：

12.2 使用A2UI实现

智能体端（Python）：

from a2ui import A2UIGenerator

class RestaurantAgent:
    def handle_search(self, query):
        # 1. 查询数据库
        restaurants = self.search_restaurants(query)
        
        # 2. 生成A2UI消息
        messages = []
        
        # 定义UI结构
        messages.append({
            "surfaceUpdate": {
                "surfaceId": "main",
                "components": [
                    {
                        "id": "restaurant-list",
                        "component": {
                            "List": {
                                "children": {
                                    "template": {
                                        "componentId": "restaurant-card",
                                        "dataBinding": "/restaurants"
                                    }
                                }
                            }
                        }
                    },
                    {
                        "id": "restaurant-card",
                        "component": {
                            "Card": {
                                "child": "card-content"
                            }
                        }
                    },
                    # … 更多组件定义
                ]
            }
        })
        
        # 填充数据
        messages.append({
            "dataModelUpdate": {
                "surfaceId": "main",
                "path": "/",
                "contents": [
                    {
                        "key": "restaurants",
                        "valueMap": [
                            {
                                "key": str(i),
                                "valueMap": [
                                    {"key": "name", "valueString": r["name"]},
                                    {"key": "rating", "valueNumber": r["rating"]}
                                ]
                            }
                            for i, r in enumerate(restaurants)
                        ]
                    }
                ]
            }
        })
        
        # 触发渲染
        messages.append({
            "beginRendering": {
                "surfaceId": "main",
                "root": "restaurant-list"
            }
        })
        
        return messages

前端（TypeScript）：

import { A2UIRenderer } from '@a2ui/lit';

class RestaurantApp {
    private renderer: A2UIRenderer;
    
    constructor() {
        this.renderer = new A2UIRenderer();
    }
    
    async searchRestaurants(query: string) {
        // 调用智能体
        const response = await fetch('/api/agent/search', {
            method: 'POST',
            body: JSON.stringify({ query })
        });
        
        // 处理A2UI消息
        const messages = await response.json();
        for (const message of messages) {
            this.renderer.processMessage(message);
        }
    }
}

特点：

• ✅ 代码清晰，职责分明

• ✅ 跨平台，可以用不同渲染器

• ❌ 需要自己处理传输层

• ❌ 需要自己处理状态管理

12.3 使用AG-UI实现

智能体端（Python）：

from copilotkit import CopilotKitSDK, Action

sdk = CopilotKitSDK()

@sdk.action()
async def search_restaurants(query: str):
    """搜索餐厅"""
    
    # 1. 发送思考状态
    yield {
        "type": "thinking",
        "content": "正在搜索餐厅…"
    }
    
    # 2. 查询数据库
    restaurants = await db.search(query)
    
    # 3. 更新状态
    yield {
        "type": "state_sync",
        "state": {
            "restaurants": restaurants
        }
    }
    
    # 4. 生成UI（可以使用A2UI格式）
    yield {
        "type": "generative_ui",
        "component": "RestaurantList",
        "props": {
            "restaurants": restaurants
        }
    }
    
    # 5. 发送消息
    yield {
        "type": "message",
        "role": "assistant",
        "content": f"为您找到{len(restaurants)}家餐厅"
    }

@sdk.action()
async def book_restaurant(restaurant_id: str, party_size: int, datetime: str):
    """预订餐厅"""
    
    # 1. 生成表单UI
    yield {
        "type": "generative_ui",
        "component": "BookingForm",
        "props": {
            "restaurantId": restaurant_id,
            "partySize": party_size,
            "datetime": datetime
        }
    }

前端（TypeScript）：

import { useCopilotKit } from '@copilotkit/react';

function RestaurantApp() {
    const { 
        messages, 
        state, 
        sendMessage,
        isLoading 
    } = useCopilotKit();
    
    return (
        <div>
            {/* 聊天界面 */}
            <ChatMessages messages={messages} />
            
            {/* 状态驱动的UI */}
            {state.restaurants && (
                <RestaurantList restaurants={state.restaurants} />
            )}
            
            {/* 输入框 */}
            <ChatInput 
                onSend={sendMessage}
                disabled={isLoading}
            />
        </div>
    );
}

特点：

• ✅ 功能全面，一站式解决方案

• ✅ 状态管理自动化

• ✅ 实时流式响应

• ❌ 与CopilotKit绑定

• ❌ 跨平台能力较弱

12.4 实现对比

十三、常见误区：澄清混淆

误区1："A2UI和AG-UI是竞争关系"

真相：它们是互补关系，解决不同层面的问题。

• A2UI专注UI生成

• AG-UI专注智能体交互

• 可以单独使用，也可以组合使用

误区2："AG-UI包含了A2UI的所有功能"

真相：AG-UI支持生成式UI，但不等于A2UI。

• AG-UI的generative_ui是一个通用机制

• 可以使用A2UI作为UI描述格式

• 也可以使用其他格式（React组件、自定义格式等）

误区3："A2UI只能用于Google的项目"

真相：A2UI是开源协议，任何人都可以使用。

• Apache 2.0协议

• 框架无关

• 可以与任何智能体框架集成

误区4："AG-UI只能用于CopilotKit"

真相：AG-UI是开放协议，支持多种框架。

• 支持LangGraph、CrewAI等

• 可以自己实现中间件

• 不强制使用CopilotKit客户端

误区5："选择了一个就不能用另一个"

真相：两者可以完美结合。

// AG-UI传输 + A2UI描述UI
{
  type: "generative_ui",
  format: "a2ui",
  content: {
    surfaceUpdate: {…}
  }
}

十四、总结：理性选择，合理使用

14.1 核心差异总结

A2UI：

• 🎯 定位：UI生成规范

• 🔧 核心：声明式组件描述

• 🌍 优势：跨平台、安全性

• 📦 生态：渲染器为主

• 🎓 学习：中等难度

• 🚀 适合：UI为主的应用

AG-UI：

• 🎯 定位：智能体交互协议

• 🔧 核心：事件驱动通信

• 🌍 优势：功能全面、集成简单

• 📦 生态：智能体框架为主

• 🎓 学习：较低难度

• 🚀 适合：全功能智能体应用

14.2 选择建议

选择A2UI，如果你：

• ✅ 需要跨平台UI生成

• ✅ 安全性要求高

• ✅ 想要框架无关的解决方案

• ✅ 专注于UI展示和数据收集

• ✅ 有自己的智能体后端

选择AG-UI，如果你：

• ✅ 需要完整的智能体交互能力

• ✅ 使用主流智能体框架

• ✅ 需要快速开发原型

• ✅ 需要实时双向通信

• ✅ 想要一站式解决方案

同时使用，如果你：

• ✅ 需要AG-UI的交互能力

• ✅ 需要A2UI的跨平台UI

• ✅ 想要最大的灵活性

14.3 未来展望

A2UI的未来：

• 成为跨平台UI生成的标准

• 更多渲染器支持

• 更丰富的组件库

• 更好的开发工具

AG-UI的未来：

• 成为智能体交互的事实标准

• 更广泛的框架支持

• 更强大的功能

• 更完善的生态

两者的关系：

• 互补而非竞争

• 可能会有更深度的集成

• 共同推动智能体应用的发展

14.4 最后的建议

结语

A2UI和AG-UI代表了AI时代UI开发的两个重要方向：

• A2UI让AI学会了"画"界面

• AG-UI让AI学会了"连接"应用

它们不是竞争对手，而是合作伙伴。选择哪一个，或者两者都用，取决于你的具体需求。

重要的是，它们都在推动一个共同的目标：让AI智能体能够更好地与人类交互。

在这个激动人心的AI时代，让我们一起探索、实践、创新！

参考资源：

A2UI：

• GitHub：https://github.com/google/A2UI

• 文档：https://google.github.io/A2UI/

• Discord：（查看GitHub）

AG-UI：

• GitHub：https://github.com/ag-ui-protocol/ag-ui

• 文档：https://docs.ag-ui.com/

• Discord：https://discord.gg/Jd3FzfdJa8

• Dojo：https://dojo.ag-ui.com/

更多AIGC文章

RAG技术全解：从原理到实战的简明指南

更多VibeCoding文章