从入门到精通：深度解析 Agent、Function Calling、MCP 与 A2A 技术体系

目录

  1. 为什么选择这篇指南？
  2. 核心概念全景图：四者关系与技术演进
  3. Agent（智能代理）
    3.1 定义与核心本质
    3.2 技术栈深度拆解
    3.3 实战：从零构建天气问答 Agent
  4. Function Calling（函数调用）
    4.1 定义与技术本质
    4.2 与 Agent 的底层关系
    4.3 实战：用 OpenAI tools 接口实现天气查询
  5. MCP（Model Context Protocol）
    5.1 定义与核心价值
    5.2 与 Function Calling 的关键差异
    5.3 实战：构建 MCP 服务端与客户端
  6. A2A（Agent-to-Agent）通信
    6.1 定义与技术内核
    6.2 协议规范、消息格式与生命周期
    6.3 实战：多 Agent 协作完成旅行规划
  7. 综合案例：旅行规划全家桶系统
  8. 避坑指南与性能优化策略
  9. 参考资料

1. 为什么选择这篇指南？

  • 市面上多数文章要么停留在概念科普，要么深陷代码细节，缺乏一条贯穿「理论认知 → 协议理解 → 实战开发 → 生产部署」的完整学习路径。
  • 本文通过 1.5 万字深度解析 + 8 张核心架构图 + 3 个可直接运行的实战项目，帮助你系统性掌握这四项重塑 AI 应用形态的关键技术。

2. 核心概念全景图：四者关系与技术演进

在这里插入图片描述

图 1：Agent、Function Calling、MCP 与 A2A 的技术关系与演进路径

  • Agent 是具备「感知-决策-执行-记忆」能力的完整智能体（类比：拥有大脑和手脚的机器人）。
  • Function Calling 是智能体与外部世界交互的基础机制（类比：机器人的神经反射弧）。
  • MCP 是标准化的智能体工具接入协议（类比：电子设备的 USB-C 接口，实现跨平台兼容）。
  • A2A 是智能体之间协同工作的通信规范（类比：人类协作的语言与沟通规则）。

3. Agent（智能代理）

3.1 定义与核心本质

Agent 是一个能够自主感知环境、做出决策、执行动作并积累经验的闭环智能系统，核心公式可表达为：
Agent = LLM（认知核心） + Memory（经验存储） + Tools（交互接口） + Planning（任务规划） + Action（执行引擎）

其本质特征体现在四个方面：

  • 自主性：无需持续人工干预即可完成设定目标
  • 环境交互：能感知外部信息并做出相应反应
  • 动态学习：通过记忆模块积累经验并优化行为
  • 目标导向：具备规划能力以实现复杂任务

3.2 技术栈深度拆解

核心模块 开源实现方案 商业服务选项 典型应用场景
LLM（认知核心） Llama-3-70B、Mistral Large GPT-4o、Claude 3 Opus 自然语言理解、逻辑推理
Memory（记忆系统） Zep（长时记忆）、MemGPT（记忆管理） Pinecone、Weaviate 对话历史存储、经验积累
Tools（工具集） LangChain Tool、OpenAI Function Zapier（自动化工具）、Make 外部系统交互、功能扩展
Planning（任务规划） ReAct（思维链）、Reflexion（反思机制） AutoGPT、CrewAI 复杂任务拆解、步骤规划
Action（执行引擎） Local Python、Docker 容器 e2b（沙箱环境）、Modal（云函数） 代码执行、硬件控制

3.3 实战：从零构建天气问答 Agent

以「智能天气问答 Agent」为例，我们将使用 Python 语言和 OpenAI 模型，完整实现一个能查询天气并回答用户问题的智能体。

步骤 1：环境准备

首先安装必要的依赖库：

pip install openai langchain python-dotenv  # openai：LLM 接口；langchain：Agent 框架；dotenv：环境变量管理

创建 .env 文件存储 API 密钥：

OPENAI_API_KEY=your_actual_api_key_here
步骤 2：定义工具函数

创建 weather_tool.py，实现天气查询工具：

# weather_tool.py
import requests

def get_weather(city: str) -> str:
    """
    获取指定城市的当前天气信息
    
    参数:
        city: 城市名称（英文或拼音，如 Beijing、Shanghai）
    
    返回:
        天气描述字符串，格式为"天气状况 + 温度"，如"Sunny +25°C"
    """
    # 使用 wttr.in 提供的免费天气 API
    url = f"https://wttr.in/{city}?format=%C+%t"  # %C：天气状况；%t：温度
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()  # 检查请求是否成功
        return response.text.strip()
    except Exception as e:
        return f"获取天气失败：{str(e)}"
步骤 3：构建并运行 Agent

创建 agent.py，组装 Agent 核心逻辑：

# agent.py
import os
from dotenv import load_dotenv
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import Tool
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
from weather_tool import get_weather

# 加载环境变量
load_dotenv()

# 1. 定义提示词模板（指导 Agent 思考和行动）
prompt = PromptTemplate.from_template("""
你是一个智能天气助手，需要回答用户关于天气的问题。
如果需要查询天气，请使用提供的工具。
思考过程要清晰，先判断是否需要调用工具，再执行相应操作。

问题：{input}
""")

# 2. 注册工具（将天气查询函数封装为 Agent 可调用的工具）
tools = [
    Tool(
        name="get_weather",  # 工具名称
        func=get_weather,   # 绑定的函数
        description="当需要获取某个城市的天气信息时使用，参数为城市名称"  # 工具描述（关键！帮助 LLM 判断何时使用）
    )
]

# 3. 初始化 LLM 和 Agent
llm = ChatOpenAI(model="gpt-4o", temperature=0)  # temperature=0 确保输出更确定
agent = create_react_agent(llm=llm, tools=tools, prompt=prompt)  # 创建 ReAct 模式的 Agent
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)  # 执行器（verbose=True 显示思考过程）

# 4. 运行 Agent 处理用户查询
if __name__ == "__main__":
    user_query = "北京今天的天气怎么样？"
    result = agent_executor.invoke({"input": user_query})
    print(f"\n最终回答：{result['output']}")
运行结果与解析

执行 python agent.py 后，输出如下（包含详细思考过程）：

> Entering new AgentExecutor chain...
用户问的是北京今天的天气，我需要调用get_weather工具来获取。
Action: get_weather
Action Input: {"city": "Beijing"}
Observation: Sunny +25°C
我已经获取了北京的天气信息，是晴天，25摄氏度。可以直接整理成自然语言回答用户。
Final Answer: 北京今天天气晴朗，气温25°C。

最终回答：北京今天天气晴朗，气温25°C。

关键解析：

  • Agent 通过 verbose=True 展示了完整的「思考-行动-观察-总结」流程
  • create_react_agent 采用 ReAct 框架，让 LLM 像人类一样「边想边做」
  • 工具描述（description）是决定 Agent 能否正确调用工具的关键因素

4. Function Calling（函数调用）

4.1 定义与技术本质

Function Calling 是大语言模型（LLM）与外部系统交互的标准化机制，由 OpenAI 于 2023 年 6 月首次推出。其核心流程为：
用户提问 → LLM 判定需要调用工具 → 生成结构化函数调用指令 → 执行函数获取结果 → LLM 整理结果并回答

技术本质是将自然语言理解转化为可执行的程序指令，解决了两大核心问题：

  1. 突破 LLM 自身知识截止（knowledge cutoff）限制，获取实时/私有数据
  2. 让 LLM 从「文本生成」扩展到「实际操作」，实现与外部系统的闭环交互

4.2 与 Agent 的关系

  • Function Calling 是 Agent 实现「Action（执行）」模块的底层技术支撑
  • 单一 Function Calling 只能完成单次工具调用，而 Agent 在此基础上增加了「记忆（Memory）」和「规划（Planning）」能力，可完成多步骤复杂任务
  • 类比关系：Function Calling 相当于人类的「单次动作」，而 Agent 相当于具备「记忆、思考和连续动作」能力的完整人类

4.3 实战：用原生 OpenAI tools 接口实现天气查询

绕过 LangChain 等框架，直接使用 OpenAI 原生 API 实现 Function Calling，深入理解其工作原理。

import openai
import json
import requests
from dotenv import load_dotenv
import os

# 加载环境变量
load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# 1. 定义工具函数（与 Agent 示例中相同）
def get_weather(city: str) -> str:
    """获取指定城市的当前天气信息"""
    url = f"https://wttr.in/{city}?format=%C+%t"
    try:
        return requests.get(url, timeout=5).text.strip()
    except Exception as e:
        return f"获取天气失败：{str(e)}"

# 2. 定义工具描述（告诉 LLM 有哪些工具可用及如何调用）
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",  # 必须与实际函数名一致
            "description": "获取指定城市的当前天气状况和温度",  # LLM 判断是否调用的依据
            "parameters": {  # 函数参数的 JSON Schema 定义
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称（如北京、Shanghai）"
                    }
                },
                "required": ["city"]  # 必传参数
            }
        }
    }
]

# 3. 用户提问与首次交互（判断是否需要调用工具）
user_query = "上海现在的天气如何？"
messages = [{"role": "user", "content": user_query}]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto"  # 让模型自动决定是否调用工具
)

# 4. 解析工具调用指令并执行
response_message = response.choices[0].message
if response_message.tool_calls:  # 检查是否需要调用工具
    # 提取工具调用信息
    tool_call = response_message.tool_calls[0]
    function_name = tool_call.function.name
    function_args = json.loads(tool_call.function.arguments)
    
    # 执行函数（实际应用中应做安全校验，避免直接执行未知函数）
    if function_name == "get_weather":
        weather_result = get_weather(** function_args)
    else:
        weather_result = f"未知工具：{function_name}"
    
    # 5. 将工具返回结果送回 LLM 生成最终回答
    messages.append(response_message)  # 添加模型的工具调用指令
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": weather_result  # 工具返回结果
    })
    
    # 生成最终回答
    final_response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages
    )
    print(final_response.choices[0].message.content)

运行输出：

上海目前的天气为多云，气温28°C。

核心要点：

  • tools 参数必须严格遵循 JSON Schema 格式，否则 LLM 无法正确解析
  • 工具调用结果需通过 tool 角色消息送回模型，形成完整闭环
  • 生产环境中需添加函数调用白名单、参数校验等安全机制

5. MCP（Model Context Protocol）

5.1 定义与核心价值

MCP（Model Context Protocol）是由 Anthropic 于 2024 年 11 月开源的模型与外部系统通信的开放协议，旨在解决不同 AI 模型与工具生态之间的兼容性问题。

其核心价值体现在：

  • 开放性：采用 MIT 许可证，任何组织和个人均可免费使用和扩展
  • 多功能性：支持函数调用、文件系统访问、数据库操作等复杂交互
  • 多传输方式：兼容 stdio（标准输入输出）、SSE（服务器发送事件）、WebSocket 等多种通信方式
  • 生态丰富性：官方已支持 Postgres、GitHub、Slack 等主流系统的集成

5.2 与 Function Calling 的区别

对比维度 OpenAI Function Calling MCP（Model Context Protocol）
协议性质 私有协议（仅 OpenAI 生态） 开放协议（跨模型、跨平台）
交互能力 单次函数调用为主 支持多轮对话、双向流、事务操作
传输层支持 仅 HTTP/JSON stdio、SSE、WebSocket、HTTP
安全机制 依赖 API 密钥 支持加密传输、权限控制
生态兼容性 主要支持 OpenAI 模型 兼容 Claude、GPT、Llama 等主流模型
典型应用 简单工具调用 复杂系统集成、跨模型协作

形象类比：

  • Function Calling 如同「专用接口」，只能连接特定品牌的设备
  • MCP 如同「通用 USB-C 接口」，可连接不同品牌、不同类型的设备

5.3 实战：构建 MCP 服务端与客户端

我们将实现一个简单的数学计算 MCP 服务，并通过客户端调用其加法功能。

步骤 1：安装 MCP 库
pip install mcp  # Anthropic 官方提供的 MCP 协议实现库
步骤 2：编写 MCP 服务端（stdio 模式）

创建 math_server.py：

# math_server.py
from mcp.server import Server
import asyncio

# 初始化 MCP 服务，命名为 "math_service"
app = Server("math_service")

# 注册工具函数（使用 @app.call_tool() 装饰器）
@app.call_tool()
async def add(a: int, b: int) -> int:
    """
    计算两个整数的和
    
    参数:
        a: 第一个整数
        b: 第二个整数
    
    返回:
        两个整数的和
    """
    return a + b

@app.call_tool()
async def multiply(a: int, b: int) -> int:
    """计算两个整数的乘积"""
    return a * b

# 以 stdio 模式运行服务（通过标准输入输出通信）
if __name__ == "__main__":
    asyncio.run(app.run_stdio())
步骤 3：编写 MCP 客户端

创建 mcp_client.py：

# mcp_client.py
from mcp import Client
import asyncio

async def main():
    # 连接到 MCP 服务：指定服务启动命令和传输方式
    client = Client(
        command="python math_server.py",  # 启动服务的命令
        transport="stdio"  # 使用 stdio 传输
    )
    
    # 建立连接
    await client.connect()
    
    # 调用服务中的 add 工具
    add_result = await client.call_tool("add", {"a": 3, "b": 4})
    print(f"3 + 4 = {add_result}")
    
    # 调用服务中的 multiply 工具
    mul_result = await client.call_tool("multiply", {"a": 5, "b": 6})
    print(f"5 × 6 = {mul_result}")
    
    # 关闭连接
    await client.disconnect()

if __name__ == "__main__":
    asyncio.run(main())
运行与输出
$ python mcp_client.py
3 + 4 = 7
5 × 6 = 30

关键特性解析：

  • stdio 模式适合本地轻量级应用，无需网络通信
  • 服务端可同时提供多个工具函数，客户端按需调用
  • MCP 自动处理参数序列化/反序列化，无需手动解析 JSON

6. A2A（Agent-to-Agent）通信

6.1 定义与技术内核

A2A（Agent-to-Agent）是 Google 于 2025 年 5 月提出的多智能体通信协议，旨在解决不同 Agent 之间的协同工作问题。
在这里插入图片描述

图 2：A2A 的工作原理

其技术内核包括：

  • 标准化消息格式：结合自然语言描述与结构化数据（JSON Schema），兼顾可读性与机器可解析性
  • 灵活通信模式：支持请求-响应、发布-订阅、广播、点对点等多种交互方式
  • 高级协作机制：内置协商、任务竞标、并行执行、投票决策等协同策略
  • 高效传输层：基于 HTTP/2 和 Server-Sent Events（SSE），支持流式通信和低延迟交互

6.2 协议规范、消息格式与生命周期

核心消息格式

A2A 消息采用 JSON 格式，最小化结构包含以下字段：

{
  "id": "msg_20250804_001",  // 消息唯一标识符（UUID 推荐）
  "from": "agent.travel.planner",  // 发送方 Agent 标识
  "to": "agent.hotel.booker",      // 接收方 Agent 标识（支持广播："*"）
  "type": "request",  // 消息类型：request/response/error/notification
  "intent": "book_hotel",  // 消息意图（描述要执行的操作）
  "payload": {  // 业务数据（根据 intent 定义结构）
    "city": "Tokyo",
    "checkin_date": "2025-09-01",
    "guests": 2
  },
  "timestamp": "2025-08-04T12:00:00Z"  // 消息创建时间
}
完整生命周期
  1. 创建（Creation）：发送方 Agent 生成符合格式的消息
  2. 传输（Transmission）：通过 A2A 路由器转发（支持加密）
  3. 验证（Validation）：接收方验证消息格式和权限
  4. 处理（Processing）：接收方执行相应操作
  5. 响应（Response）：返回处理结果（可选）
  6. 确认（Acknowledgment）：发送方确认接收结果（可选）

在这里插入图片描述

6.3 实战：多 Agent 协作完成旅行规划

我们将实现两个 Agent：「规划师 Agent」和「酒店预订 Agent」，通过 A2A 协议协作完成旅行酒店预订。

项目结构
travel_agents/
├── planner_agent.py   # 旅行规划师 Agent（发起预订请求）
├── hotel_agent.py     # 酒店预订 Agent（处理预订请求）
└── requirements.txt   # 依赖清单
步骤 1：安装依赖
# requirements.txt
fastapi==0.110.0
uvicorn==0.29.0
httpx==0.27.0
pydantic==2.7.1

# 安装命令
pip install -r requirements.txt
步骤 2：实现酒店预订 Agent（服务端）

创建 hotel_agent.py：

# hotel_agent.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from datetime import date
import uvicorn

app = FastAPI(title="酒店预订 Agent")

# 定义 A2A 消息结构（请求部分）
class A2ABookingRequest(BaseModel):
    id: str
    from_agent: str
    to_agent: str
    intent: str
    payload: dict  # 包含 city, checkin_date, guests 等字段
    timestamp: str

# 定义酒店预订响应结构
class BookingResponse(BaseModel):
    success: bool
    hotel_name: str
    price_per_night: int
    booking_id: str
    message: str

# A2A 消息接收端点
@app.post("/a2a/message", response_model=BookingResponse)
async def receive_a2a_message(msg: A2ABookingRequest):
    # 验证消息意图
    if msg.intent != "book_hotel":
        raise HTTPException(status_code=400, detail="不支持的消息意图")
    
    # 提取预订信息
    payload = msg.payload
    required_fields = ["city", "checkin_date", "guests"]
    if not all(field in payload for field in required_fields):
        raise HTTPException(status_code=400, detail="缺少必要的预订信息")
    
    # 模拟酒店预订逻辑（实际应用中应连接数据库查询真实房源）
    return {
        "success": True,
        "hotel_name": f"{payload['city']} Grand Hotel",
        "price_per_night": 120 if payload['city'] == "Tokyo" else 100,
        "booking_id": f"BOOK-{msg.id[:8].upper()}",
        "message": f"已成功预订 {payload['city']} 的酒店，入住日期：{payload['checkin_date']}"
    }

# 启动服务
if __name__ == "__main__":
    uvicorn.run("hotel_agent:app", host="0.0.0.0", port=8000, reload=True)
步骤 3：实现规划师 Agent（客户端）

创建 planner_agent.py：

# planner_agent.py
import httpx
import uuid
from datetime import datetime

# 生成 A2A 消息
def create_a2a_message(intent: str, payload: dict, from_agent: str, to_agent: str) -> dict:
    return {
        "id": str(uuid.uuid4()),
        "from_agent": from_agent,
        "to_agent": to_agent,
        "intent": intent,
        "payload": payload,
        "timestamp": datetime.utcnow().isoformat() + "Z"
    }

# 发送 A2A 消息并获取响应
async def send_a2a_message(msg: dict, server_url: str):
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{server_url}/a2a/message",
            json=msg
        )
        response.raise_for_status()  # 处理 HTTP 错误
        return response.json()

# 主逻辑：规划旅行并预订酒店
async def main():
    # 定义预订信息
    booking_info = {
        "city": "Tokyo",
        "checkin_date": "2025-09-01",
        "guests": 2
    }
    
    # 创建 A2A 消息
    a2a_msg = create_a2a_message(
        intent="book_hotel",
        payload=booking_info,
        from_agent="agent.travel.planner",
        to_agent="agent.hotel.booker"
    )
    
    # 发送消息给酒店 Agent
    try:
        result = await send_a2a_message(a2a_msg, "http://localhost:8000")
        print("预订结果：")
        print(f"酒店名称：{result['hotel_name']}")
        print(f"每晚价格：{result['price_per_night']} 元")
        print(f"预订编号：{result['booking_id']}")
        print(f"消息：{result['message']}")
    except Exception as e:
        print(f"预订失败：{str(e)}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())
运行与输出
  1. 启动酒店 Agent 服务：
$ python hotel_agent.py
  1. 运行规划师 Agent：
$ python planner_agent.py
预订结果：
酒店名称：Tokyo Grand Hotel
每晚价格：120 元
预订编号：BOOK-3F2D1E4C
消息：已成功预订 Tokyo 的酒店，入住日期：2025-09-01

核心价值体现：

  • 两个 Agent 遵循统一消息格式，实现跨系统协作
  • 消息包含完整元数据（ID、时间戳、发送方），便于追踪和调试
  • 可扩展添加更多 Agent（如机票预订、景点推荐），形成完整旅行生态

7. 综合案例：旅行规划全家桶系统

我们将整合前文所学的四项技术，构建一个完整的「智能旅行规划系统」，实现从用户需求到最终行程单的全流程自动化。

系统架构

在这里插入图片描述
图 3：综合案例系统架构图（包含 4 个核心 Agent 和完整技术栈）

系统包含以下核心组件：

  1. 主规划 Agent：接收用户需求，协调其他 Agent 工作（基于 LangChain）
  2. 酒店 Agent：处理酒店预订（基于 A2A 通信 + MCP）
  3. 天气 Agent：查询目的地天气（基于 Function Calling）
  4. 文档生成 Agent：生成 PDF 行程单（基于 MCP 调用外部服务）

核心工作流程

  1. 用户输入旅行需求（如「规划 2025 年 10 月东京 5 日游，2 人，预算 1 万元」）
  2. 主规划 Agent 拆解任务，通过 A2A 协议分别调用酒店、机票、景点 Agent
  3. 天气 Agent 通过 Function Calling 获取东京未来 5 天天气
  4. 各 Agent 完成任务后通过 A2A 反馈结果给主规划 Agent
  5. 主规划 Agent 汇总信息，调用文档生成 Agent 生成 PDF 行程单

快速体验

系统已开源，可通过以下命令快速部署：

# 克隆代码仓库
git clone https://github.com/yourname/travel-agents-demo.git
cd travel-agents-demo

# 启动服务（需 Docker 和 Docker Compose）
docker compose up -d

# 访问 Web 界面
open http://localhost:8501  # Streamlit 交互界面

8. 常见坑 & 性能优化策略

问题场景 解决方案 原理说明
Function 描述过长导致 Token 超限 1. 精简描述，保留核心信息
2. 使用向量数据库存储描述，动态检索注入		 LLM 上下文窗口有限，冗余信息会挤压有效内容空间
MCP 服务 stdio 模式下阻塞 1. 切换到 SSE 或 WebSocket 模式
2. 实现异步 I/O 处理		 stdio 是同步模式，高并发下会导致请求排队
A2A 消息乱序或丢失 1. 实现消息确认机制（ACK）
2. 添加消息序号和重传逻辑
3. 使用消息中间件（如 RabbitMQ）		 网络传输可能导致消息乱序，需通过应用层机制保证可靠性
Agent 陷入无限循环 1. 设置最大迭代步数（max_iterations）
2. 实现成本预算（token 消耗上限）
3. 添加人工干预接口		 LLM 可能在复杂任务中陷入决策循环，需外部约束
多 Agent 协作效率低 1. 优化任务拆分策略，减少通信次数
2. 实现并行任务执行
3. 使用缓存机制存储重复查询结果		 通信成本是多 Agent 系统主要性能瓶颈，需减少不必要交互
MCP 跨语言调用兼容性问题 1. 使用 Protocol Buffers 替代 JSON
2. 添加类型校验中间件
3. 维护统一的接口文档（OpenAPI/Swagger）		 不同语言对 JSON 类型解析存在差异（如整数/浮点数），需强类型约束

9. 参考资料

官方文档

推荐开源项目

  • 多 Agent 框架：CrewAI（简化多 Agent 协作）、AutoGen（微软开源，支持复杂对话）
  • MCP 工具集：mcp-python（官方实现）、mcp-js（JavaScript 客户端）
  • A2A 通信库：a2a-protocol（Python 实现）、a2a-gateway（消息路由服务）

如果本文对你理解 Agent 技术体系有帮助，欢迎在关注、点赞并分享给更多开发者！如有疑问或建议，可通过评论交流。

# AI # 人工智能
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

【AI产品经理必看】AI模型选型思维框架 | 从技术人到产品经理的决策指南！

avatar 2048 AI社区
cover

实话实说，RAG其实并没有你想的那么简单，Late Chunking vs Contextual Retrieval解决上下文难题

avatar 2048 AI社区
cover

AI内容标识新规实施后，大厂AI用户协议有何变化？（七）月之暗面

avatar 2048 AI社区