MetaGPT & MetaTool - LLM 기반 다중 에이전트 협력 프레임워크

업데이트: April 24, 2026

개요

MetaGPT와 MetaTool은 대규모 언어 모델(LLM)의 능력을 활용하여 복잡한 작업을 해결하기 위한 혁신적인 프레임워크입니다. 전통적인 단일 에이전트 방식의 한계를 극복하기 위해, 메타 프로그래밍(Meta Programming) 개념을 도입하여 여러 LLM 에이전트가 소프트웨어 회사와 같은 조직 구조를 이루고 협력하는 방식입니다.

1. 개념 (Concept)

1.1 MetaGPT란?

MetaGPT는 “Meta Programming for A Multi-Agent Collaborative Framework”의 약자로, 다음과 같은 핵심 특징을 가진 프레임워크입니다:

소프트웨어 회사 시뮬레이션: LLM 기반의 역할(Role)들이 실제 소프트웨어 회사의 조직 구조를 형성
표준 운영 절차(SOP) 기반: 효율적인 워크플로우를 구조화된 프롬프트 시퀀스로 인코딩
복잡한 작업 분해: 한 줄의 요구사항을 입력으로 받아 사용자 스토리, 경쟁 분석, 아키텍처, 코드 등을 출력

1.2 MetaTool 방식

MetaTool은 더 광범위한 도구 사용 패러다임으로, LLM이 다양한 도구와 함수를 활용하여 작업을 수행하는 방식입니다:

특성	설명
도구 인식	LLM이 사용 가능한 도구의 목록과 사용법을 인식
지능형 선택	주어진 작업에 적합한 도구를 자동으로 선택
반복적 실행	도구를 사용한 결과를 바탕으로 다음 단계 결정
오류 해결	도구 사용 오류를 감지하고 수정

1.3 핵심 철학

Code = SOP(Team)

MetaGPT의 핵심 철학은 코드를 팀의 표준 운영 절차(SOP)로 표현하는 것입니다. 즉:

복잡한 작업은 여러 역할의 협력으로 구성
각 역할은 명확한 책임과 워크플로우를 가짐
LLM들이 인간처럼 도메인 전문성을 가지고 중간 결과를 검증
이를 통해 할루시네이션으로 인한 오류 감소

2. 메커니즘 (Mechanism)

2.1 다중 에이전트 협력 구조

┌─────────────────────────────────────┐
│      한 줄 요구사항 (Requirement)     │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│      메타 프로그래밍 엔진              │
│    (Meta Programming Engine)        │
└──────────────┬──────────────────────┘
               │
      ┌────────┼────────┬─────────┐
      ▼        ▼        ▼         ▼
   ┌─────┐ ┌──────┐ ┌────────┐ ┌────────┐
   │ PM  │ │Arch. │ │Manager │ │Engineer│
   │(상품)│ │(설계)│ │(프로젝트)│ │(개발)   │
   └─────┘ └──────┘ └────────┘ └────────┘
      │        │        │         │
      └────────┼────────┼─────────┘
               │
               ▼
   ┌─────────────────────────────────────┐
   │    협력된 결과물                      │
   │  - 사용자 스토리                      │
   │  - 아키텍처 설계                      │
   │  - 데이터 모델                        │
   │  - API 명세                          │
   │  - 구현 코드                         │
   └─────────────────────────────────────┘

2.2 에이전트 역할 구성

MetaGPT 시스템에는 다음과 같은 주요 역할들이 있습니다:

Product Manager (상품 관리자)

요구사항을 사용자 스토리로 변환
경쟁 분석 수행
제품 요구사항 정의(PRD) 작성

Architect (아키텍트)

소프트웨어 아키텍처 설계
기술 스택 선정
시스템 구조도 작성

Project Manager (프로젝트 관리자)

작업 분해 (Task Breakdown)
일정 관리
리스크 관리

Engineer (개발자)

실제 코드 작성
기술 구현
테스트 코드 작성

2.3 SOP 기반 워크플로우

Input: "2048 게임을 만들어줘"

↓

SOP 1: Product Manager
- 게임 요구사항 분석
- 사용자 스토리 작성
- 게임 규칙 문서화

↓

SOP 2: Architect
- 게임 구조 설계
- 데이터 모델 정의
  * GameState
  * Grid
  * Score

↓

SOP 3: Project Manager
- 구현 작업 분해
- 마일스톤 정의
- 의존성 정의

↓

SOP 4: Engineer
- 게임 로직 코드 작성
- UI/렌더링 구현
- 테스트 코드 작성

↓

Output: 완전한 2048 게임 프로젝트

3. 내부 구조 (Internal Architecture)

3.1 MetaGPT 시스템 아키텍처

┌─────────────────────────────────────────────┐
│         User Interface Layer                │
│  (CLI, Web UI, API Gateway)                 │
└────────────────┬────────────────────────────┘
                 │
┌─────────────────────────────────────────────┐
│      Multi-Agent Orchestration Layer        │
│  - Agent Manager                            │
│  - Message Queue                            │
│  - State Management                         │
└────────────────┬────────────────────────────┘
                 │
┌─────────────────────────────────────────────┐
│         Role Layer                          │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐     │
│  │   Role   │ │   Role   │ │   Role   │     │
│  │ Behavior │ │ Prompts  │ │ Actions  │     │
│  └──────────┘ └──────────┘ └──────────┘     │
└────────────────┬────────────────────────────┘
                 │
┌─────────────────────────────────────────────┐
│        Memory & Context Layer               │
│  - Message History                          │
│  - Shared Context                           │
│  - Knowledge Base                           │
└────────────────┬────────────────────────────┘
                 │
┌─────────────────────────────────────────────┐
│         LLM Integration Layer               │
│  - LLM API Client                           │
│  - Prompt Engineering                       │
│  - Response Parsing                         │
└────────────────┬────────────────────────────┘
                 │
┌─────────────────────────────────────────────┐
│          External Tools & APIs              │
│  - Code Execution                           │
│  - File Operations                          │
│  - Database Access                          │
└─────────────────────────────────────────────┘

3.2 Role 클래스 구조

MetaGPT의 핵심은 Role 클래스로, 각 에이전트는 Role을 상속받습니다:

# 기본 Role 구조
class Role:
    def __init__(self, name: str, profile: str):
        self.name = name
        self.profile = profile
        self.memory = Memory()  # 메시지 히스토리
        
    async def run(self, message: str):
        """역할 수행 실행"""
        pass
        
    async def think(self):
        """다음 행동 결정"""
        pass
        
    async def act(self):
        """행동 수행"""
        pass

3.3 Message 기반 통신

MetaGPT는 메시지 기반의 비동기 통신을 사용합니다:

@dataclass
class Message:
    role: str              # 송신자 역할
    content: str           # 메시지 내용
    inst: str              # 지시사항
    cause_by: Type[Action] # 어떤 액션으로 인한 메시지인지
    send_to: set[str]      # 수신자 역할

4. 주요 제품 및 실제 구현

4.1 MetaGPT Framework

주요 특징

Open Source: MIT 라이선스
Python 기반: Python 3.9 이상 필요
플러그인 지원: 커스텀 Role, Action 확장 가능
다양한 LLM 지원: OpenAI, Azure, Ollama, Groq 등

주요 내장 Role들

4.2 Data Interpreter

MetaGPT의 대표적인 활용 사례로, 데이터 분석을 자동화합니다:

from metagpt.roles.di.data_interpreter import DataInterpreter

async def main():
    di = DataInterpreter()
    # sklearn Iris 데이터셋 분석 및 시각화
    await di.run(
        "Iris 데이터셋 분석: 꽃받침 길이와 꽃잎 길이의 관계 분석 및 산점도 생성"
    )

4.3 MGX (MetaGPT X)

최신 제품으로, AI 에이전트 개발팀을 시뮬레이션합니다:

자연어 프로그래밍: 자연어로 소프트웨어 프로젝트 생성
전체 개발 사이클: 요구사항 → 설계 → 구현
산업 규모 결과물: 실제 사용 가능한 코드 생성

5. 활용 샘플 및 코드

5.1 기본 사용 예제 - CLI 방식

설치

# pip를 사용한 설치
pip install metagpt

# 초기 설정 (OpenAI API 키 필요)
metagpt --init-config

# 설정 파일 편집
vim ~/.metagpt/config2.yaml

config2.yaml 예제

llm:
  api_type: "openai"
  model: "gpt-4-turbo"
  base_url: "https://api.openai.com/v1"
  api_key: "your-api-key-here"
  
mermaid:
  engine: "playwright"
  width: 1200
  height: 800

5.2 실행 예제

CLI 사용법

# 2048 게임 생성
metagpt "Create a 2048 game"

# 뱀 게임 생성
metagpt "Create a snake game with pygame"

# 할일 앱 생성
metagpt "Create a todo application with Flask and SQLite"

# 결과는 ./workspace 디렉토리에 생성됨

5.3 Python 라이브러리로 사용

from metagpt.software_company import generate_repo
from metagpt.utils.project_repo import ProjectRepo

# 요구사항으로 저장소 생성
repo: ProjectRepo = generate_repo("Create a 2048 game")

# 생성된 프로젝트 구조 출력
print(repo)

5.4 커스텀 Role 만들기

from metagpt.roles import Role
from metagpt.actions import Action
from metagpt.logs import logger

# 커스텀 Action 정의
class AnalyzeTrends(Action):
    """트렌드 분석 액션"""
    
    async def run(self, context: str):
        # LLM을 사용하여 트렌드 분석
        prompt = f"""
        다음 시장 데이터를 분석하고 주요 트렌드를 파악해주세요:
        {context}
        
        분석 결과:
        1. 주요 트렌드
        2. 성장 분야
        3. 위험 요소
        """
        return await self.llm.aask(prompt)

# 커스텀 Role 정의
class MarketAnalyst(Role):
    """시장 분석가 역할"""
    
    def __init__(self):
        super().__init__(
            name="Market Analyst",
            profile="전문 시장 분석가"
        )
        self.set_actions([AnalyzeTrends()])
    
    async def _act(self):
        logger.info(f"{self.name} is analyzing market trends...")
        todo = self.rc.memory.get_by_role(None)
        result = await self.rc.execute(todo)
        return result

5.5 Data Interpreter 활용 예제

import asyncio
from metagpt.roles.di.data_interpreter import DataInterpreter

async def analyze_iris():
    """Iris 데이터셋 분석"""
    di = DataInterpreter()
    
    # 데이터 분석 및 시각화
    await di.run(
        """
        sklearn의 Iris 데이터셋을 로드하여:
        1. 각 꽃의 특성 통계 분석
        2. 품종별 특성 비교
        3. 꽃받침 길이와 꽃잎 길이의 관계를 산점도로 표시
        """
    )

# 실행
asyncio.run(analyze_iris())

5.6 다중 에이전트 협력 예제

from metagpt.team import Team
from metagpt.roles import ProductManager, Architect, Engineer

async def create_software_team():
    """소프트웨어 개발팀 구성"""
    
    # 팀 생성
    team = Team()
    
    # 역할 추가
    team.add_roles([
        ProductManager(),
        Architect(),
        Engineer(),
    ])
    
    # 요구사항 입력
    requirement = "간단한 API 서버를 만들어주세요. FastAPI를 사용하고 CRUD 기능을 지원해야 합니다."
    
    # 팀 실행
    await team.run(requirement)
    
    return team

# 실행
import asyncio
team = asyncio.run(create_software_team())

5.7 복잡한 워크플로우 예제

from metagpt.team import Team
from metagpt.actions import UserStoryBrainstorm, WritePRD
from metagpt.roles import ProductManager, Architect, Engineer, ProjectManager

async def complex_workflow():
    """복잡한 소프트웨어 개발 워크플로우"""
    
    team = Team()
    
    # 팀 구성
    team.add_roles([
        ProductManager(),
        Architect(),
        ProjectManager(),
        Engineer(),
    ])
    
    # 요구사항
    requirement = """
    전자상거래 플랫폼을 만들어주세요:
    - 사용자 인증 시스템
    - 상품 카탈로그 관리
    - 장바구니 기능
    - 결제 시스템
    - 주문 추적
    """
    
    # 실행
    repo = await team.run(requirement)
    
    # 생성된 파일 확인
    for file in repo.all_files:
        print(f"생성된 파일: {file}")

# 실행
asyncio.run(complex_workflow())

6. 아키텍처 패턴 및 Best Practices

6.1 메모리 관리

MetaGPT는 효율적인 메모리 관리를 위해 다양한 메모리 유형을 사용합니다:

from metagpt.memory import Memory, LongTermMemory

# 단기 메모리 (메시지 히스토리)
memory = Memory()
memory.add_message(message)

# 장기 메모리 (임베딩 기반 유사도 검색)
long_memory = LongTermMemory()
long_memory.add(content, vectorstore)

6.2 컨텍스트 관리

# 공유 컨텍스트를 통한 에이전트 간 정보 교환
shared_context = {
    "project_name": "MyProject",
    "requirements": "PRD 문서",
    "architecture": "설계 문서",
    "tasks": "작업 분해 구조"
}

# 각 에이전트가 필요한 정보 참조
product_manager_context = shared_context["requirements"]
architect_context = shared_context["architecture"]

6.3 오류 처리 및 재시도

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=4, max=10)
)
async def safe_llm_call(prompt: str):
    """재시도 로직을 포함한 LLM 호출"""
    try:
        response = await llm.aask(prompt)
        return response
    except Exception as e:
        logger.error(f"LLM 호출 실패: {e}")
        raise

7. 성능 및 최적화

7.1 병렬 처리

MetaGPT는 비동기 처리를 통해 여러 에이전트가 동시에 작업할 수 있습니다:

import asyncio

# 동시 실행
await asyncio.gather(
    product_manager.run(requirement),
    architect.run(prd),
    project_manager.run(design),
)

7.2 토큰 최적화

# 프롬프트 길이 제한
max_tokens = 4000

# 불필요한 정보 필터링
filtered_context = summarize_context(context, max_length=1000)

8. 실제 적용 사례

8.1 소프트웨어 개발 자동화

MetaGPT를 사용하면 단순한 텍스트 요구사항으로부터:

완전한 시스템 설계
실행 가능한 코드
테스트 케이스
문서

를 자동 생성할 수 있습니다.

8.2 데이터 분석 자동화

Data Interpreter를 사용하여:

데이터 로딩 및 전처리
통계 분석
시각화
인사이트 도출

을 자동으로 수행합니다.

8.3 연구 및 보고서 작성

커스텀 Role을 만들어:

주제 분석
자료 수집
보고서 작성
시각화 자료 생성

을 자동화할 수 있습니다.

9. 제한사항 및 고려사항

9.1 LLM 비용

OpenAI API 사용 시 토큰 기반 과금
복잡한 프로젝트는 큰 비용 발생 가능

9.2 코드 품질

생성된 코드가 항상 최적은 아님
리뷰 및 테스트 필요

9.3 시간 소요

복잡한 프로젝트는 여러 LLM 호출 필요
실행 시간이 길어질 수 있음

10. 향후 발전 방향

10.1 최신 개발 (2025년)

AFlow: 자동 에이전트 워크플로우 생성 (ICLR 2025 구두 발표)
SPO: 구조화된 프로그래밍 최적화
AOT: 에이전트 온톨로지 이론

10.2 예상되는 개선사항

더욱 정교한 메모리 관리
더 나은 에러 핸들링
성능 최적화
추론(Reasoning) 능력 강화

참조 및 리소스

공식 문서 및 저장소

자료	URL
GitHub 저장소	FoundationAgents/MetaGPT
공식 문서	MetaGPT Documentation
논문	MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework
Discord 커뮤니티	Join Discord
Twitter	@MetaGPT_

주요 논문

제목	설명	링크
MetaGPT	기초 논문	arXiv:2308.00352
AFlow	워크플로우 자동화	ICLR 2025
SPO	구조화 최적화	arXiv:2502.06855
AOT	에이전트 온톨로지	arXiv:2502.12018

결론

MetaGPT와 MetaTool은 LLM 기반의 자동화를 새로운 수준으로 끌어올린 혁신적인 프레임워크입니다. 단순한 텍스트 요구사항으로부터 완전한 소프트웨어를 생성할 수 있는 가능성은 소프트웨어 개발의 미래를 크게 바꿀 것으로 예상됩니다.

SOP 기반의 구조화된 접근방식은 LLM의 할루시네이션을 줄이고, 다중 에이전트 협력은 복잡한 문제를 효율적으로 해결합니다. 지속적인 개선과 새로운 기능 추가를 통해 MetaGPT는 AI 에이전트 시대의 핵심 플랫폼으로 자리잡을 것입니다.

Source Code: MetaGPT 소스 코드는 GitHub Repository에서 확인 가능합니다.

Kim

개요