AI Agent开发路线图2026：从入门到精通

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

                    ┌────────────────────────────────────┐
                    │          AI Agent 框架生态          │
                    └────────────────────────────────────┘
                                      │
          ┌───────────────────────────┼───────────────────────────┐
          │                           │                           │
  ┌───────▼────────┐          ┌──────▼──────┐           ┌───────▼────────┐
  │  工作流编排     │          │  多Agent协作  │           │  垂直场景      │
  │  LangGraph      │          │  CrewAI      │           │  Browser Use   │
  │  (LangChain系)  │          │  AutoGen/MAF │           │  (浏览器操作)  │
  │  ~10K ⭐        │          │  15K/38K ⭐  │           │  79K ⭐        │
  └────────────────┘          └──────────────┘           └────────────────┘
          │                           │                           │
          │                    ┌──────▼──────┐                    │
          │                    │  轻量多模态  │                    │
          │                    │  Agno        │                    │
          │                    │  18.6K+ ⭐   │                    │
          │                    └──────────────┘                    │
          │                                                       │
          └───────────────────────────┬───────────────────────────┘
                                      │
                          ┌───────────▼───────────┐
                          │   规格驱动开发         │
                          │   GitHub Spec-Kit     │
                          │   64.5K ⭐             │
                          └───────────────────────┘

1

pip install -U langgraph langchain-openai

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
import os

# 定义工具：Agent可以调用的函数
def get_weather(city: str) -> str:
    """获取指定城市的天气"""
    # 实际项目中接入天气API
    return f"{city}今天晴，气温25°C~32°C"

def search_web(query: str) -> str:
    """搜索互联网获取信息"""
    # 实际项目接入搜索API（如Tavily）
    return f"关于'{query}'的搜索结果：..."

# 创建Agent
agent = create_react_agent(
    model=ChatOpenAI(model="gpt-4o-mini", api_key=os.getenv("OPENAI_API_KEY")),
    tools=[get_weather, search_web],
    prompt="你是一个有用的助手，可以使用工具来回答问题。"
)

# 运行
result = agent.invoke({
    "messages": [{"role": "user", "content": "深圳今天天气怎么样？顺便查一下最新的AI Agent框架有哪些。"}]
})

# 打印结果
for msg in result["messages"]:
    if hasattr(msg, "content"):
        print(f"[{msg.type}] {msg.content}")

1

pip install crewai crewai-tools

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

# 定义工具
search_tool = SerperDevTool()

# 定义Agent角色
researcher = Agent(
    role="资深研究员",
    goal="深入调研指定话题，收集最新数据和洞察",
    backstory="你有10年行业研究经验，擅长从海量信息中提炼关键发现。",
    tools=[search_tool],
    verbose=True
)

writer = Agent(
    role="技术撰稿人",
    goal="将研究结果转化为通俗易懂的技术文章",
    backstory="你擅长把复杂概念讲得简单有趣。",
    verbose=True
)

# 定义任务
research_task = Task(
    description="研究2026年AI Agent框架的最新发展，重点关注LangGraph、CrewAI和Browser Use。收集至少3个关键趋势。",
    agent=researcher,
    expected_output="一份结构化的研究报告，包含框架对比表格和关键趋势分析"
)

writing_task = Task(
    description="基于研究报告，撰写一篇面向独立开发者的AI Agent框架选型指南。文章需包含：框架介绍、对比分析、选型建议。语言通俗。",
    agent=writer,
    expected_output="一篇1500字左右的技术文章，Markdown格式"
)

# 组建Crew并执行
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,  # sequential（顺序）或 hierarchical（层级）
    verbose=True
)

result = crew.kickoff()
print(result)

1

pip install autogen-agentchat

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from autogen import AssistantAgent, UserProxyAgent

# 创建助手Agent
assistant = AssistantAgent(
    name="代码助手",
    llm_config={
        "model": "gpt-4o-mini",
        "api_key": "your-api-key"
    },
    system_message="你是一个Python专家，帮助审查和改进代码。"
)

# 创建用户代理（代表人类，可自动执行代码）
user_proxy = UserProxyAgent(
    name="用户",
    human_input_mode="NEVER",  # NEVER：全自动 / TERMINATE：关键操作前询问 / ALWAYS：每步询问
    code_execution_config={
        "work_dir": "coding",
        "use_docker": False
    }
)

# 启动对话
user_proxy.initiate_chat(
    assistant,
    message="帮我写一个Python函数，计算斐波那契数列前20项，并分析时间复杂度。"
)

1

pip install -U agno

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.yfinance import YFinanceTools

# 创建带金融工具的Agent
agent = Agent(
    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[
        YFinanceTools(
            stock_price=True,
            analyst_recommendations=True,
            company_info=True
        )
    ],
    instructions=["用表格展示数据", "使用中文回复"],
    markdown=True
)

# 查询
agent.print_response("分析一下英伟达(NVDA)近况", stream=True)

1
2

pip install browser-use
playwright install  # 安装浏览器驱动

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import asyncio
from browser_use import Agent
from langchain_openai import ChatOpenAI

async def main():
    agent = Agent(
        task="""
        1. 打开 https://github.com/trending
        2. 切换到「本周」趋势
        3. 找到排名第一的项目
        4. 告诉我项目名称、Star数和简介
        """,
        llm=ChatOpenAI(model="gpt-4o")
    )
    result = await agent.run()
    print(result)

asyncio.run(main())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

from crewai import Agent, Task, Crew, Process

# 5个角色
pm = Agent(
    role="产品经理",
    goal="分析需求并产出PRD文档",
    backstory="你有10年产品经验，擅长PRD撰写。",
    verbose=True
)

architect = Agent(
    role="架构师",
    goal="设计技术方案和系统架构",
    backstory="你擅长设计高并发、高可用的系统。",
    verbose=True
)

dev = Agent(
    role="开发工程师",
    goal="根据PRD和技术方案编写代码",
    backstory="你是一个全栈工程师，Python/TypeScript精通。",
    verbose=True
)

tester = Agent(
    role="测试工程师",
    goal="编写测试用例并执行",
    backstory="你对边界条件和异常情况特别敏感。",
    verbose=True
)

reviewer = Agent(
    role="代码审查员",
    goal="审查代码质量、安全性和可维护性",
    backstory="你以严格著称，不放过任何一个潜在风险。",
    verbose=True
)

# 定义任务链
tasks = [
    Task(description="分析需求：设计一个简单的REST API，支持用户注册和登录。", agent=pm,
         expected_output="PRD文档"),
    Task(description="基于PRD设计系统架构和技术选型。", agent=architect,
         expected_output="技术方案文档"),
    Task(description="根据PRD和技术方案编写代码实现。", agent=dev,
         expected_output="可运行的Python代码"),
    Task(description="编写并执行测试用例。", agent=tester,
         expected_output="测试报告"),
    Task(description="审查代码质量。", agent=reviewer,
         expected_output="代码审查报告"),
]

crew = Crew(
    agents=[pm, architect, dev, tester, reviewer],
    tasks=tasks,
    process=Process.sequential,
    verbose=True
)

result = crew.kickoff()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 以LangGraph为例，集成多种工具

from langgraph.prebuilt import create_react_agent
from langchain_community.tools import (
    TavilySearchResults,  # 搜索
    GoogleSerperRun,       # 搜索
)
from langchain.tools import tool
import requests
import json

# 自定义工具：调用自己的后端API
@tool
def query_order(order_id: str) -> str:
    """根据订单号查询订单状态"""
    response = requests.get(f"https://your-api.com/orders/{order_id}")
    return json.dumps(response.json(), ensure_ascii=False)

# 自定义工具：操作数据库
@tool
def execute_sql(query: str) -> str:
    """执行SQL查询（只读）"""
    # 生产环境需要SQL注入防护和权限控制
    import sqlite3
    conn = sqlite3.connect("app.db")
    cursor = conn.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    conn.close()
    return str(results)

# 创建带工具集的Agent
agent = create_react_agent(
    model="gpt-4o",
    tools=[
        TavilySearchResults(max_results=5),
        query_order,
        execute_sql,
    ],
    prompt="你是一个电商客服助手，可以查订单、查数据。"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# docker-compose.prod.yml
version: '3.8'
services:
  # Agent服务
  agent-service:
    build: .
    ports:
      - "8000:8000"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - REDIS_URL=redis://redis:6379
      - DATABASE_URL=postgresql://user:pass@postgres:5432/agents
    depends_on:
      - redis
      - postgres
    restart: always
    
  # 状态存储（LangGraph checkpoint）
  postgres:
    image: postgres:16
    environment:
      POSTGRES_DB: agents
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
    volumes:
      - pgdata:/var/lib/postgresql/data
    
  # 缓存层  
  redis:
    image: redis:7-alpine
    volumes:
      - redisdata:/data

volumes:
  pgdata:
  redisdata:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 生产级LangGraph配置
from langgraph.checkpoint.postgres import PostgresSaver
from langgraph.graph import StateGraph
import logging

# 日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# 使用PostgreSQL做checkpoint持久化
checkpointer = PostgresSaver.from_conn_string(
    "postgresql://user:pass@localhost:5432/agents"
)

# 构建带断点恢复的Agent图
graph = StateGraph(AgentState)
# ... 添加节点和边 ...

# 编译时指定checkpointer
app = graph.compile(checkpointer=checkpointer)

# 运行时用thread_id区分不同会话
config = {"configurable": {"thread_id": "user-123-session-456"}}
app.invoke({"messages": [{"role": "user", "content": "帮我查订单"}]}, config)

1
2
3
4
5
6
7

# Kubernetes部署核心配置
kubectl create deployment agent-service --image=your-agent:latest
kubectl expose deployment agent-service --port=8000 --type=LoadBalancer

# HPA自动扩缩容
kubectl autoscale deployment agent-service \
  --cpu-percent=70 --min=2 --max=10

1
2
3
4
5

┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
│ 1.宪法    │───▶│ 2.规格    │───▶│ 3.澄清    │───▶│ 4.计划    │───▶│ 5.任务    │───▶│ 6.实现    │
│Constitution│   │Specify   │   │Clarify   │   │Plan      │   │Tasks     │   │Implement │
└──────────┘    └──────────┘    └──────────┘    └──────────┘    └──────────┘    └──────────┘
定义项目原则     编写功能规格    澄清模糊需求     制定技术方案    分解开发任务    执行编码实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 安装Spec-Kit
pip install specify-cli

# 初始化项目
specify init my-agent-project

# 第一步：定宪法（项目原则）
# 编辑 .specify/memory/constitution.md
# 示例内容：
# - 所有API必须有OpenAPI文档
# - 测试覆盖率不低于80%
# - 优先使用Python异步编程

# 第二步：写规格
specify create "用户可以通过自然语言查询订单状态"

# 第三步：澄清
specify clarify  # AI会主动问你不清楚的地方

# 第四步：做计划
specify plan

# 第五步：拆任务
specify tasks

# 第六步：实现
specify implement  # AI按规格写代码

1
2
3
4
5
6
7

# 给Agent加token计数
from langchain.callbacks import get_openai_callback

with get_openai_callback() as cb:
    result = agent.invoke({"messages": [{"role": "user", "content": "帮我做个市场分析报告"}]})
    print(f"本次调用消耗：${cb.total_cost:.4f}")
    print(f"Token数：{cb.total_tokens}")

1
2
3
4
5
6
7

# LangGraph中设置递归限制
app = graph.compile(checkpointer=checkpointer)

config = {
    "configurable": {"thread_id": "session-1"},
    "recursion_limit": 25  # 最多25步，超过就报错
}

1
2
3
4
5
6
7

# CrewAI中设置最大迭代
agent = Agent(
    role="研究员",
    goal="...",
    max_iter=5,  # 最多迭代5次
    verbose=True
)

1
2
3
4
5

第1周：看完微软AI Agents for Beginners前6课，理解基础概念
第2周：用CrewAI或LangGraph做一个完整的Agent项目
第3周：学习多Agent协作模式，把你的单Agent升级为Agent团队
第4周：学习生产部署（Docker + LangSmith监控 + 成本控制）
持续学习：用Spec-Kit管理你的Agent项目，规范驱动开发