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 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:

Gerente de Producto — Escribe un Documento de Requisitos del Producto (PRD)
Arquitecto — Diseña la arquitectura del sistema y la pila tecnológica
Gerente de Proyecto — Desglosa las tareas y las asigna
Ingenieros — Escriben código funcional real para cada componente
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

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.

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:

Solo para API: cualquier servidor con ≥4 GB de RAM
Para LLM local: GPU con ≥24 GB de VRAM

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

Paso 2: Descarga la imagen Docker de MetaGPT

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:

# 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:

nano /opt/metagpt/config/config2.yaml

Para OpenAI (GPT-4o):

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):

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):

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

# 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

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

# /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:

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)

# 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:

# 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

# /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"]

# 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:

# 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 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:

# 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 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

# 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:

# 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

# 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:

#!/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

# 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

# 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

# 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

# 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

# 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

# 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"

# 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 — Código fuente, ejemplos, hoja de ruta
Documentación de MetaGPT — Documentación oficial, referencia de configuración, tutoriales
Discord de MetaGPT — Soporte de la comunidad, casos de uso, consejos sobre modelos
Docker Hub: metagpt/metagpt — Etiquetas de imagen disponibles
Ollama en Clore.ai — Ejecuta LLM locales para impulsar MetaGPT gratis
vLLM en Clore.ai — LLM local de alto rendimiento para MetaGPT a gran escala
Guía de comparación de GPU — Elige la GPU de Clore.ai adecuada para tu carga de trabajo
Clasificación de SWE-bench — Comparativa de frameworks de programación multiagente
Documento de MetaGPT — Investigación original: "MetaGPT: Programación meta para un marco colaborativo multiagente"

AnteriorConstructor de agentes de IA Flowise

SiguienteFramework de agentes SuperAGI

Última actualización hace 12 días

¿Te fue útil?