# Empresa de software MetaGPT

## Resumen

[MetaGPT](https://github.com/geekan/MetaGPT) es un marco de IA multiagente que simula una **empresa de software** — completo con agentes de Product Manager, Arquitecto, Ingeniero y QA Engineer — todos colaborando para convertir una idea de una frase en un proyecto de software completamente funcional. Con más de 45K estrellas en GitHub, MetaGPT es uno de los enfoques más innovadores para el desarrollo de software impulsado por IA.

A diferencia de un único agente de codificación, MetaGPT refleja los flujos de trabajo de un equipo real. Cuando le das una tarea como "Construir un juego de Snake en Python", él:

1. **Product Manager** — Escribe un Documento de Requisitos del Producto (PRD)
2. **Arquitecto** — Diseña la arquitectura del sistema y la pila tecnológica
3. **Project Manager** — Desglosa las tareas y las asigna
4. **Ingenieros** — Escriben código funcional real para cada componente
5. **QA Engineer** — Escribe pruebas unitarias y valida la implementación

El resultado es un directorio de proyecto completo con código, documentación y pruebas — generado de forma autónoma.

**Capacidades clave:**

* **Ciclo de vida completo del software** — Desde los requisitos hasta el código funcional en un solo comando
* **Agentes basados en roles** — Agentes especializados con responsabilidades distintas
* **Generación de documentos** — Produce automáticamente PRDs, diseños del sistema, especificaciones de API
* **Soporte multilingüe** — Python, Node.js, Go y más
* **Intérprete de datos** — Agente autónomo de análisis y visualización de datos
* **Desarrollo incremental** — Añade características a proyectos existentes
* **Modo de interacción humana** — Pausa para revisión humana en etapas clave

**¿Por qué Clore.ai para MetaGPT?**

MetaGPT en sí está basado en CPU, pero Clore.ai ofrece ventajas críticas:

* **Tareas de larga duración** — La generación con MetaGPT puede tomar 10–60 minutos; servidores dedicados lo manejan sin timeouts
* **Backend local de LLM** — Usa Ollama o vLLM para eliminar costos por token en proyectos grandes
* **Control de costos** — A $0.20–0.35/h, ejecuta sesiones extensas de MetaGPT más baratas que llamadas a la API de GPT-4o
* **Entorno aislado** — El código generado se ejecuta en un entorno de servidor controlado
* **Colaboración en equipo** — Comparte un endpoint de servidor MetaGPT entre un equipo de desarrollo

***

## Requisitos

MetaGPT orquesta llamadas a APIs de LLM — la GPU solo es necesaria si ejecutas un backend LLM local.

| Configuración                         | GPU       | VRAM  | RAM   | Almacenamiento | Precio estimado |
| ------------------------------------- | --------- | ----- | ----- | -------------- | --------------- |
| **MetaGPT + API de OpenAI/Anthropic** | Ninguna   | —     | 4 GB  | 20 GB          | \~$0.03–0.08/h  |
| **+ Ollama (Qwen2.5-Coder 7B)**       | RTX 3090  | 24 GB | 16 GB | 40 GB          | \~$0.20/h       |
| **+ Ollama (DeepSeek Coder 33B)**     | RTX 4090  | 24 GB | 32 GB | 60 GB          | \~$0.35/h       |
| **+ vLLM (Qwen2.5-Coder 32B)**        | RTX 4090  | 24 GB | 32 GB | 80 GB          | \~$0.35/h       |
| **+ vLLM (Llama 3.1 70B)**            | A100 80GB | 80 GB | 64 GB | 100 GB         | \~$1.10/h       |

> **Recomendación:** MetaGPT depende en gran medida de la calidad del modelo para un razonamiento coherente en múltiples pasos. Para proyectos complejos, usa las APIs GPT-4o o Claude Sonnet 3.5, o localmente Qwen2.5-Coder-32B / DeepSeek-Coder-V2. Consulta el [Guía de comparación de GPU](https://docs.clore.ai/guides/guides_v2-es/primeros-pasos/gpu-comparison).

**Requisitos de software en el servidor Clore.ai:**

* Docker Engine (preinstalado en todas las imágenes de Clore.ai)
* NVIDIA Container Toolkit (solo para la opción LLM local)
* 20+ GB de espacio libre en disco (imagen de MetaGPT + archivos de proyecto generados)
* Acceso a internet saliente (para descargar imágenes Docker y alcanzar APIs de LLM)

***

## Inicio rápido

### Paso 1: Conéctate a tu servidor Clore.ai

Reserva un servidor en [mercado de Clore.ai](https://clore.ai):

* Para solo API: Cualquier servidor con ≥4 GB de RAM
* Para LLM local: GPU con ≥24 GB de VRAM

```bash
ssh root@<ip-del-servidor> -p <puerto-ssh>
```

### Paso 2: Descargar la imagen Docker de MetaGPT

```bash
docker pull metagpt/metagpt:latest
```

> La imagen de MetaGPT tiene \~3 GB. Esto puede tardar 2–5 minutos en la primera descarga.

### Paso 3: Configurar

MetaGPT requiere un archivo de configuración YAML con tus credenciales de API de LLM:

```bash
# Crear directorios
mkdir -p /opt/metagpt/{config,workspace}

# Extrae la plantilla de configuración por defecto desde la imagen
docker run --rm metagpt/metagpt:latest \
  cat /app/metagpt/config/config2.yaml \
  > /opt/metagpt/config/config2.yaml

# Ver la configuración
cat /opt/metagpt/config/config2.yaml
```

### Paso 4: Configura tu proveedor de LLM

Edita el archivo de configuración:

```bash
nano /opt/metagpt/config/config2.yaml
```

**Para OpenAI (GPT-4o):**

```yaml
llm:
  api_type: "openai"
  model: "gpt-4o"
  base_url: "https://api.openai.com/v1"
  api_key: "sk-your-openai-key-here"

repair_llm_output: true
max_auto_summarize_code: 1
```

**Para Anthropic (Claude):**

```yaml
llm:
  api_type: "anthropic"
  model: "claude-3-5-sonnet-20241022"
  api_key: "sk-ant-your-key-here"

repair_llm_output: true
```

**Para Ollama local (ver sección de GPU):**

```yaml
llm:
  api_type: "ollama"
  model: "ollama/qwen2.5-coder:32b"
  base_url: "http://host.docker.internal:11434"
  api_key: "ollama"

repair_llm_output: true
```

### Paso 5: Ejecuta tu primer proyecto MetaGPT

```bash
# Generar un juego de Snake (demo clásico)
docker run --rm --privileged \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \
  -v /opt/metagpt/workspace:/app/metagpt/workspace \
  metagpt/metagpt:latest \
  metagpt "Create a snake game with Python"
```

Observa a los agentes trabajar: verás la generación del PRD, diseño del sistema, escritura de código y pruebas en secuencia. Espera 5–15 minutos dependiendo de tu LLM.

### Paso 6: Ver la salida

```bash
ls -la /opt/metagpt/workspace/
# Verás un directorio con el nombre de tu proyecto

find /opt/metagpt/workspace -type f | head -30
# Lista todos los archivos generados: .py, .md, requirements.txt, tests/
```

***

## Configuración

### Referencia completa de configuración

```yaml
# /opt/metagpt/config/config2.yaml

# Configuración principal de LLM
llm:
  api_type: "openai"          # openai | anthropic | ollama | azure | gemini
  model: "gpt-4o"
  base_url: "https://api.openai.com/v1"
  api_key: "your-api-key"
  temperature: 0.0            # Más bajo = generación de código más determinista
  max_token: 4096

# Ajustes de comportamiento de MetaGPT
repair_llm_output: true       # Autoarregla respuestas malformadas del LLM
max_auto_summarize_code: 1    # Iteraciones de resumen de código (0 = deshabilitado)
max_project_auto_run: 5       # Máximo de ciclos de autoejecución

# Ajustes del proyecto
project_name: ""              # Opcional: sobrescribir el nombre de proyecto generado
inc: false                    # Modo incremental (añadir a proyecto existente)
reqa_file: ""                 # Ejecutar QA en un archivo específico

# Seguimiento de costos
max_budget: 10.0              # Máximo $ a gastar (solo llamadas API)
```

### Ejecución en Modo Interactivo

Para mayor control, ejecuta MetaGPT con puntos de control para revisión humana:

```bash
docker run --rm -it --privileged \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \
  -v /opt/metagpt/workspace:/app/metagpt/workspace \
  metagpt/metagpt:latest \
  metagpt "Build a REST API for a todo list app with FastAPI" \
  --human-review
```

Con `--human-review`, MetaGPT pausa después de las etapas de PRD y diseño del sistema, permitiéndote proporcionar retroalimentación antes de que comience la ingeniería.

### Desarrollo incremental (Añadir a un proyecto existente)

```bash
# Continuar el desarrollo en un proyecto existente
docker run --rm -it --privileged \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \
  -v /opt/metagpt/workspace:/app/metagpt/workspace \
  -v /opt/metagpt/workspace/my-project:/app/metagpt/workspace/my-project \
  metagpt/metagpt:latest \
  metagpt "Add user authentication to the existing todo API" \
  --project-path /app/metagpt/workspace/my-project \
  --inc
```

### Ejecución del Intérprete de Datos

MetaGPT incluye un agente especializado Intérprete de Datos para análisis de datos:

```bash
# Análisis de datos interactivo en Python
docker run --rm -it --privileged \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \
  -v /opt/metagpt/workspace:/app/metagpt/workspace \
  -v /path/to/your/data:/data:ro \
  metagpt/metagpt:latest \
  python -m metagpt.roles.di.data_interpreter \
    "Analyze /data/sales.csv and find top-performing products, create visualization"
```

### Docker Compose para configuración persistente

```yaml
# /opt/metagpt/docker-compose.yml
version: "3.9"

services:
  metagpt:
    image: metagpt/metagpt:latest
    privileged: true
    volumes:
      - /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml:ro
      - /opt/metagpt/workspace:/app/metagpt/workspace
      - /opt/metagpt/logs:/app/metagpt/logs
    environment:
      - PYTHONUNBUFFERED=1
    stdin_open: true
    tty: true
    # Nota: MetaGPT es por tareas, no un servicio persistente.
    # Usa 'docker compose run metagpt metagpt "your task"' para ejecutar
    entrypoint: ["bash"]
```

```bash
# Ejecutar una tarea vía docker-compose
docker compose -f /opt/metagpt/docker-compose.yml \
  run --rm metagpt \
  metagpt "Create a Flask web app with user registration"
```

***

## Aceleración por GPU (Integración LLM local)

### MetaGPT + Ollama

Ejecuta MetaGPT completamente gratis (sin costos de API) usando un modelo de codificación local:

```bash
# Paso 1: Iniciar Ollama con GPU
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \
  ollama/ollama:latest

# Paso 2: Descargar un modelo de codificación de alta calidad
# Para RTX 3090/4090 (24 GB VRAM):
docker exec ollama ollama pull qwen2.5-coder:32b      # Mejor para código
docker exec ollama ollama pull deepseek-coder-v2:16b  # Alternativa
# Para GPUs más pequeñas (8–16 GB VRAM):
docker exec ollama ollama pull qwen2.5-coder:7b
docker exec ollama ollama pull codellama:13b

# Paso 3: Configurar MetaGPT para Ollama
cat > /opt/metagpt/config/config2.yaml << 'EOF'
llm:
  api_type: "ollama"
  model: "ollama/qwen2.5-coder:32b"
  base_url: "http://host.docker.internal:11434"
  api_key: "ollama"
  temperature: 0.0
  max_token: 4096

repair_llm_output: true
max_auto_summarize_code: 0
EOF

# Paso 4: Ejecutar MetaGPT con la red del host para acceso a Ollama
docker run --rm --privileged \
  --add-host host.docker.internal:host-gateway \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \
  -v /opt/metagpt/workspace:/app/metagpt/workspace \
  metagpt/metagpt:latest \
  metagpt "Create a Python CLI tool for file organization"
```

> Consulta el completo [guía de Ollama](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ollama) para la configuración del modelo y la optimización de GPU.

### MetaGPT + vLLM (Alto rendimiento)

Para máximo rendimiento de tokens en proyectos grandes y complejos:

```bash
# Paso 1: Iniciar vLLM con un modelo de codificación
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

# Espera a que cargue el modelo
until curl -s http://localhost:8000/health | grep -q ok; do
  echo "Waiting for vLLM..."; sleep 10
done

# Paso 2: Configurar MetaGPT para vLLM
cat > /opt/metagpt/config/config2.yaml << 'EOF'
llm:
  api_type: "openai"
  model: "Qwen/Qwen2.5-Coder-32B-Instruct"
  base_url: "http://host.docker.internal:8000/v1"
  api_key: "none"
  temperature: 0.0
  max_token: 8192

repair_llm_output: true
EOF

# Paso 3: Ejecutar MetaGPT
docker run --rm --privileged \
  --add-host host.docker.internal:host-gateway \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \
  -v /opt/metagpt/workspace:/app/metagpt/workspace \
  metagpt/metagpt:latest \
  metagpt "Build a complete e-commerce backend with FastAPI and PostgreSQL"
```

> Ver el [guía de vLLM](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/vllm) para opciones de cuantización y configuraciones multi-GPU.

### Modelos recomendados según la tarea

| Tipo de tarea           | Modelo                         | VRAM mínima | Notas                                 |
| ----------------------- | ------------------------------ | ----------- | ------------------------------------- |
| Scripts simples         | `qwen2.5-coder:7b`             | 8 GB        | Rápidos, buenos para herramientas CLI |
| Proyectos medianos      | `qwen2.5-coder:14b`            | 12 GB       | Buen equilibrio                       |
| Sistemas complejos      | `qwen2.5-coder:32b`            | 24 GB       | Mejor opción local                    |
| Bases de código grandes | `gpt-4o` / `claude-3-5-sonnet` | API         | Más fiable para PRDs complejos        |

> **Consejo:** Los modelos locales funcionan bien para la generación de código pero a veces tienen dificultades con el razonamiento arquitectónico complejo. Para PRDs y diseños de sistema con calidad de producción, considera usar GPT-4o o Claude para la fase de planificación y un modelo local para la generación de código.

***

## Consejos y mejores prácticas

### 1. Escribe prompts de tarea efectivos

El rendimiento de MetaGPT depende en gran medida de la calidad de tu prompt inicial:

```
✅ Buenos prompts:
"Create a Python REST API using FastAPI that manages a library catalog.
Características: añadir/buscar/eliminar libros, autenticación de usuarios con JWT, 
Base de datos SQLite, documentación OpenAPI. Objetivo: listo para producción con pruebas."

"Build a CLI data pipeline tool in Python that reads CSV files,
realiza análisis estadístico y genera gráficos usando matplotlib."

❌ Prompts vagos:
"Haz una aplicación web"
"Construye algo con Python"
```

### 2. Estima los costos de API antes de ejecutar

```bash
# MetaGPT procesa muchos tokens por proyecto:
# - Script simple: ~50K tokens (~$0.25 con GPT-4o)
# - Webapp mediana: ~200K tokens (~$1.00 con GPT-4o)
# - Sistema complejo: ~500K+ tokens (~$2.50+ con GPT-4o)

# Establece un límite de presupuesto en la configuración:
# max_budget: 2.0  # Detener después de gastar $2
```

### 3. Revisa el PRD generado primero

Usa `--human-review` para proyectos importantes. La etapa de PRD es donde se fijan los requisitos — detectar problemas aquí ahorra un coste de tokens significativo en comparación con revisarlos después de la generación de código.

### 4. Prueba el código generado

MetaGPT genera pruebas unitarias, pero siempre verifica:

```bash
# Navega al proyecto generado
cd /opt/metagpt/workspace/<your-project>

# Instalar dependencias
pip install -r requirements.txt

# Ejecuta las pruebas generadas
pytest tests/ -v

# Intenta ejecutar la aplicación principal
python main.py
```

### 5. Usa control de versiones

```bash
# Inicializa git en el workspace
cd /opt/metagpt/workspace
git init
git add .
git commit -m "Initial MetaGPT generation"

# Después de cada iteración
git add .
git commit -m "MetaGPT: Added authentication feature"
```

### 6. Ejecuta múltiples proyectos por lotes

Ejecuta varios proyectos durante la noche en Clore.ai para obtener el máximo valor:

```bash
#!/bin/bash
# /opt/metagpt/batch-run.sh
PROJECTS=(
  "Create a URL shortener service with Python and Redis"
  "Build a Markdown to PDF converter CLI tool"
  "Create a REST API for a blog with comments and tags"
)

for project in "${PROJECTS[@]}"; do
  echo "Starting: $project"
  docker run --rm --privileged \
    -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \
    -v /opt/metagpt/workspace:/app/metagpt/workspace \
    metagpt/metagpt:latest \
    metagpt "$project"
  echo "Completed: $project"
done
```

***

## Solución de problemas

### Fallo al descargar la imagen

```bash
# Si se alcanza el límite de tasa de Docker Hub
docker login  # Inicia sesión con tu cuenta de Docker Hub
docker pull metagpt/metagpt:latest

# Comprueba el espacio en disco disponible
df -h
# La imagen de MetaGPT tiene ~3 GB; el workspace puede crecer a varios GB
```

### Archivo de configuración no encontrado

```bash
# Verifica que el mapeo de rutas sea correcto
docker run --rm \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \
  metagpt/metagpt:latest \
  ls -la /app/metagpt/config/

# También verifica que tu YAML sea válido
python3 -c "import yaml; yaml.safe_load(open('/opt/metagpt/config/config2.yaml'))"
```

### Error de autenticación de la API LLM

```bash
# Prueba tu clave de API de forma independiente
curl https://api.openai.com/v1/models \
  -H "Authorization: Bearer sk-your-key"

# Para Anthropic:
curl https://api.anthropic.com/v1/models \
  -H "x-api-key: sk-ant-your-key" \
  -H "anthropic-version: 2023-06-01"

# Problemas comunes:
# - Clave copiada con espacios en blanco extra
# - Clave caducada o cuota excedida
# - api_type incorrecto en la configuración (por ejemplo, "openai" vs "anthropic")
```

### Conexión a Ollama rechazada desde el contenedor

```bash
# Verifica que Ollama esté en funcionamiento
docker ps | grep ollama
curl http://localhost:11434/api/tags

# Prueba desde la perspectiva del contenedor MetaGPT
docker run --rm \
  --add-host host.docker.internal:host-gateway \
  metagpt/metagpt:latest \
  curl http://host.docker.internal:11434/api/tags

# Si sigue fallando, comprueba los logs de Ollama
docker logs ollama --tail 20
```

### La generación se queda colgada o expira

```bash
# Comprueba si el LLM realmente está respondiendo
# Añade logging de depuración para ver qué agente está atascado
docker run --rm --privileged \
  -e PYTHONUNBUFFERED=1 \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \
  -v /opt/metagpt/workspace:/app/metagpt/workspace \
  metagpt/metagpt:latest \
  metagpt "Simple task" 2>&1 | tee /opt/metagpt/logs/debug.log

# Causas comunes:
# - Modelo local demasiado lento (prueba un modelo cuantizado más pequeño)
# - Limitación de tasa de la API (añade retrasos o cambia de nivel)
# - Ventana de contexto del modelo excedida (reduce max_auto_summarize_code)
```

### Sin espacio en disco

```bash
# Los proyectos generados pueden ser grandes; limpia los antiguos
du -sh /opt/metagpt/workspace/*
rm -rf /opt/metagpt/workspace/old-project/

# También limpia la caché de build de Docker
docker system prune -f

# Comprueba el uso total
df -h /opt/metagpt/
```

### Bucles de "Repair LLM Output"

```bash
# Si MetaGPT sigue reintentando debido a salidas malformadas del LLM:
# 1. Prueba un modelo más capaz (GPT-4o, Claude Sonnet)
# 2. Reduce la temperatura (ponla a 0.0 para determinismo)
# 3. Desactiva repair (si usas un modelo capaz):
#    repair_llm_output: false
```

***

## Lecturas adicionales

* [Repositorio de MetaGPT en GitHub](https://github.com/geekan/MetaGPT) — Código fuente, ejemplos, hoja de ruta
* [Documentación de MetaGPT](https://docs.deepwisdom.ai/main/en/) — Documentación oficial, referencia de configuración, tutoriales
* [Discord de MetaGPT](https://discord.gg/DYn29wFk9z) — Soporte comunitario, casos de uso, consejos sobre modelos
* [Docker Hub: metagpt/metagpt](https://hub.docker.com/r/metagpt/metagpt) — Etiquetas de imagen disponibles
* [Ollama en Clore.ai](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ollama) — Ejecuta LLMs locales para impulsar MetaGPT de forma gratuita
* [vLLM en Clore.ai](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/vllm) — LLM local de alto rendimiento para MetaGPT a escala
* [Guía de comparación de GPU](https://docs.clore.ai/guides/guides_v2-es/primeros-pasos/gpu-comparison) — Elige la GPU Clore.ai adecuada para tu carga de trabajo
* [Leaderboard de SWE-bench](https://www.swebench.com) — Comparar frameworks multiagente de codificación
* [Artículo de MetaGPT](https://arxiv.org/abs/2308.00352) — Investigación original: "MetaGPT: Meta Programming for a Multi-Agent Collaborative Framework"


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/metagpt.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.