Auto-GPT 2026 부활: OG 자율 에이전트 프레임워크가 설정 시간을 80% 줄인 방법 — 신규 설치 가이드

python --version
# Expected: Python 3.10.x or higher

# 클론용 Git
git --version

# Docker (선택, 샌드박스 실행용)
docker --version

# 저장소 클론
git clone https://github.com/Significant-Gravitas/AutoGPT.git
cd AutoGPT

# pip로 설치 — 2026년 설치 프로그램이 자동으로 의존성 처리
pip install -e .

# 또는 설치 스크립트 사용 (권장)
./setup.sh
# 이것은 의존성 설치, 기본 경로 구성, 환경 검증을 수행한다

# 예시 설정 복사
cp .env.example .env

# API 키로 .env 편집
nano .env

# .env — 최소 필수 구성
# OpenAI (기본)
OPENAI_API_KEY=sk-your-openai-key-here

# 또는 Anthropic Claude
# ANTHROPIC_API_KEY=sk-ant-your-anthropic-key

# 또는 ollama를 통한 로컬 모델
# OLLAMA_BASE_URL=http://localhost:11434
# OLLAMA_MODEL=llama3.2

# 메모리 백엔드
MEMORY_BACKEND=chroma
CHROMA_PERSIST_DIR=./data/memory

# 샌드박스 코드 실행
EXECUTE_LOCAL_COMMANDS=False
DOCKER_CONTAINER_NAME=autogpt-sandbox

# 에이전트 설정
CONTINUOUS_MODE=True
CONTINUOUS_LIMIT=50  # 실행당 최대 반복 횟수

# 대화형 모드 — 에이전트가 각 단계에서 확인을 요청한다
autogpt

# 연속 모드 — 반복 한도까지 자율적으로 실행
autogpt --continuous

# 특정 목표로 (원샷 모드)
autogpt --goal "Research the top 5 Python web frameworks in 2026 and write a comparison report"

# 로컬 모델 사용
autogpt --llm ollama --model llama3.2

# 상태 확인 명령
autogpt --version
# Expected: autogpt 0.6.x

# 도구 레지스트리 테스트
autogpt --test-tools
# Expected output: All 12 default tools loaded successfully

{
  "protocol_version": "2.1",
  "message_type": "task_delegate",
  "sender_id": "research_agent",
  "recipient_id": "writer_agent",
  "payload": {
    "task_id": "task_001",
    "task_description": "Write a summary of Python async frameworks",
    "context": {
      "source_material": "...",
      "target_length": 500,
      "style": "technical"
    },
    "deadline": "2026-05-19T12:00:00Z"
  },
  "timestamp": "2026-05-19T10:30:00Z"
}

# multi_agent_demo.py
from autogpt.agent import Agent
from autogpt.protocol import AgentProtocol
from autogpt.orchestrator import Orchestrator

# 전문 에이전트 생성
researcher = Agent(
    name="researcher",
    role="Research specialist — finds and analyzes information from the web",
    llm_provider="openai",
    tools=["web_browse", "memory_search"]
)

writer = Agent(
    name="writer",
    role="Technical writer — creates clear, structured documentation",
    llm_provider="openai",
    tools=["file_ops", "memory_search"]
)

code_agent = Agent(
    name="code_agent",
    role="Python developer — writes and tests code",
    llm_provider="openai",
    tools=["code_execute", "file_ops", "shell_command"]
)

# 오케스트레이터가 통신 관리
orchestrator = Orchestrator(agents=[researcher, writer, code_agent])

# 협업이 필요한 복잡한 목표 정의
result = orchestrator.run(
    goal="Research the latest Python async frameworks, write a comparison guide, "
         "and provide working code examples for each framework",
    max_iterations=30
)

print(result.final_output)

# 에이전트는 동적으로 다른 에이전트에게 하위 작업을 위임할 수 있다
class ResearchAgent(Agent):
    def handle_task(self, task):
        if task.complexity > 0.7:
            # 작성을 writer 에이전트에게 위임
            return self.protocol.delegate(
                to="writer",
                task="summarize_research",
                context=self.gather_sources()
            )
        return self.execute(task)

# Auto-GPT는 JavaScript 렌더링 페이지를 자동으로 처리하고
# 구조화된 데이터를 추출한다

from autogpt.tools import WebBrowseTool

browser = WebBrowseTool()

# 탐색 및 추출
result = browser.browse(
    url="https://docs.python.org/3/library/asyncio.html",
    extract_type="text",
    max_length=5000
)

print(result.content[:500])
# Output: The asyncio library is used to write concurrent code using...

# 폼 처리 및 검색
search_result = browser.search(
    query="Python async frameworks 2026 benchmark",
    engine="duckduckgo",
    num_results=5
)

for r in search_result.results:
    print(f"{r.title}: {r.url}")

from autogpt.tools import FileOpsTool

file_tool = FileOpsTool(sandbox_dir="./workspace")

# 파일 읽기
content = file_tool.read("data/input.txt")

# 자동 백업으로 쓰기
file_tool.write("output/report.md", "# Analysis Results\n\n...")

# 코드 분석
analysis = file_tool.analyze_code("src/app.py")
print(f"Lines: {analysis.line_count}, Functions: {analysis.function_count}")

# 코드는 격리된 Docker 컨테이너에서 실행된다
from autogpt.tools import CodeExecuteTool

code_tool = CodeExecuteTool(container="autogpt-sandbox")

# 안전하게 Python 실행
result = code_tool.execute("""
import numpy as np

data = np.random.randn(1000)
print(f"Mean: {data.mean():.4f}")
print(f"Std: {data.std():.4f}")
""")

print(result.stdout)
# Output: Mean: 0.0123
#         Std: 0.9876

# 실패한 실행은 포착되고 보고된다
if result.error:
    print(f"Error: {result.error}")

# 자신만의 도구 등록
from autogpt.tools import ToolRegistry

@ToolRegistry.register(
    name="send_slack",
    description="Send a notification to Slack",
    parameters={
        "channel": "string — Slack channel name",
        "message": "string — Message to send"
    }
)
def send_slack(channel: str, message: str) -> str:
    import requests
    webhook_url = "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
    requests.post(webhook_url, json={"channel": channel, "text": message})
    return f"Message sent to #{channel}"

# 이제 에이전트가 이 도구를 자동으로 사용할 수 있다
# LLM이 설명을 보고 언제 호출할지 결정한다

# Dockerfile.autogpt
FROM python:3.11-slim

WORKDIR /app

# Playwright 의존성 설치
RUN apt-get update && apt-get install -y \
    chromium-driver \
    && rm -rf /var/lib/apt/lists/*

# 복사 및 설치
COPY requirements.txt .
RUN pip install -r requirements.txt
RUN playwright install chromium

COPY . .

# 연속 모드로 목표 파일과 함께 실행
CMD ["autogpt", "--continuous", "--goal-file", "/app/goals/main.json"]

# docker-compose.yml
version: "3.8"

services:
  autogpt:
    build:
      context: .
      dockerfile: Dockerfile.autogpt
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - MEMORY_BACKEND=chroma
      - CHROMA_HOST=chroma
      - CHROMA_PORT=8000
      - CONTINUOUS_MODE=True
      - CONTINUOUS_LIMIT=100
    volumes:
      - ./workspace:/app/workspace
      - ./goals:/app/goals
      - ./data:/app/data
    depends_on:
      - chroma
      - redis
    restart: unless-stopped

  chroma:
    image: chromadb/chroma:0.6.0
    volumes:
      - chroma_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data

  # 선택: 코드 실행 샌드박스
  sandbox:
    image: python:3.11-slim
    command: tail -f /dev/null
    security_opt:
      - no-new-privileges:true
    read_only: true
    tmpfs:
      - /tmp

volumes:
  chroma_data:
  redis_data:

# 스택 배포
docker-compose up -d

# 에이전트 로그 확인
docker-compose logs -f autogpt

# 모두 중지
docker-compose down

# autogpt-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: autogpt
spec:
  replicas: 1
  selector:
    matchLabels:
      app: autogpt
  template:
    metadata:
      labels:
        app: autogpt
    spec:
      containers:
      - name: autogpt
        image: autogpt:latest
        env:
        - name: OPENAI_API_KEY
          valueFrom:
            secretKeyRef:
              name: autogpt-secrets
              key: openai-key
        - name: MEMORY_BACKEND
          value: "chroma"
        - name: CHROMA_HOST
          value: "chroma-service"
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "2000m"

# 전문 에이전트 동작 정의
from autogpt.agent import AgentConfig

config = AgentConfig(
    name="security_auditor",
    role="Security-focused code reviewer who checks for vulnerabilities",
    personality="meticulous, skeptical, thorough",
    constraints=[
        "Never execute code without reviewing it first",
        "Always check for SQL injection vulnerabilities",
        "Flag any use of eval() or exec()"
    ],
    allowed_tools=["file_ops", "code_execute", "web_browse"],
    max_iterations=25
)

agent = Agent(config=config)
result = agent.run("Audit the auth module in src/auth.py")

# 에이전트 코드를 변경하지 않고 LLM 제공자 전환
from autogpt.llm import LLMManager

# OpenAI 사용
llm = LLMManager.create(provider="openai", model="gpt-4o")

# Anthropic으로 전환
llm = LLMManager.create(provider="anthropic", model="claude-sonnet-4-20250514")

# 로컬 모델 사용
llm = LLMManager.create(provider="ollama", model="llama3.2", base_url="http://localhost:11434")

# 백엔드와 관계없이 에이전트는 동일하게 작동
agent = Agent(llm=llm)

# Auto-GPT는 기능 확장을 위한 플러그인을 지원한다
# 플러그인을 plugins/ 디렉토리에 배치

# plugins/custom_logger.py
from autogpt.plugins import Plugin

class CustomLogger(Plugin):
    def on_agent_start(self, agent):
        print(f"[{agent.name}] Agent started with goal: {agent.goal}")

    def on_step_complete(self, agent, step, result):
        with open("agent_log.txt", "a") as f:
            f.write(f"[{agent.name}] Step {step}: {result.summary}\n")

    def on_agent_finish(self, agent, result):
        print(f"[{agent.name}] Agent finished. Final output length: {len(result.final_output)}")