如果你正在学习AI Agent开发，可能会遇到这样的困境：看了很多教程，概念都懂，但一上手就不知道从何写起；或者跟着某个框架跑通了Demo，但稍微改点需求就报错，完全不知道如何调试和优化。更让人焦虑的是，招聘要求上写着“熟悉Agent开发”，但具体要掌握哪些技能、做到什么程度才算“熟悉”，却模糊不清。

这篇文章要解决的，正是这个从“知道”到“做到”的核心断层。我们不会空谈Agent的宏大未来，而是聚焦于一个非常具体的目标： 通过一套精心设计的、总耗时约2.5小时的实战练习，让你系统性地掌握Agent开发的核心能力闭环 。这2.5小时不是漫无目的的摸索，而是针对“记忆”、“工具使用”、“规划与执行”、“多智能体协作”这四大Agent核心支柱的刻意训练。

读完本文并完成练习，你将获得一个清晰的自我评估标准：你的Agent到底“牛”在哪里？是能记住复杂的上下文，还是能娴熟地调用各种API？是能拆解复杂任务，还是能与其他Agent协同工作？更重要的是，你将拥有一套可复现、可扩展的代码实践，以及面对真实项目需求时的解决思路。

1. 重新定义“牛”的Agent：超越跑通Demo的四个能力维度

在开始练习之前，我们必须先统一认知：一个“牛”的Agent绝不仅仅是能回答几个问题。它应该像一个经验丰富的数字员工，具备以下四种核心工作能力：

  1. 记忆与上下文管理 ：这是Agent的“工作经验”。它能否记住对话历史、用户偏好、以及任务执行过程中的中间状态？能否从长上下文中精准提取关键信息，而不被无关内容干扰？
  2. 工具使用与技能扩展 ：这是Agent的“双手”。它能否根据任务需求，自主选择并正确调用外部工具（如搜索API、计算器、数据库、文件系统）？能否处理工具调用失败、结果异常等情况？
  3. 规划、分解与执行 ：这是Agent的“大脑”。面对一个复杂目标（如“为我策划一次旅行”），它能否将其分解为“查询天气”、“查找机票”、“推荐景点”等一系列可执行的子任务？能否根据子任务执行结果动态调整计划？
  4. 多智能体协作 ：这是Agent的“团队协作能力”。在复杂场景下，能否让多个各司其职的Agent（如一个负责创意，一个负责审核，一个负责执行）通过通信和协作，共同完成一个单Agent难以胜任的任务？

市面上很多教程只带你实现了第一点或第二点，但这就像只学会了走路，还远不能奔跑。我们设计的2.5小时练习，正是为了让你在这四个维度上都得到扎实的训练，从而构建出一个真正有能力处理现实世界复杂问题的智能体。

2. 环境准备：选择你的“训练场”

工欲善其事，必先利其器。为了避免环境问题消耗不必要的精力，我们选择当前最主流、对初学者最友好的技术栈。

核心运行环境：Python 请确保你的系统已安装Python 3.8或更高版本。可以通过命令行验证：

python --version
# 或
python3 --version

核心开发框架：LangChain LangChain是目前构建Agent事实上的标准框架，它提供了丰富的模块化组件，能极大降低开发复杂度。我们使用pip进行安装：

pip install langchain langchain-community langchain-core

大语言模型（LLM）接入：OpenAI API 或 本地模型 Agent的“智力”来源于大语言模型。你有两个选择：

  • 云端API（推荐，稳定便捷） ：使用OpenAI的GPT系列。你需要一个OpenAI API Key。 
    pip install openai
    然后在代码中或环境变量设置你的API Key。
  • 本地模型（注重隐私与成本） ：使用Ollama运行本地模型（如Llama 3, Qwen等）。 
    # 安装Ollama (请参考官网：https://ollama.com/)
# 拉取一个模型，例如：
ollama pull llama3.2
pip install langchain-ollama

辅助工具包 ： 为了模拟真实工具调用，我们还需要安装一些常用的库：

pip install requests python-dotenv duckduckgo-search
  • requests : 用于模拟调用Web API。
  • python-dotenv : 管理环境变量（如API Key）。
  • duckduckgo-search : 提供一个免费的搜索工具。

集成开发环境（IDE） ： 任何你熟悉的Python IDE均可，如VSCode、PyCharm。建议使用支持Jupyter Notebook的环境，方便分步执行和调试。

3. 实战练习一：构建具有持久记忆的会话Agent（预计耗时：40分钟）

目标 ：让Agent不仅能回答当前问题，还能引用整个会话历史中的信息，实现连贯的、个性化的对话。

痛点 ：默认的LLM调用是无状态的，每次提问它都会“忘记”之前的对话。我们需要为其添加“记忆”模块。

核心概念 ： ConversationBufferMemory 。这是LangChain中最简单的记忆类型，像一个不断增长的缓冲区，保存所有历史消息。

3.1 基础记忆实现

让我们先创建一个能记住上下文的简单聊天机器人。

# 文件：agent_with_memory_basic.py
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# 1. 初始化LLM (这里以OpenAI为例，使用本地模型请替换为ChatOllama)
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7, openai_api_key="你的API Key")

# 2. 创建记忆体
memory = ConversationBufferMemory()

# 3. 创建对话链
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True  # 开启详细日志，方便观察记忆如何被使用
)

# 4. 进行多轮对话
print("Agent: 你好！我是你的助手。")
while True:
    user_input = input("\n你: ")
    if user_input.lower() in ['退出', 'exit', 'quit']:
        print("Agent: 再见！")
        break
    response = conversation.predict(input=user_input)
    print(f"Agent: {response}")

运行与验证 ： 运行上述脚本，进行如下对话：

你: 我叫张三。
Agent: 你好，张三！很高兴认识你。
你: 我最喜欢的水果是苹果。
Agent: 苹果很健康！你喜欢什么品种的苹果？
你: 我刚刚告诉你我的名字是什么？

观察Agent的回复。在最后一轮，一个没有记忆的AI会不知道“我的名字”指代谁，但我们的Agent应该能正确回答“张三”。通过设置 verbose=True ，你可以在控制台看到LangChain是如何将历史记录拼接到当前提问中的。

3.2 进阶：记忆窗口与摘要记忆

ConversationBufferMemory 会保存所有历史，可能导致上下文过长（超出模型限制）和成本增加。 ConversationBufferWindowMemory 只保留最近K轮对话， ConversationSummaryMemory 则动态生成对话摘要。

# 文件：agent_with_advanced_memory.py
from langchain.memory import ConversationBufferWindowMemory, ConversationSummaryMemory
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)

# 示例1：窗口记忆（只保留最近3轮）
window_memory = ConversationBufferWindowMemory(k=3)
# 示例2：摘要记忆（适合超长对话）
summary_memory = ConversationSummaryMemory(llm=llm)

练习任务 ：修改上面的基础代码，分别使用 窗口记忆(k=2) 和 摘要记忆 进行长对话（超过5轮），观察并对比Agent的行为差异。思考在“客服对话”和“长期项目规划”两种场景下，哪种记忆方式更合适？

4. 实战练习二：为Agent装备“工具手”（预计耗时：50分钟）

目标 ：让Agent学会使用外部工具来获取信息或执行操作，突破纯文本生成的限制。

痛点 ：LLM的知识可能过时，且无法直接操作现实世界（如查询实时天气、执行计算、读写文件）。

核心概念 ： Tool + AgentExecutor 。你将工具（函数）描述给Agent，它学会在需要时调用它们。

4.1 创建自定义工具

我们创建两个工具：一个计算器，一个获取当前时间的工具。

# 文件：custom_tools.py
from langchain.tools import tool
from datetime import datetime
import math

@tool
def calculate(expression: str) -> str:
    """执行数学计算。输入是一个数学表达式字符串，例如 ‘(3+5)*2‘。只支持基本运算。"""
    try:
        # 警告：使用eval有安全风险，此处仅用于演示。生产环境应使用安全计算库如`numexpr`。
        result = eval(expression, {"__builtins__": None}, {"math": math})
        return f"计算结果: {result}"
    except Exception as e:
        return f"计算错误: {e}"

@tool
def get_current_time(timezone: str = "Asia/Shanghai") -> str:
    """获取指定时区的当前时间。时区参数例如 ‘Asia/Shanghai‘, ‘America/New_York‘。"""
    from pytz import timezone as tz
    import pytz
    try:
        tz_obj = tz(timezone)
        current_time = datetime.now(tz_obj).strftime("%Y-%m-%d %H:%M:%S %Z%z")
        return f"{timezone}的当前时间是: {current_time}"
    except pytz.exceptions.UnknownTimeZoneError:
        return f"错误：未知时区 ‘{timezone}‘。请提供有效的时区名称。"

# 注意：需要安装pytz库: pip install pytz

4.2 创建工具型Agent并执行

现在，我们将工具赋予Agent，并观察它如何决策。

# 文件：agent_with_tools.py
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from custom_tools import calculate, get_current_time

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# 定义工具列表
tools = [calculate, get_current_time]

# 初始化Agent。AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION 适合基于聊天的Agent使用ReAct推理框架。
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,  # 必须开启，才能看到Agent的思考过程！
    handle_parsing_errors=True  # 优雅处理Agent输出解析错误
)

# 测试Agent
queries = [
    “请问(12+8)*3等于多少？”，
    “现在纽约是几点钟？”，
    “先计算100除以25，然后告诉我伦敦现在的时间。”
]

for query in queries:
    print(f"\n用户提问: {query}")
    try:
        result = agent.run(query)
        print(f"Agent最终回答: {result}")
    except Exception as e:
        print(f"执行出错: {e}")

运行与验证 ： 运行代码，仔细观察控制台 verbose 模式下的输出。你会看到类似以下的思考链：

> Entering new AgentExecutor chain...
Thought: 用户需要计算一个数学表达式，我需要使用计算器工具。
Action: calculate
Action Input: (12+8)*3
Observation: 计算结果: 60
Thought: 我得到了计算结果，可以回答用户了。
Final Answer: (12+8)*3 等于 60。

这个过程就是 ReAct（Reason + Act）框架 的直观体现：Agent先思考（Reason），再决定行动（Act，调用工具），根据工具返回结果（Observation）再次思考，最终给出答案。

练习任务 ：

  1. 为Agent添加一个 duckduckgo-search 工具，让它能回答实时性问题（如“今天比特币价格多少？”）。
  2. 尝试问一个需要 按顺序调用多个工具 的复杂问题（如“计算北京和伦敦的时差，然后用中文告诉我”），观察Agent的规划能力。

5. 实战练习三：实现自主规划与任务分解（预计耗时：60分钟）

目标 ：让Agent具备“项目经理”能力，能够将模糊的、复杂的用户指令，自动分解为一系列明确的、可执行的子任务。

痛点 ：用户指令如“帮我规划一个周末杭州旅行”，直接抛给LLM可能得到一段笼统的文字。而一个真正的Agent应该能输出可执行的清单：1. 查杭州周末天气 2. 查高铁票 3. 列出西湖周边景点等。

核心概念 ： Plan-and-Execute 模式。我们使用LangChain的 PlanAndExecute 组件，它包含一个“规划者”和一个“执行者”。

5.1 构建规划执行Agent

这个示例将模拟一个旅行规划助手。

# 文件：planning_agent.py
from langchain_openai import ChatOpenAI
from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner
from langchain.tools import Tool
from custom_tools import get_current_time
# 假设我们还有之前创建的搜索工具和计算器工具
from duckduckgo_search import DDGS

def search_web(query: str) -> str:
    """使用DuckDuckGo进行网页搜索。"""
    with DDGS() as ddgs:
        results = [r for r in ddgs.text(query, max_results=3)]
        return "\n".join([f"{r['title']}: {r['body']}" for r in results])

search_tool = Tool(
    name="Web Search",
    func=search_web,
    description="当需要获取最新的、未知的或实时信息时使用此工具。"
)

# 定义工具集
tools = [search_tool, get_current_time]  # 实际项目中会有更专业的工具，如航班查询API

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

# 1. 创建规划器：负责将目标分解为步骤
planner = load_chat_planner(llm)

# 2. 创建执行器：负责调用工具执行每个步骤
executor = load_agent_executor(llm, tools, verbose=True)

# 3. 组合成规划执行Agent
agent = PlanAndExecute(planner=planner, executor=executor, verbose=True)

# 执行一个复杂任务
complex_task = “为我规划一个本周六从上海出发，周日返回的杭州周末游。需要考虑天气和交通。”
print(f“执行任务: {complex_task}”)
result = agent.run(complex_task)
print(f“\n最终规划结果:\n{result}”)

5.2 解析与优化

运行上述代码，你会看到Agent首先输出一个 计划 ，例如：

计划:
1. 搜索本周末杭州的天气预报。
2. 搜索从上海到杭州的高铁或火车时刻表及票价。
3. 搜索杭州周末值得游览的景点或活动。
4. 综合以上信息，生成一个周末游计划。

然后，它会逐步执行每一步，调用相应的工具，最终整合成一个完整的答案。

关键洞察 ： PlanAndExecute 模式将“思考规划”和“行动执行”分离。规划器（Planner）通常使用一个LLM，它不直接调用工具，只负责制定高级计划。执行器（Executor）是另一个Agent，它严格按计划步骤，调用具体工具完成任务。这种架构更清晰，也更容易调试。

练习任务 ：

  1. 观察与调试 ：尝试给Agent一个它现有工具无法完成的任务（如“帮我预订一家西湖边的酒店”）。观察它的计划和执行过程在哪里失败？错误信息是什么？
  2. 定制规划提示 ： load_chat_planner 函数内部使用了默认的系统提示词。尝试查阅LangChain文档，找到如何自定义规划器的提示词（ planner_prompt ），让它输出的计划步骤更具体、格式更统一（例如，强制要求每一步都以“步骤X：使用[工具名]来[具体操作]”的格式输出）。

6. 实战练习四：搭建多智能体协作系统（预计耗时：40分钟）

目标 ：模拟一个软件团队，让多个具备不同角色和专长的Agent通过对话协作，完成一个单Agent难以处理的复杂任务。

痛点 ：单一Agent的能力有上限。复杂的任务（如“设计并实现一个简单的网页”）需要需求分析、UI设计、编码、测试等不同技能。

核心概念 ： MultiAgentCollaboration (通过 CrewAI 或 AutoGen 框架实现)。这里我们使用相对轻量的 CrewAI 来演示。

6.1 使用CrewAI创建角色与任务

我们模拟一个“技术博客创作团队”，包含策划、写手、编辑三个角色。

# 文件：multi_agent_crew.py
# 首先安装crewai包: pip install crewai
from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

# 配置LLM
llm = ChatOpenAI(model="gpt-4", temperature=0.7) # 多Agent协作建议使用更强模型

# 1. 定义角色（Agent）
planner = Agent(
    role=‘技术博客策划师’,
    goal=‘根据热点话题，策划出有深度、能吸引开发者的博客选题和详细大纲’,
    backstory=‘你是一位资深技术布道师，对AI、云计算、前端框架等趋势有敏锐的洞察力。你擅长将复杂技术转化为引人入胜的故事线。’,
    verbose=True,
    allow_delegation=True,  # 允许将任务委派给其他Agent
    llm=llm
)

writer = Agent(
    role=‘高级技术写手’,
    goal=‘根据策划师提供的大纲，撰写专业、准确、易懂且文笔流畅的技术博客正文’,
    backstory=‘你拥有多年技术文档和博客写作经验，能用清晰的逻辑和生动的案例把技术讲透。你痛恨晦涩难懂的术语堆砌。’,
    verbose=True,
    llm=llm
)

editor = Agent(
    role=‘严厉的技术编辑’,
    goal=‘审核和润色写手完成的博客草稿，确保其技术准确性、逻辑严谨性、语言无错误，并符合发布标准’,
    backstory=‘你以挑剔和严谨著称，对技术细节和语言表达有极高的要求。任何模糊的表述和潜在的误导都逃不过你的眼睛。’,
    verbose=True,
    llm=llm
)

# 2. 定义任务（Task），并指定执行者和上下文依赖
plan_task = Task(
    description=‘针对当前热点“AI Agent开发入门”，策划一篇面向中级Python开发者的技术博客。输出包括：标题、核心痛点、3-5个核心章节标题及简要说明、目标读者。’,
    expected_output=‘一份完整的博客策划案文档。’,
    agent=planner
)

write_task = Task(
    description=‘根据策划师提供的策划案，撰写博客正文。要求：每个章节充实，有代码示例（用Markdown格式），有实际应用场景，语言生动。字数不少于1500字。’,
    expected_output=‘一篇完整的、格式良好的Markdown技术博客正文。’,
    agent=writer,
    context=[plan_task]  # 此任务依赖plan_task的输出
)

edit_task = Task(
    description=‘对写手完成的博客正文进行审核和编辑。重点检查：1. 技术概念是否准确。2. 代码示例能否运行。3. 逻辑是否通顺。4. 有无错别字或语法问题。输出最终修订版。’,
    expected_output=‘最终可发布的、经过审核的博客正文。’,
    agent=editor,
    context=[write_task]  # 此任务依赖write_task的输出
)

# 3. 组建团队（Crew），并定义工作流程
blog_crew = Crew(
    agents=[planner, writer, editor],
    tasks=[plan_task, write_task, edit_task],
    process=Process.sequential,  # 顺序执行：策划 -> 写作 -> 编辑
    verbose=2  # 2级详细日志，可以看到Agent间的交互
)

# 4. 启动团队执行任务
result = blog_crew.kickoff()
print(“\n” + “=”*50)
print(“多智能体协作最终产出：”)
print(“=”*50)
print(result)

运行与观察 ： 运行代码，由于任务较复杂，可能需要一些时间。观察控制台输出，你会看到：

  1. 策划师 开始工作，输出策划案。
  2. 策划案完成后， 写手 自动接收策划案作为输入，开始撰写。
  3. 写手完成后， 编辑 接收博客草稿，开始审核修改。
  4. 最终输出整合了三个角色的成果。

核心价值 ：多Agent系统的魅力在于 角色分工 和 信息流转 。每个Agent专注于自己的专业领域，并通过 context 参数自动获取上游工作的成果。这极大地扩展了AI处理复杂工作流的能力边界。

练习任务 ：

  1. 修改流程 ：将 Process.sequential 改为 Process.hierarchical ，并定义一个 manager_agent （经理角色）来协调其他Agent。观察执行流程有何不同。
  2. 增加角色 ：在团队中增加一个 SEO专家 角色，它的任务是在编辑完成后，为博客生成一组合适的关键词和元描述。

7. 常见问题与排查指南

在练习过程中，你一定会遇到各种错误。以下是典型问题及解决方案：

问题现象 可能原因 排查步骤 解决方案
ModuleNotFoundError 依赖库未安装或环境错误。 1. 确认在正确的Python环境下运行。
2. 使用 pip list 检查所需包是否存在。		 使用 pip install [package-name] 安装缺失的包。注意包名可能不同（如 langchain-openai ）。
API密钥错误 OpenAI API Key未设置或无效。 1. 检查代码中 openai_api_key 参数或环境变量 OPENAI_API_KEY 。
2. 在OpenAI官网检查密钥状态和余额。		 确保密钥正确设置。对于本地模型，检查Ollama服务是否运行( ollama serve )。
Agent陷入循环或输出无关内容 提示词不清晰、工具描述不准确或模型温度( temperature )过高。 1. 开启 verbose=True ，观察Agent的思考链( Thought )。
2. 检查是否在无效的 Action 和 Observation 间循环。		 1. 降低 temperature （如设为0）以获得更确定性的输出。
2. 优化工具的描述( description )，使其更精确。
3. 使用更强的模型（如 gpt-4 ）。
解析错误 (Parsing Error) Agent输出的文本不符合框架预期的格式（如JSON）。 查看 verbose 日志，找到Agent原始输出，看是否包含多余的解释或格式错误。 1. 设置 handle_parsing_errors=True 。
2. 在Agent初始化时提供更清晰的输出格式指令。
3. 使用专为结构化输出设计的模型或方法。
工具调用失败 工具函数本身有Bug，或输入参数类型不对。 1. 单独测试工具函数是否能正常工作。
2. 检查Agent传递给工具的 Action Input 是否正确。		 1. 修复工具函数的代码。
2. 在工具描述中明确指定输入参数的格式和类型。
上下文长度超限 对话历史或文档内容太长，超过模型token限制。 观察错误信息是否包含“context length”或“token”。 1. 使用 ConversationSummaryMemory 或 ConversationBufferWindowMemory 。
2. 对长文本进行分块或摘要处理后再输入。
多Agent CrewAI执行慢 任务复杂，串行执行步骤多，或网络延迟。 1. 确认每个Agent的任务是否过于庞大。
2. 使用 verbose=2 观察卡在哪一步。		 1. 简化任务描述，或拆分成更小的Crew。
2. 考虑使用异步或并发执行（如果框架支持）。
3. 耐心等待，复杂任务可能需要数分钟。

8. 从练习到项目：工程化最佳实践

完成以上练习，你已经掌握了Agent的核心能力。但要将其用于真实项目，还需要关注工程化细节：

  1. 配置与密钥管理 ：永远不要将API密钥硬编码在代码中。使用 .env 文件和环境变量。

    # .env 文件
OPENAI_API_KEY=sk-...

    # 代码中读取
from dotenv import load_dotenv
import os
load_dotenv()
llm = ChatOpenAI(openai_api_key=os.getenv(“OPENAI_API_KEY”))

  2. 日志与监控 ：除了 verbose=True ，在生产环境中应集成结构化日志（如 logging 模块），记录每次Agent的思考、行动和结果，便于调试和审计。

  3. 错误处理与降级 ：对工具调用、网络请求、模型调用等可能失败的操作进行 try-catch 包装。设计降级策略，例如当搜索工具失败时，让Agent基于自身知识给出保守回答。

  4. 性能与成本优化 ：

    • 缓存 ：对重复的、耗时的LLM调用或工具查询结果进行缓存。
    • 流式输出 ：对于长文本生成，使用流式响应以提升用户体验。
    • 模型选择 ：根据任务复杂度选择合适的模型。简单的工具调用可用 gpt-3.5-turbo ，复杂的规划推理则用 gpt-4 。

  5. 评估与测试 ：为你的Agent建立测试集。例如，针对“旅行规划”Agent，设计一系列标准问题，并评估其输出是否包含必备信息（天气、交通、景点）。这有助于在迭代中保证质量。

  6. 安全与边界 ：

    • 工具权限 ：严格控制工具的能力。例如，文件读写工具应限制路径；数据库操作工具应使用只读或最小权限账户。
    • 输入过滤 ：对用户输入进行基本的清理和过滤，防止注入攻击。
    • 内容审核 ：对Agent的最终输出（特别是面向公众时）进行内容安全审核。

这2.5小时的练习，是一个高度浓缩的“能力地图绘制”过程。你不再是通过零散的知识点来理解Agent，而是通过亲手构建四个关键系统，从内到外掌握了它的工作原理。记忆、工具、规划、协作——这四大支柱，构成了当今绝大多数实用型AI Agent的骨架。

真正的“牛”，不在于你记住了多少框架的名字，而在于当产品经理提出“我们需要一个能自动处理用户工单的AI助手”时，你能立刻在脑海中勾勒出它的技术蓝图：它需要 ConversationSummaryMemory 来理解工单历史，需要集成 JIRA API 和 知识库搜索 作为工具，复杂问题需要 PlanAndExecute 来拆解，或许还需要一个 审核Agent 来确保回复质量。然后，你能快速用代码将这些蓝图变为现实。

接下来的方向也很明确：选择一个你感兴趣的具体领域（智能客服、个人知识管理、自动化测试），将这四个练习组合起来，去构建一个解决真实问题的项目。过程中，你会遇到更具体的挑战，比如工具API的鉴权、长文本处理的性能、多Agent协作的通信开销，而解决这些挑战的过程，就是你超越这2.5小时，成为一名真正Agent开发者的开始。

Logo
亚马逊云科技技术品牌专区

更多推荐

2026年AI编程工具排行榜：10款主流产品深度横评，谁才是真正的提效之王

三个月实测10款AI编程工具，从代码生成质量、Agent能力、过程可控性、性价比、IDE兼容性五个维度打分排名。文心快码以SPEC规范驱动+Multi-Agent矩阵在可控性上拉满，附完整对比表和选型建议。

avatar 亚马逊云科技技术品牌专区
cover

我做了一个 AI 原生安全测试 Skill：让 Claude Code/Cursor 直接进入安全工程模式

avatar 亚马逊云科技技术品牌专区
cover

深入理解 AI Agent · MCP 子系列 #02：MCP Server 开发实战—从工具注册到无状态新规范

avatar 亚马逊云科技技术品牌专区