Maestro: AI 기반 연구 자동화 플랫폼 완전 가이드 - 멀티 에이전트 시스템으로 연구 혁신하기
⏱️ 예상 읽기 시간: 22분
서론
현대 연구 환경에서 정보의 양은 기하급수적으로 증가하고 있지만, 연구자들이 이를 체계적으로 분석하고 종합할 시간은 한정적입니다. Maestro는 이러한 문제를 해결하기 위해 개발된 AI 기반 연구 자동화 플랫폼으로, 복잡한 연구 작업을 멀티 에이전트 시스템을 통해 자동화합니다.
이 튜토리얼에서는 Maestro의 핵심 아키텍처부터 실제 배포까지, 연구 워크플로우를 혁신할 수 있는 완전한 솔루션을 구축하는 방법을 알아보겠습니다.
Maestro 플랫폼 개요
핵심 기능과 특징
🤖 멀티 에이전트 시스템
- Planning Agent: 연구 계획 및 구조화
- Research Agent: 정보 수집 및 RAG 파이프라인 실행
- Reflection Agent: 비판적 검토 및 품질 관리
- Writing Agent: 보고서 작성 및 종합
- Agent Controller: 전체 워크플로우 관리
🔍 고급 연구 기능
- 로컬 RAG 파이프라인 지원
- 웹 검색 통합 (SearXNG)
- 실시간 연구 진행 추적
- 투명한 AI 추론 과정
- 완전 자체 호스팅 가능
💻 현대적 아키텍처
- FastAPI 백엔드
- React + TypeScript 프론트엔드
- WebSocket 실시간 통신
- SQLAlchemy + SQLite 데이터베이스
- Docker 컨테이너화
시스템 요구사항
하드웨어 요구사항
# 최소 사양
CPU: 4 cores (Intel i5 또는 AMD Ryzen 5 이상)
RAM: 8GB (16GB 권장)
Storage: 10GB 여유 공간
# 권장 사양 (AI 모델 포함)
CPU: 8 cores (Intel i7 또는 AMD Ryzen 7 이상)
RAM: 16GB (32GB 권장)
GPU: NVIDIA GPU (CUDA 지원, 8GB VRAM 이상)
Storage: 20GB 여유 공간 (SSD 권장)
소프트웨어 요구사항
# 필수 소프트웨어
Docker: 24.0 이상
Docker Compose: 2.0 이상
Git: 2.30 이상
# 선택사항 (개발 환경)
Node.js: 18.0 이상
Python: 3.9 이상
설치 및 환경 설정
1. 저장소 클론 및 기본 설정
# Maestro 저장소 클론
git clone https://github.com/murtaza-nasir/maestro.git
cd maestro
# 디렉토리 구조 확인
ls -la
maestro/
├── maestro_backend/ # FastAPI 백엔드
├── maestro_frontend/ # React 프론트엔드
├── evaluation/ # 성능 평가 도구
├── example reports/ # 예제 보고서
├── scripts/ # 설정 스크립트
├── docker-compose.yml # Docker 구성
├── setup-env.sh # 환경 설정 스크립트
└── README.md
2. 대화형 환경 설정
# 대화형 설정 스크립트 실행
chmod +x setup-env.sh
./setup-env.sh
설정 과정에서 다음 항목들을 구성합니다:
# 네트워크 설정
포트 설정: 3030 (기본값)
호스트 주소: localhost (기본값)
# API 키 설정
OpenAI API Key: [선택사항 - 로컬 모델 사용시 불필요]
SearXNG URL: [웹 검색용, 기본값 사용 가능]
# 데이터베이스 설정
SQLite 경로: ./data/maestro.db (기본값)
# 보안 설정
JWT Secret Key: [자동 생성]
Admin Password: [설정 필요]
3. 환경 변수 확인
생성된 .env 파일을 확인하고 필요시 수정합니다:
# .env 파일 내용 확인
cat .env
# 기본 설정 예시
FRONTEND_PORT=3030
BACKEND_PORT=8000
DATABASE_URL=sqlite:///./data/maestro.db
# API 설정
OPENAI_API_KEY=your_openai_key_here
SEARXNG_URL=https://search.example.com
# 보안 설정
JWT_SECRET_KEY=your_generated_secret_key
ADMIN_USERNAME=admin
ADMIN_PASSWORD=your_secure_password
# AI 모델 설정
LOCAL_MODEL_URL=http://localhost:11434 # Ollama 기본값
MODEL_NAME=llama2 # 사용할 모델명
Docker 기반 배포
1. 컨테이너 빌드 및 실행
# 컨테이너 빌드 및 백그라운드 실행
docker compose up --build -d
# 실행 상태 확인
docker compose ps
NAME COMMAND SERVICE STATUS PORTS
maestro-frontend-1 "docker-entrypoint.s…" frontend running 0.0.0.0:3030->3000/tcp
maestro-backend-1 "uvicorn main:app --…" backend running 0.0.0.0:8000->8000/tcp
maestro-db-1 "docker-entrypoint.s…" database running 5432/tcp
2. 로그 모니터링
# 전체 서비스 로그 확인
docker compose logs -f
# 특정 서비스 로그 확인
docker compose logs -f backend
docker compose logs -f frontend
3. 헬스체크 및 접속 확인
# 백엔드 헬스체크
curl http://localhost:8000/health
# 프론트엔드 접속 확인
curl http://localhost:3030
핵심 기능 활용 가이드
1. 첫 연구 미션 생성
웹 인터페이스(http://localhost:3030)에 접속 후:
// 연구 미션 예시
{
"title": "AI 윤리 가이드라인 분석",
"description": "최신 AI 윤리 가이드라인들을 비교 분석하고 핵심 원칙들을 도출",
"research_questions": [
"주요 AI 윤리 가이드라인들의 공통 원칙은 무엇인가?",
"각 가이드라인별 차이점과 특징은?",
"실무 적용을 위한 구체적 방안은?"
],
"sources": [
"local_documents",
"web_search"
]
}
2. 멀티 에이전트 워크플로우 이해
Phase 1: Planning
# Planning Agent 작업 흐름
def create_research_plan(mission):
"""
1. 연구 질문 분석
2. 계층적 연구 계획 수립
3. 보고서 개요 작성
4. 작업 우선순위 설정
"""
return structured_plan
Phase 2: Research & Reflection
# Research-Reflection Loop
def research_cycle(plan):
"""
1. Research Agent: 정보 수집
2. Reflection Agent: 품질 검토
3. 필요시 계획 수정
4. 추가 연구 수행
"""
while not research_complete:
findings = research_agent.gather_info()
feedback = reflection_agent.critique(findings)
if feedback.requires_more_research:
plan = update_plan(feedback)
else:
break
return comprehensive_findings
Phase 3: Writing & Finalization
# Writing-Reflection Loop
def writing_cycle(findings):
"""
1. Writing Agent: 보고서 초안 작성
2. Reflection Agent: 글 검토
3. 필요시 수정 및 개선
4. 최종 보고서 완성
"""
draft = writing_agent.create_draft(findings)
while not writing_approved:
feedback = reflection_agent.review_writing(draft)
draft = writing_agent.revise(draft, feedback)
return final_report
3. RAG 파이프라인 활용
문서 업로드 및 인덱싱
# CLI를 통한 문서 일괄 업로드
docker exec -it maestro-backend-1 python scripts/ingest_documents.py \
--directory /path/to/documents \
--format pdf,docx,txt \
--chunk_size 1000 \
--overlap 200
벡터 데이터베이스 확인
# 인덱싱된 문서 확인
from maestro_backend.vector_store import VectorStore
store = VectorStore()
documents = store.list_documents()
print(f"총 {len(documents)}개 문서가 인덱싱되었습니다.")
# 유사도 검색 테스트
results = store.similarity_search("AI ethics principles", k=5)
for doc in results:
print(f"문서: {doc.source}, 유사도: {doc.score:.3f}")
4. 웹 검색 통합 (SearXNG)
SearXNG 설정
# docker-compose.yml에 SearXNG 추가
services:
searxng:
image: searxng/searxng:latest
ports:
- "8080:8080"
environment:
- SEARXNG_SECRET=your_secret_key
volumes:
- ./searxng:/etc/searxng
검색 설정 최적화
# searxng/settings.yml
search:
default_lang: "ko"
autocomplete: "google"
safe_search: 1
engines:
- name: google
weight: 1.0
disabled: false
- name: scholar
weight: 1.5
disabled: false
- name: arxiv
weight: 2.0
disabled: false
고급 설정 및 최적화
1. 로컬 LLM 모델 설정
Ollama 설정
# Ollama 설치 (macOS/Linux)
curl -fsSL https://ollama.ai/install.sh | sh
# 모델 다운로드
ollama pull llama2
ollama pull mistral
ollama pull codellama
# 서비스 시작
ollama serve
Maestro와 Ollama 연동
# maestro_backend/config.py
LOCAL_MODEL_CONFIG = {
"base_url": "http://localhost:11434",
"model": "llama2",
"temperature": 0.7,
"max_tokens": 2048,
"context_window": 4096
}
2. 성능 모니터링 및 최적화
시스템 리소스 모니터링
# Docker 컨테이너 리소스 사용량
docker stats
# GPU 사용량 (NVIDIA)
nvidia-smi
# 메모리 사용량 상세
docker exec maestro-backend-1 python -c "
import psutil
print(f'CPU: {psutil.cpu_percent()}%')
print(f'Memory: {psutil.virtual_memory().percent}%')
"
데이터베이스 최적화
-- SQLite 성능 최적화 설정
PRAGMA journal_mode = WAL;
PRAGMA synchronous = NORMAL;
PRAGMA cache_size = 10000;
PRAGMA foreign_keys = ON;
-- 인덱스 생성
CREATE INDEX idx_research_created_at ON research_missions(created_at);
CREATE INDEX idx_agent_logs_mission_id ON agent_logs(mission_id);
3. 고급 에이전트 커스터마이징
에이전트 프롬프트 최적화
# maestro_backend/agents/research_agent.py
RESEARCH_PROMPT_TEMPLATE = """
당신은 전문 연구원입니다. 다음 연구 계획에 따라 정보를 수집하세요:
연구 목표: {research_goal}
현재 단계: {current_phase}
수집해야 할 정보: {target_information}
검색 전략:
1. 핵심 키워드 식별
2. 다양한 정보원 활용
3. 신뢰할 수 있는 출처 우선
4. 최신성과 관련성 고려
수집된 정보는 다음 형식으로 정리하세요:
- 출처: [URL 또는 문서명]
- 신뢰도: [1-10 점수]
- 핵심 내용: [3-5문장 요약]
- 연관성: [연구 목표와의 관련성]
"""
에이전트 간 협업 로직
# maestro_backend/agents/agent_controller.py
class AgentController:
def coordinate_research_cycle(self, mission):
"""에이전트 간 협업 관리"""
plan = self.planning_agent.create_plan(mission)
iteration = 0
max_iterations = 5
while iteration < max_iterations:
# 연구 수행
findings = self.research_agent.execute(plan)
# 품질 검토
feedback = self.reflection_agent.evaluate(
findings, plan, mission.requirements
)
if feedback.quality_score >= 0.8:
break
# 계획 수정
plan = self.planning_agent.refine_plan(
plan, feedback.suggestions
)
iteration += 1
return self.writing_agent.synthesize(findings, plan)
실전 활용 시나리오
1. 학술 연구 지원
논문 리뷰 자동화
# 논문 리뷰 미션 설정
paper_review_mission = {
"title": "자연어 처리 최신 논문 리뷰",
"scope": "2024년 EMNLP, ACL 주요 논문",
"focus_areas": [
"Large Language Models",
"Few-shot Learning",
"Multimodal AI"
],
"output_format": "systematic_review"
}
연구 동향 분석
# 정기적 연구 동향 모니터링 설정
docker exec maestro-backend-1 python scripts/schedule_research.py \
--topic "AI Safety Research" \
--frequency weekly \
--sources "arxiv,scholar,conferences" \
--alert_threshold 10
2. 비즈니스 인텔리전스
시장 조사 자동화
market_research_config = {
"industry": "AI SaaS",
"regions": ["North America", "Europe", "Asia"],
"timeframe": "2024-2025",
"competitors": ["identified_automatically"],
"metrics": [
"market_size",
"growth_rate",
"key_players",
"emerging_trends"
]
}
기술 트렌드 분석
# 기술 트렌드 정기 분석
curl -X POST http://localhost:8000/api/missions \
-H "Content-Type: application/json" \
-d '{
"title": "AI Infrastructure Trends Q1 2025",
"research_questions": [
"What are the emerging AI infrastructure technologies?",
"Which companies are leading in AI hardware?",
"What are the cost optimization trends?"
],
"automated": true,
"schedule": "monthly"
}'
3. 정책 연구 및 분석
규제 분석
regulatory_analysis = {
"scope": "AI Regulation Global Overview",
"jurisdictions": ["EU", "US", "China", "UK"],
"focus": [
"AI Act compliance",
"Data privacy requirements",
"Algorithm transparency",
"Liability frameworks"
],
"update_frequency": "quarterly"
}
문제 해결 및 디버깅
1. 일반적인 문제점들
메모리 부족 문제
# Docker 메모리 한계 증가
echo '{
"default-runtime": "runc",
"runtimes": {
"runc": {
"path": "runc"
}
},
"default-ulimits": {
"memlock": {
"Name": "memlock",
"Hard": -1,
"Soft": -1
}
}
}' | sudo tee /etc/docker/daemon.json
sudo systemctl restart docker
모델 로딩 실패
# 모델 상태 확인 스크립트
def check_model_status():
try:
response = requests.get("http://localhost:11434/api/tags")
models = response.json()
print("사용 가능한 모델들:")
for model in models.get('models', []):
print(f"- {model['name']}")
except Exception as e:
print(f"모델 서버 연결 실패: {e}")
check_model_status()
WebSocket 연결 문제
// 프론트엔드 WebSocket 재연결 로직
class WebSocketManager {
constructor(url) {
this.url = url;
this.reconnectAttempts = 0;
this.maxReconnectAttempts = 5;
this.connect();
}
connect() {
this.ws = new WebSocket(this.url);
this.ws.onopen = () => {
console.log('WebSocket 연결됨');
this.reconnectAttempts = 0;
};
this.ws.onclose = () => {
if (this.reconnectAttempts < this.maxReconnectAttempts) {
setTimeout(() => {
this.reconnectAttempts++;
this.connect();
}, 5000);
}
};
}
}
2. 로그 분석 및 모니터링
구조화된 로깅 설정
# maestro_backend/utils/logging_config.py
import logging
import json
from datetime import datetime
class JSONFormatter(logging.Formatter):
def format(self, record):
log_obj = {
'timestamp': datetime.utcnow().isoformat(),
'level': record.levelname,
'logger': record.name,
'message': record.getMessage(),
'module': record.module,
'function': record.funcName,
'line': record.lineno
}
if hasattr(record, 'mission_id'):
log_obj['mission_id'] = record.mission_id
if hasattr(record, 'agent_type'):
log_obj['agent_type'] = record.agent_type
return json.dumps(log_obj)
실시간 로그 대시보드
# ELK 스택을 이용한 로그 시각화
docker run -d \
--name elasticsearch \
-p 9200:9200 \
-e "discovery.type=single-node" \
docker.elastic.co/elasticsearch/elasticsearch:8.11.0
docker run -d \
--name kibana \
-p 5601:5601 \
--link elasticsearch:elasticsearch \
docker.elastic.co/kibana/kibana:8.11.0
확장 및 커스터마이징
1. 커스텀 에이전트 개발
새로운 에이전트 클래스 생성
# maestro_backend/agents/custom_agent.py
from .base_agent import BaseAgent
class DataAnalysisAgent(BaseAgent):
"""데이터 분석 전문 에이전트"""
def __init__(self, model_config):
super().__init__(model_config)
self.agent_type = "data_analysis"
def analyze_dataset(self, data_path, analysis_type):
"""데이터셋 분석 수행"""
prompt = f"""
데이터 분석 전문가로서 다음 데이터를 분석하세요:
데이터 경로: {data_path}
분석 유형: {analysis_type}
다음 단계를 수행하세요:
1. 데이터 구조 파악
2. 기초 통계 분석
3. 패턴 및 이상치 탐지
4. 시각화 제안
5. 인사이트 도출
"""
return self.execute_task(prompt)
def generate_report(self, analysis_results):
"""분석 결과 보고서 생성"""
# 보고서 생성 로직 구현
pass
2. 플러그인 시스템 구축
플러그인 인터페이스
# maestro_backend/plugins/base_plugin.py
from abc import ABC, abstractmethod
class MaestroPlugin(ABC):
"""Maestro 플러그인 기본 클래스"""
@abstractmethod
def initialize(self, config):
"""플러그인 초기화"""
pass
@abstractmethod
def execute(self, request):
"""플러그인 실행"""
pass
@abstractmethod
def cleanup(self):
"""플러그인 정리"""
pass
# 데이터 소스 플러그인 예시
class DatabasePlugin(MaestroPlugin):
def initialize(self, config):
self.connection = create_connection(config.db_url)
def execute(self, query):
return self.connection.execute(query)
def cleanup(self):
self.connection.close()
3. API 확장
커스텀 엔드포인트 추가
# maestro_backend/api/custom_endpoints.py
from fastapi import APIRouter, Depends
from .auth import get_current_user
router = APIRouter(prefix="/api/v1/custom")
@router.post("/analyze-data")
async def analyze_data(
data_request: DataAnalysisRequest,
user: User = Depends(get_current_user)
):
"""데이터 분석 API"""
agent = DataAnalysisAgent(app.config.model_config)
result = await agent.analyze_dataset(
data_request.data_path,
data_request.analysis_type
)
return {"analysis": result, "status": "completed"}
@router.get("/research-stats")
async def get_research_statistics():
"""연구 통계 API"""
stats = {
"total_missions": Mission.count(),
"active_missions": Mission.count_active(),
"completed_missions": Mission.count_completed(),
"avg_completion_time": Mission.avg_completion_time()
}
return stats
보안 및 프라이버시
1. 인증 및 권한 관리
JWT 기반 인증 강화
# maestro_backend/auth/jwt_manager.py
import jwt
from datetime import datetime, timedelta
from passlib.context import CryptContext
class JWTManager:
def __init__(self, secret_key, algorithm="HS256"):
self.secret_key = secret_key
self.algorithm = algorithm
self.pwd_context = CryptContext(schemes=["bcrypt"])
def create_access_token(self, user_id: str, permissions: list):
payload = {
"user_id": user_id,
"permissions": permissions,
"exp": datetime.utcnow() + timedelta(hours=24),
"iat": datetime.utcnow()
}
return jwt.encode(payload, self.secret_key, self.algorithm)
def verify_token(self, token: str):
try:
payload = jwt.decode(token, self.secret_key, [self.algorithm])
return payload
except jwt.ExpiredSignatureError:
raise HTTPException(401, "Token expired")
except jwt.InvalidTokenError:
raise HTTPException(401, "Invalid token")
역할 기반 접근 제어
# 사용자 역할 정의
class UserRole(Enum):
ADMIN = "admin"
RESEARCHER = "researcher"
VIEWER = "viewer"
# 권한 데코레이터
def require_role(required_role: UserRole):
def decorator(func):
async def wrapper(*args, **kwargs):
user = kwargs.get('current_user')
if user.role != required_role.value:
raise HTTPException(403, "Insufficient permissions")
return await func(*args, **kwargs)
return wrapper
return decorator
2. 데이터 보호
민감 정보 마스킹
# maestro_backend/utils/data_protection.py
import re
from typing import str
class DataMasker:
"""민감 정보 마스킹 클래스"""
@staticmethod
def mask_email(text: str) -> str:
"""이메일 주소 마스킹"""
pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
return re.sub(pattern, '[EMAIL_MASKED]', text)
@staticmethod
def mask_phone(text: str) -> str:
"""전화번호 마스킹"""
pattern = r'\b\d{3}-?\d{3,4}-?\d{4}\b'
return re.sub(pattern, '[PHONE_MASKED]', text)
@staticmethod
def mask_personal_data(text: str) -> str:
"""개인정보 종합 마스킹"""
text = DataMasker.mask_email(text)
text = DataMasker.mask_phone(text)
return text
데이터 암호화
# 데이터베이스 필드 암호화
from cryptography.fernet import Fernet
class EncryptedField:
def __init__(self, key: bytes):
self.cipher = Fernet(key)
def encrypt(self, data: str) -> str:
return self.cipher.encrypt(data.encode()).decode()
def decrypt(self, encrypted_data: str) -> str:
return self.cipher.decrypt(encrypted_data.encode()).decode()
운영 및 유지보수
1. 백업 및 복구
자동 백업 스크립트
#!/bin/bash
# scripts/backup.sh
BACKUP_DIR="/backup/maestro/$(date +%Y%m%d_%H%M%S)"
mkdir -p "$BACKUP_DIR"
# 데이터베이스 백업
docker exec maestro-backend-1 sqlite3 /app/data/maestro.db ".backup /tmp/backup.db"
docker cp maestro-backend-1:/tmp/backup.db "$BACKUP_DIR/database.db"
# 설정 파일 백업
cp .env "$BACKUP_DIR/"
cp docker-compose.yml "$BACKUP_DIR/"
# 업로드된 문서 백업
docker exec maestro-backend-1 tar -czf /tmp/documents.tar.gz /app/data/documents/
docker cp maestro-backend-1:/tmp/documents.tar.gz "$BACKUP_DIR/"
# 백업 완료 알림
echo "백업 완료: $BACKUP_DIR"
복구 스크립트
#!/bin/bash
# scripts/restore.sh
BACKUP_PATH=$1
if [ -z "$BACKUP_PATH" ]; then
echo "사용법: $0 <backup_directory>"
exit 1
fi
# 서비스 중단
docker compose down
# 데이터베이스 복구
docker cp "$BACKUP_PATH/database.db" maestro-backend-1:/app/data/maestro.db
# 문서 복구
docker cp "$BACKUP_PATH/documents.tar.gz" maestro-backend-1:/tmp/
docker exec maestro-backend-1 tar -xzf /tmp/documents.tar.gz -C /app/data/
# 서비스 재시작
docker compose up -d
echo "복구 완료"
2. 모니터링 및 알림
Prometheus 메트릭 수집
# maestro_backend/monitoring/metrics.py
from prometheus_client import Counter, Histogram, Gauge
# 메트릭 정의
research_missions_total = Counter(
'maestro_research_missions_total',
'Total number of research missions',
['status']
)
agent_execution_duration = Histogram(
'maestro_agent_execution_duration_seconds',
'Agent execution duration',
['agent_type']
)
active_missions_gauge = Gauge(
'maestro_active_missions',
'Number of currently active missions'
)
# 메트릭 업데이트 함수
def record_mission_completion(status: str, duration: float):
research_missions_total.labels(status=status).inc()
def record_agent_execution(agent_type: str, duration: float):
agent_execution_duration.labels(agent_type=agent_type).observe(duration)
Grafana 대시보드 설정
# monitoring/grafana-dashboard.json
{
"dashboard": {
"title": "Maestro AI Research Platform",
"panels": [
{
"title": "Research Missions Status",
"type": "stat",
"targets": [
{
"expr": "sum(maestro_research_missions_total) by (status)"
}
]
},
{
"title": "Agent Performance",
"type": "graph",
"targets": [
{
"expr": "histogram_quantile(0.95, maestro_agent_execution_duration_seconds_bucket)"
}
]
}
]
}
}
결론
Maestro는 AI 기반 연구 자동화의 새로운 패러다임을 제시하는 강력한 플랫폼입니다. 멀티 에이전트 시스템을 통해 복잡한 연구 작업을 체계적으로 자동화하고, 완전한 자체 호스팅을 통해 데이터 프라이버시를 보장합니다.
핵심 장점 요약
- 지능적 자동화: 5개의 전문 에이전트가 협력하여 인간 수준의 연구 품질 달성
- 완전한 투명성: 모든 추론 과정과 의사결정을 실시간으로 추적 가능
- 확장 가능성: 플러그인 시스템과 API를 통한 무제한 확장
- 프라이버시 보장: 완전 자체 호스팅으로 민감한 연구 데이터 보호
- 비용 효율성: 로컬 모델 지원으로 API 비용 없이 운영 가능
다음 단계
- 고급 기능 탐색: 커스텀 에이전트 개발 및 플러그인 시스템 활용
- 성능 최적화: GPU 클러스터링 및 분산 처리 구현
- 도메인 특화: 특정 연구 분야에 맞는 전문 에이전트 개발
- 협업 기능: 멀티 유저 환경 및 팀 협업 기능 구축
Maestro를 통해 연구의 미래를 경험하고, AI와 함께하는 새로운 지식 창조의 여정을 시작하세요.
추가 리소스
- 공식 문서: Maestro GitHub
- 커뮤니티: GitHub Issues 및 Discussions
- 기술 지원: Docker 설정 및 환경 문제해결 가이드
- 확장 가이드: 커스텀 에이전트 및 플러그인 개발 문서