AutoGen AgentChat 기반으로 구축된 멀티 에이전트 리서치 및 리포트 파이프라인

# AutoGen AgentChat 파이프라인 설정

## 1. 의존성 설치

```bash
pip install "autogen-agentchat" "autogen-ext[openai]"
```

## 2. `config.py` — 에이전트 프롬프트

```python
"""Agent prompts and pipeline configuration."""

MODEL = "gpt-4o-mini"
MAX_TURNS = 12
REPORTS_DIR = "reports"

PLANNER_PROMPT = """You are the Planner. Break the user's request into a short,
ordered list of research questions and a proposed outline. Be concise. Do not
write the final draft yourself."""

RESEARCHER_PROMPT = """You are the Researcher. For each question from the Planner,
provide factual notes, key points, and any caveats. If you are unsure, say so
explicitly rather than inventing details."""

WRITER_PROMPT = """You are the Writer. Using the Planner's outline and the
Researcher's notes, produce a clear, well-structured draft. Do not add facts
that were not provided by the Researcher."""

CRITIC_PROMPT = """You are the Critic. Review the Writer's draft for accuracy,
clarity, and completeness. If it is acceptable, reply with a message that
starts with the exact token APPROVED and then a one-line summary. Otherwise,
list concrete, actionable revisions and do not use the APPROVED token."""
```

## 3. `pipeline.py` — 팀 구성 및 실행

```python
"""AutoGen AgentChat pipeline: planner -> researcher -> writer -> critic."""

import asyncio
import json
import os
from datetime import datetime

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.conditions import MaxMessageTermination, TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient

import config


def build_team() -> RoundRobinGroupChat:
    model_client = OpenAIChatCompletionClient(model=config.MODEL)

    planner = AssistantAgent(
        name="planner",
        model_client=model_client,
        system_message=config.PLANNER_PROMPT,
    )
    researcher = AssistantAgent(
        name="researcher",
        model_client=model_client,
        system_message=config.RESEARCHER_PROMPT,
    )
    writer = AssistantAgent(
        name="writer",
        model_client=model_client,
        system_message=config.WRITER_PROMPT,
    )
    critic = AssistantAgent(
        name="critic",
        model_client=model_client,
        system_message=config.CRITIC_PROMPT,
    )

    termination = TextMentionTermination("APPROVED") | MaxMessageTermination(
        config.MAX_TURNS
    )

    return RoundRobinGroupChat(
        [planner, researcher, writer, critic],
        termination_condition=termination,
    )


def _extract_final_draft(messages) -> str:
    """Return the last message authored by the writer agent."""
    for msg in reversed(messages):
        if getattr(msg, "source", None) == "writer":
            return msg.content
    return ""


def _serialize_transcript(messages) -> list[dict]:
    out = []
    for msg in messages:
        out.append(
            {
                "source": getattr(msg, "source", None),
                "type": type(msg).__name__,
                "content": getattr(msg, "content", None),
            }
        )
    return out


async def run(task: str) -> None:
    team = build_team()
    result = await team.run(task=task)

    os.makedirs(config.REPORTS_DIR, exist_ok=True)
    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")

    draft_path = os.path.join(config.REPORTS_DIR, f"draft-{stamp}.md")
    transcript_path = os.path.join(config.REPORTS_DIR, f"transcript-{stamp}.json")

    with open(draft_path, "w", encoding="utf-8") as f:
        f.write(_extract_final_draft(result.messages))

    with open(transcript_path, "w", encoding="utf-8") as f:
        json.dump(_serialize_transcript(result.messages), f, indent=2, ensure_ascii=False)

    print(f"Wrote {draft_path}")
    print(f"Wrote {transcript_path}")


if __name__ == "__main__":
    import sys

    task = " ".join(sys.argv[1:]) or "Write a short briefing on the state of MCP adoption."
    asyncio.run(run(task))
```

## 4. `README.md` 노트 추가

```markdown
## AutoGen pipeline

This repo includes a small AutoGen AgentChat pipeline (`pipeline.py`) with a
planner, researcher, writer, and critic agent. It runs as a round-robin team
and stops when the critic emits `APPROVED` or after `MAX_TURNS` messages.

> **Note:** AutoGen is archived. Microsoft Agent Framework is the successor
> project. This pipeline is kept for reference and may be migrated in the
> future.
```

## 5. 실행

```bash
export OPENAI_API_KEY=...
python pipeline.py "Write a short briefing on the state of MCP adoption."
```

`reports/`에 `draft-<timestamp>.md`와 `transcript-<timestamp>.json`이 생성됩니다.