┌─────────────────────────────────────┐
│         LangGraph Platform          │  ← 部署、扩展、监控层
│   (LangSmith Deployment + Studio)    │
├─────────────────────────────────────┤
│         LangGraph Framework          │  ← 编排层
│  StateGraph / Node / Edge / Reducer  │
├─────────────────────────────────────┤
│         LangGraph Runtime            │  ← 执行层
│  Checkpoint / Persistence / Streaming│
└─────────────────────────────────────┘

from langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    next_action: str
    retry_count: int

def researcher(state: AgentState) -> dict:
    """研究节点：分析任务，决定下一步"""
    return {"next_action": "write", "messages": [...]}

def writer(state: AgentState) -> dict:
    """写作节点：根据研究结果生成内容"""
    return {"next_action": "review", "messages": [...]}

def reviewer(state: AgentState) -> dict:
    """审核节点：质量检查，可退回重写"""
    if quality_check() < 0.8:
        return {"next_action": "write", "retry_count": state["retry_count"] + 1}
    return {"next_action": "end"}

def route_after_review(state: AgentState) -> str:
    if state["retry_count"] > 3:
        return END
    return state["next_action"]

graph = StateGraph(AgentState)
graph.add_node("researcher", researcher)
graph.add_node("writer", writer)
graph.add_node("reviewer", reviewer)
graph.add_edge(START, "researcher")
graph.add_conditional_edges("reviewer", route_after_review)
graph.add_edge("researcher", "writer")
graph.add_edge("writer", "reviewer")
graph.add_edge("reviewer", END)

app = graph.compile(checkpointer=SqliteSaver("agent.db"))

from crewai import Agent, Task, Crew, Flow, listen, start

class ContentPipeline(Flow):
    @start()
    def receive_brief(self):
        return {"topic": self.inputs["topic"], "depth": "deep"}

    @listen("receive_brief")
    def research(self, inputs):
        researcher = Agent(
            role="Senior Research Analyst",
            goal=f"Research {inputs['topic']} thoroughly",
            backstory="Expert analyst with 10 years experience",
            tools=[search_tool, scrape_tool]
        )
        task = Task(description="...", agent=researcher)
        crew = Crew(agents=[researcher], tasks=[task])
        result = crew.kickoff()
        return {"research": result, "topic": inputs["topic"]}

    @listen("research")
    def write_and_review(self, inputs):
        # Flows允许并行或串行编排多个Crew
        writer = Agent(role="Writer", ...)
        reviewer = Agent(role="Editor", ...)
        crew = Crew(agents=[writer, reviewer], tasks=[...])
        return crew.kickoff()

flow = ContentPipeline()
result = flow.kickoff(inputs={"topic": "AI Agent Frameworks 2026"})

import ag2

# 定义带工具的Agent
researcher = ag2.AssistantAgent(
    name="researcher",
    system_message="You are a research specialist.",
    llm_config={"model": "gpt-4o", "api_key": "..."},
    tools=[web_search, read_file]
)

writer = ag2.AssistantAgent(
    name="writer",
    system_message="You write compelling articles based on research.",
    llm_config={"model": "gpt-4o"}
)

# 事件驱动的多Agent对话
group_chat = ag2.GroupChat(
    agents=[researcher, writer],
    messages=[],
    max_round=10
)
manager = ag2.GroupChatManager(groupchat=group_chat)
researcher.initiate_chat(manager, message="Research and write about AI agents")

from openai import agents

# 定义带Sandbox的Agent
agent = agents.Agent(
    name="data_analyst",
    model="o3",
    instructions="Analyze data files and create visualizations.",
    tools=[
        agents.sandbox_tool(),       # 原生沙箱代码执行
        agents.file_search_tool(),   # 文件搜索
        agents.web_search_tool(),    # 网页搜索
    ]
)

# Harness管理执行循环
result = agents.Run.create(
    agent=agent,
    input="Analyze the sales.csv file and create a trend chart",
    sandbox=agents.SandboxConfig(
        timeout=300,
        memory_limit="512Mi",
        network_access=False
    )
)

print(result.final_output)
print(f"Tokens used: {result.usage.total_tokens}")
print(f"Sandbox logs: {result.sandbox_logs}")

from google.adk import Agent, Tool, Runner
from google.adk.tools import google_search, code_execution

# ADK的Tool-First设计哲学
research_agent = Agent(
    name="researcher",
    model="gemini-3.5-flash",
    instruction="Research the given topic thoroughly.",
    tools=[google_search(), code_execution()]
)

writing_agent = Agent(
    name="writer",
    model="gemini-2.5-pro",
    instruction="Write an engaging article based on research."
)

# A2A协议：Agent间通过标准化协议通信
from google.adk.a2a import A2AClient, RemoteAgent

remote_researcher = RemoteAgent(
    url="https://my-agent-cloud.run.app",
    agent_card={"name": "researcher", "capabilities": ["web_search", "analysis"]}
)

# 本地Agent调用远程Agent
result = writing_agent.run(
    input="Write about quantum computing",
    remote_agents=[remote_researcher]
)

from strands import Agent, Tool

@Tool
def search_web(query: str) -> str:
    """Search the web for information."""
    return web_search_api(query)

@Tool
def read_file(path: str) -> str:
    """Read a file from disk."""
    with open(path) as f:
        return f.read()

@Tool
def run_code(code: str) -> str:
    """Execute Python code safely."""
    return sandbox_execute(code)

agent = Agent(
    model="anthropic.claude-3.5-sonnet",
    tools=[search_web, read_file, run_code]
)

# 模型自主决定调用顺序，无需显式编排
result = agent("Analyze the quarterly report and generate a summary chart")

from pydantic_ai import Agent
from pydantic import BaseModel
from dataclasses import dataclass

class ResearchResult(BaseModel):
    summary: str
    sources: list[str]
    confidence: float

@dataclass
class Dependencies:
    db_connection: Database
    api_key: str

research_agent = Agent(
    model="openai:gpt-4o",       # 模型无关：支持任意提供商
    result_type=ResearchResult,    # 结构化输出，Pydantic验证
    deps_type=Dependencies,        # 依赖注入
    system_prompt="You are a research analyst."
)

@research_agent.tool
async def search_database(ctx: RunContext[Dependencies], query: str) -> str:
    """搜索数据库获取信息"""
    return await ctx.deps.db_connection.search(query)

result = await research_agent.run(
    "What are the latest trends in AI agents?",
    deps=Dependencies(db=db, api_key="...")
)
print(result.data.summary)         # 类型安全，IDE自动补全
print(result.data.confidence)      # Pydantic验证，保证数据质量

graph TB
    subgraph "第一代 Agent框架 2023-2024"
        LC[LangChain Chains]
        CA0[CrewAI Crew]
        AG0[AutoGen ConversableAgent]
    end

    subgraph "第二代 Agent框架 2025-2026"
        direction TB
        subgraph "编排优先"
            LG[LangGraph<br/>StateGraph+Reducer<br/>★★★★★]
            CF[CrewAI Flows<br/>事件驱动DAG<br/>★★★★]
            AG2[AG2/AutoGen<br/>事件驱动+GroupChat<br/>★★★]
        end
        subgraph "云厂商原生"
            OAI[OpenAI Agents SDK<br/>Harness+Sandbox<br/>★★★★]
            GADK[Google ADK 1.0<br/>A2A协议+Antigravity<br/>★★★]
            STR[Amazon Strands<br/>Model-Driven+Bedrock<br/>★★★]
        end
        subgraph "工程质量"
            PAI[PydanticAI<br/>类型安全+模型无关<br/>★★★★]
        end
    end

    subgraph "基础设施层 2026"
        MCP[MCP协议<br/>工具互操作]
        A2A[A2A协议<br/>Agent间互操作]
        OBS[可观测性<br/>LangSmith/CloudWatch/Trace]
        SBX[安全沙箱<br/>Sandbox/Cloud Run/AgentCore]
    end

    LC --> LG
    CA0 --> CF
    AG0 --> AG2

    LG --> MCP
    OAI --> MCP
    GADK --> A2A
    STR --> MCP
    STR --> SBX
    OAI --> SBX
    GADK --> OBS
    LG --> OBS

    style LG fill:#4CAF50,color:#fff
    style CF fill:#8BC34A,color:#fff
    style AG2 fill:#FFC107,color:#333
    style OAI fill:#2196F3,color:#fff
    style GADK fill:#FF5722,color:#fff
    style STR fill:#FF9800,color:#fff
    style PAI fill:#9C27B0,color:#fff

graph TD
    START[选择Agent框架] --> Q1{需要多Agent协作?}
    Q1 -->|否| Q2{主要用什么模型?}
    Q1 -->|是| Q3{Agent需要跨框架通信?}

    Q2 -->|OpenAI| OAI[OpenAI Agents SDK<br/>Sandbox+Harness开箱即用]
    Q2 -->|任意模型| PAI[PydanticAI<br/>类型安全+模型无关]
    Q2 -->|Gemini| GADK[Google ADK<br/>Gemini原生优化]

    Q3 -->|是| GADK2[Google ADK<br/>A2A协议唯一选择]
    Q3 -->|否| Q4{团队技术背景?}

    Q4 -->|工程师为主| LG[LangGraph<br/>图编排+状态管理]
    Q4 -->|混合团队| CA[CrewAI<br/>角色扮演+Flows]
    Q4 -->|AWS原生| STR2[Amazon Strands<br/>Bedrock深度集成]
    Q4 -->|学术研究| AG2[AG2/AutoGen<br/>GroupChat多轮对话]

    style OAI fill:#2196F3,color:#fff
    style PAI fill:#9C27B0,color:#fff
    style GADK fill:#FF5722,color:#fff
    style GADK2 fill:#FF5722,color:#fff
    style LG fill:#4CAF50,color:#fff
    style CA fill:#8BC34A,color:#fff
    style STR2 fill:#FF9800,color:#fff
    style AG2 fill:#FFC107,color:#333