flowchart TB
    subgraph CLI/API["入口层"]
        A[CLI Command] --> B[software_company.generate_repo]
        C[Python API] --> B
    end
    
    subgraph Core["核心框架层"]
        B --> D[Context]
        D --> E[Config]
        D --> F[LLM Provider]
        B --> G[Team]
        G --> H[Environment]
        H --> I[Message Queue]
    end
    
    subgraph Roles["角色层"]
        G -.雇佣.-> J[TeamLeader]
        G -.雇佣.-> K[ProductManager]
        G -.雇佣.-> L[Architect]
        G -.雇佣.-> M[Engineer]
        G -.雇佣.-> N[DataAnalyst]
        
        J --> O[Role Base]
        K --> O
        L --> O
        M --> O
        N --> O
    end
    
    subgraph Actions["动作层"]
        O --> P[Action Base]
        P --> Q[WritePRD]
        P --> R[WriteDesign]
        P --> S[WriteCode]
        P --> T[RunCode]
        P --> U[WriteTest]
    end
    
    subgraph Support["支持层"]
        F --> V[OpenAI]
        F --> W[Anthropic]
        F --> X[Azure]
        F --> Y[Gemini]
        F --> Z[Ollama]
        
        O --> AA[Memory]
        O --> AB[Context Mixin]
        
        AA --> AC[Storage]
        AA --> AD[Index]
        
        P --> AE[LLM Call]
        P --> AF[Prompt Template]
    end
    
    subgraph Infra["基础设施层"]
        H --> AG[Document Store]
        H --> AH[RAG Engine]
        H --> AI[Tool Registry]
        
        AG --> AJ[File System]
        AH --> AK[Vector DB/FAISS]
        AI --> AL[Built-in Tools]
    end
    
    I -.消息传递.-> O
    O -.观察消息.-> I
    O -.执行.-> P
    P -.调用.-> AE
    AE -.使用.-> F

用户需求 → Message → Environment → 各角色的 Memory 
→ Action 处理 → LLM 生成内容 → 新 Message → Environment

Team.run() → Environment.run() → 
  循环：各 Role._observe() → _think() → _act() → publish_message()
→ 直到达到轮次上限或所有角色空闲

sequenceDiagram
    autonumber
    participant U as User
    participant CLI as CLI/API
    participant T as Team
    participant E as Environment
    participant PM as ProductManager
    participant A as Architect
    participant EN as Engineer
    participant DA as DataAnalyst
    participant LLM as LLM Provider
    participant FS as FileSystem
    
    U->>CLI: metagpt "Create a 2048 game"
    CLI->>T: generate_repo(idea, ...)
    T->>T: hire([ProductManager, Architect, Engineer, ...])
    T->>E: add_roles(roles)
    T->>T: invest(investment=3.0)
    T->>E: publish_message(UserRequirement)
    
    Note over E: 开始运行循环（n_round=5）
    
    loop 每个轮次
        E->>E: run()
        E->>PM: _observe() - 检查 MessageQueue
        PM->>PM: _think() - 决定下一步动作
        PM->>PM: _act() - 执行 WritePRD
        PM->>LLM: aask("写产品需求文档...")
        LLM-->>PM: PRD content
        PM->>FS: 保存 PRD 文档
        PM->>E: publish_message(PRD Message)
        
        E->>A: _observe() - 发现 PRD 消息
        A->>A: _think() - 决定执行 WriteDesign
        A->>A: _act() - 执行 WriteDesign
        A->>LLM: aask("根据 PRD 设计系统架构...")
        LLM-->>A: Design Doc + API Design
        A->>FS: 保存设计文档
        A->>E: publish_message(Design Message)
        
        E->>EN: _observe() - 发现 Design 消息
        EN->>EN: _think() - 决定执行 WriteCode
        EN->>EN: _act() - 执行 WriteCode
        EN->>LLM: aask("根据设计文档编写代码...")
        LLM-->>EN: Code files
        EN->>FS: 保存代码文件
        EN->>EN: _act() - 执行 RunCode
        EN->>FS: 运行代码并获取结果
        EN->>E: publish_message(Code Message)
        
        E->>DA: _observe() - 发现 Code 消息
        DA->>DA: _think() - 决定是否需要数据分析
        DA->>DA: _act() - 执行数据分析（如果需要）
        DA->>LLM: aask("分析代码质量...")
        LLM-->>DA: Analysis result
        DA->>E: publish_message(Analysis Message)
        
        E->>E: 检查所有角色是否空闲
    end
    
    Note over E: 循环结束条件：n_round=0 或所有角色空闲
    
    E->>FS: archive() - 归档项目
    T-->>CLI: 返回项目路径
    CLI-->>U: 输出项目完成信息

llm:
  api_type: "openai"  # LLM 类型
  model: "gpt-4-turbo"  # 模型名称
  base_url: "https://api.openai.com/v1"  # API 端点
  api_key: "YOUR_API_KEY"  # API 密钥
  
workspace:
  path: "./workspace"  # 工作目录路径
  
logs:
  level: "INFO"  # 日志级别

# 安装
pip install metagpt

# 初始化配置
metagpt --init-config

# 运行项目
metagpt "Create a 2048 game"

from metagpt.software_company import generate_repo

# 一行代码生成项目
project_path = generate_repo("Create a 2048 game")
print(f"Project generated at: {project_path}")

from metagpt.roles import Role
from metagpt.actions import Action
from metagpt.schema import Message
from metagpt.team import Team

# 自定义动作
class WriteTestPlan(Action):
    name: str = "WriteTestPlan"
    
    async def run(self, context: str) -> str:
        prompt = f"根据以下内容编写测试计划：\n{context}"
        return await self.llm.aask(prompt)

# 自定义角色
class TestEngineer(Role):
    name: str = "TestEngineer"
    profile: str = "测试工程师"
    
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.set_actions([WriteTestPlan])
        self._watch([WritePRD, WriteDesign])  # 监听 PRD 和 Design 消息

# 使用自定义角色
team = Team()
team.hire([
    ProductManager(),
    Architect(),
    Engineer(),
    TestEngineer(),  # 添加自定义角色
])
team.invest(5.0)
await team.run(n_round=5, idea="开发一个在线聊天系统")

# 1. 自定义 LLM Provider
from metagpt.provider.base_llm import BaseLLM
from metagpt.provider.llm_provider_registry import register_provider
from metagpt.configs.llm_config import LLMType

@register_provider([LLMType.CUSTOM])
class CustomLLM(BaseLLM):
    def __init__(self, config):
        self.config = config
        # 初始化自定义 LLM 客户端
    
    async def aask(self, prompt: str, **kwargs) -> str:
        # 实现自定义 LLM 调用逻辑
        pass

# 2. 注册自定义工具
from metagpt.tools.tool_registry import register_tool

@register_tool()
class DatabaseQuery:
    """数据库查询工具"""
    
    async def query(self, sql: str) -> list:
        """执行 SQL 查询"""
        # 实现查询逻辑
        pass

# 3. 自定义记忆存储
from metagpt.memory import Memory

class RedisMemory(Memory):
    """使用 Redis 作为记忆存储"""
    
    def __init__(self, redis_url: str):
        self.redis_client = redis.from_url(redis_url)
    
    def add(self, message: Message):
        # 存储到 Redis
        pass
    
    def get(self, k=0) -> list[Message]:
        # 从 Redis 检索
        pass