> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/metagpt.md).

# Compañía de software MetaGPT

Despliega MetaGPT en Clore.ai: ejecuta una compañía de software de IA multiagente totalmente autónoma en servidores de nube GPU asequibles para generar bases de código completas, PRDs, diseños de arquitectura y pruebas QA a partir de una sola

## Descripción general

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

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

1. **Gerente de Producto** — Escribe un Documento de Requisitos del Producto (PRD)
2. **Arquitecto** — Diseña la arquitectura del sistema y la pila tecnológica
3. **Gerente de Proyecto** — Desglosa las tareas y las asigna
4. **Ingenieros** — Escriben código funcional real para cada componente
5. **Ingeniero de QA** — 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** — De los requisitos al código funcional en un solo comando
* **Agentes basados en roles** — Agentes especializados con responsabilidades distintas
* **Generación de documentos** — Produce automáticamente PRD, diseños de sistema y especificaciones de API
* **Compatibilidad 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 funciones 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í se basa en CPU, pero Clore.ai ofrece ventajas críticas:

* **Tareas de larga duración** — La generación de MetaGPT puede tardar entre 10 y 60 minutos; los servidores dedicados gestionan esto sin tiempos de espera
* **Backend local de LLM** — Usa Ollama o vLLM para eliminar los costes de API por token en proyectos grandes
* **Control de costes** — Con $0.20–0.35/h, ejecuta sesiones extensas de MetaGPT más baratas que las 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 la API de LLM — la GPU solo se necesita si ejecutas un backend local de LLM.

| Configuración                         | GPU       | VRAM  | RAM   | Almacenamiento | Precio est.                               |
| ------------------------------------- | --------- | ----- | ----- | -------------- | ----------------------------------------- |
| **MetaGPT + API de OpenAI/Anthropic** | Ninguno   | —     | 4 GB  | 20 GB          | \~$0.03–0.08/h                            |
| **+ Ollama (Qwen2.5-Coder 7B)**       | RTX 3090  | 24 GB | 16 GB | 40 GB          | $0.07–0.21/h                              |
| **+ Ollama (DeepSeek Coder 33B)**     | RTX 4090  | 24 GB | 32 GB | 60 GB          | $0.14–0.42/h                              |
| **+ vLLM (Qwen2.5-Coder 32B)**        | RTX 4090  | 24 GB | 32 GB | 80 GB          | $0.14–0.42/h                              |
| **+ vLLM (Llama 3.1 70B)**            | A100 80GB | 80 GB | 64 GB | 100 GB         | [bare metal](https://clore.ai/bare-metal) |

> **Recomendación:** MetaGPT depende en gran medida de la calidad del modelo para un razonamiento coherente de múltiples pasos. Para proyectos complejos, usa las APIs de 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](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md).

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

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

***

## Inicio rápido

### Paso 1: Conecta a tu servidor de Clore.ai

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

* Solo para 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: Descarga la imagen Docker de MetaGPT

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

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

### Paso 3: Configura la configuración

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

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

# Extrae la plantilla de configuración predeterminada de 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 (consulta la 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
# Genera un juego de Snake (demo clásica)
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 "Crea un juego de Snake con Python"
```

Mira cómo trabajan los agentes: verás generación del PRD, diseño del sistema, escritura de código y pruebas en secuencia. Espera entre 5 y 15 minutos, según 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 del 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       # Corrige automáticamente respuestas mal formadas 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 ejecución automática

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

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

### Ejecutando en modo interactivo

Para tener más control, ejecuta MetaGPT con puntos de control de 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 "Construye una API REST para una aplicación de lista de tareas con FastAPI" \
  --human-review
```

Con `--human-review`, MetaGPT se pausa después de las etapas del PRD y del diseño del sistema, lo que te permite proporcionar comentarios antes de que comience la ingeniería.

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

```bash
# Continúa 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 "Añade autenticación de usuario a la API de tareas pendiente existente" \
  --project-path /app/metagpt/workspace/my-project \
  --inc
```

### Ejecutando el intérprete de datos

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

```bash
# Análisis interactivo de datos 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 \
    "Analiza /data/sales.csv y encuentra los productos con mejor rendimiento, crea una visualización"
```

### Docker Compose para una 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 funciona por tareas, no como un servicio persistente.
    # Usa 'docker compose run metagpt metagpt "tu tarea"' para ejecutar
    entrypoint: ["bash"]
```

```bash
# Ejecutar una tarea mediante docker-compose
docker compose -f /opt/metagpt/docker-compose.yml \
  run --rm metagpt \
  metagpt "Crea una aplicación web Flask con registro de usuarios"
```

***

## Aceleración por GPU (integración local de LLM)

### MetaGPT + Ollama

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

```bash
# Paso 1: Inicia 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: Descarga un modelo de programación de alta calidad
# Para RTX 3090/4090 (24 GB de 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 GPU más pequeñas (8–16 GB de VRAM):
docker exec ollama ollama pull qwen2.5-coder:7b
docker exec ollama ollama pull codellama:13b

# Paso 3: Configura 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: Ejecuta MetaGPT con red del host para acceder 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 "Crea una herramienta CLI de Python para organizar archivos"
```

> Consulta la guía completa [de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) para la configuración del modelo y la optimización de la GPU.

### MetaGPT + vLLM (alto rendimiento)

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

```bash
# Paso 1: Inicia vLLM con un modelo de programació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 se cargue el modelo
until curl -s http://localhost:8000/health | grep -q ok; do
  echo "Esperando a vLLM..."; sleep 10
done

# Paso 2: Configura 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: Ejecuta 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 "Construye un backend de comercio electrónico completo con FastAPI y PostgreSQL"
```

> Consulta la [guía de vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) para opciones de cuantización y configuraciones de múltiples GPU.

### Modelos recomendados por tarea

| Tipo de tarea           | Modelo                         | VRAM mínima | Notas                               |
| ----------------------- | ------------------------------ | ----------- | ----------------------------------- |
| Scripts simples         | `qwen2.5-coder:7b`             | 8 GB        | Rápido, bueno 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 PRD 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 PRD y diseños de sistema de 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 tareas eficaces

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

```
✅ Prompts buenos:
"Crea una API REST de Python usando FastAPI que gestione un catálogo de biblioteca.
Características: agregar/buscar/eliminar libros, autenticación de usuario con JWT, 
base de datos SQLite, documentación OpenAPI. Objetivo: lista para producción con pruebas."

"Construye una herramienta CLI de canalización de datos en Python que lea archivos CSV,
realice análisis estadístico y genere gráficos usando matplotlib."

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

### 2. Estima los costes de la API antes de ejecutar

```bash
# MetaGPT procesa muchos tokens por proyecto:
# - Script simple: ~50K tokens (~$0.25 con GPT-4o)
# - Aplicación web 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 primero el PRD generado

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

### 4. Prueba el código generado

MetaGPT genera pruebas unitarias, pero verifica siempre:

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

# Instalar dependencias
pip install -r requirements.txt

# Ejecutar 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 espacio de trabajo
cd /opt/metagpt/workspace
git init
git add .
git commit -m "Generación inicial de MetaGPT"

# Después de cada iteración
git add .
git commit -m "MetaGPT: Añadida función de autenticación"
```

### 6. Procesa varios 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=(
  "Crea un servicio acortador de URL con Python y Redis"
  "Construye una herramienta CLI de conversión de Markdown a PDF"
  "Crea una API REST para un blog con comentarios y etiquetas"
)

for project in "${PROJECTS[@]}"; do
  echo "Iniciando: $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 "Completado: $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 libre disponible en disco
df -h
# La imagen de MetaGPT pesa ~3 GB; el espacio de trabajo puede crecer hasta 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 del 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 espacio en blanco adicional
# - 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 se esté ejecutando
docker ps | grep ollama
curl http://localhost:11434/api/tags

# Prueba desde la perspectiva del contenedor de 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, revisa los registros de Ollama
docker logs ollama --tail 20
```

### La generación se atasca o se agota el tiempo de espera

```bash
# Comprueba si el LLM está respondiendo realmente
# Añade registros de depuración para ver qué agente está bloqueado
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 "Tarea simple" 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 plan)
# - Se excedió la ventana de contexto del modelo (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/

# Limpia también la caché de compilación de Docker
docker system prune -f

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

### Bucles de "Reparar la salida del LLM"

```bash
# Si MetaGPT sigue reintentando debido a una salida LLM mal formada:
# 1. Prueba un modelo más capaz (GPT-4o, Claude Sonnet)
# 2. Reduce la temperatura (configúrala en 0.0 para determinismo)
# 3. Desactiva la reparación (si estás usando un modelo capaz):
#    repair_llm_output: false
```

***

## Lecturas adicionales

* [Repositorio de GitHub de MetaGPT](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 de la comunidad, 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](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — Ejecuta LLM locales para impulsar MetaGPT gratis
* [vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — LLM local de alto rendimiento para MetaGPT a gran escala
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — Elige la GPU de Clore.ai adecuada para tu carga de trabajo
* [Clasificación de SWE-bench](https://www.swebench.com) — Comparativa de frameworks de programación multiagente
* [Documento de MetaGPT](https://arxiv.org/abs/2308.00352) — Investigación original: "MetaGPT: Programación meta para un marco colaborativo multiagente"


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.