@rotifer/mcp-server

Marco de agente de IA auto-evolutivo: busca, compara e instala Genes clasificados por aptitud Arena a través de MCP

Documentación

@rotifer/mcp-server

Construye, compone y ejecuta agentes de IA — directamente desde tu IDE.

Busca genes, crea agentes con genomas componibles, ejecuta pipelines en un sandbox WASM y compite en la Arena. Cero configuración. Funciona con Cursor, Claude Desktop, Windsurf y cualquier cliente compatible con MCP.

Inicio Rápido

Cursor

Añade a .cursor/mcp.json:

{
  "mcpServers": {
    "rotifer": {
      "command": "npx",
      "args": ["@rotifer/mcp-server"]
    }
  }
}

Claude Desktop

Añade a claude_desktop_config.json:

{
  "mcpServers": {
    "rotifer": {
      "command": "npx",
      "args": ["@rotifer/mcp-server"]
    }
  }
}

Windsurf / Otros Clientes MCP

Usa el mismo comando npx — cualquier cliente que soporte el transporte stdio de MCP funcionará.

¿Qué Puede Hacer?

Crear y ejecutar un agente en una sola conversación

You: "Build me an agent for code security scanning"
AI:  → create_agent({ agent_name: "sec-bot", gene_ids: ["security-scanner", "genesis-code-format"],
                       composition: "Seq" })
     Agent 'sec-bot' created with 2-gene Seq genome.

You: "Run it on my project"
AI:  → agent_run({ agent_name: "sec-bot", input: "{\"path\":\"./src\"}" })
     Pipeline complete — 3 findings, 0 critical.

Buscar, comparar y componer genes

You: "Find the best gene for web search"
AI:  → search_genes({ query: "web search" })
     Found 8 genes. Top match: genesis-web-search (F(g) = 0.87, Native)

You: "Compare it against the lite version"
AI:  → compare_genes({ gene_ids: ["...", "..."] })
     Side-by-side: success rate, latency, fitness breakdown

Ciclo de vida completo del gen desde tu IDE

You: "Wrap my function as a gene"
AI:  → wrap_gene({ gene_name: "my-search", domain: "search.web", fidelity: "Wrapped" })
     → compile_gene({ gene_name: "my-search" })
     → test_gene({ gene_name: "my-search", compliance: true })
     → publish_gene({ gene_name: "my-search", changelog: "Initial release" })

Herramientas (31)

Descubrimiento y Analítica

Herramienta	Descripción	Parámetros Clave
`search_genes`	Busca en el ecosistema Gene por nombre, dominio o descripción	`query`, `domain`, `fidelity`, `sort` (`relevance`/`newest`/`popular`/`fitness`), `page`, `per_page`
`get_gene_detail`	Obtén información detallada sobre un Gene (fenotipo, fitness, metadatos)	`gene_id`, `content_hash` (cualquiera identifica el gen)
`get_arena_rankings`	Clasificaciones de la Arena para un dominio, ordenadas por fitness F(g)	`domain`, `page`, `per_page`
`compare_genes`	Comparación de fitness lado a lado de 2–5 Genes	`gene_ids` (array)
`get_gene_stats`	Estadísticas de descargas (total, 7d, 30d, 90d)	`gene_id`
`get_leaderboard`	Tabla de líderes de reputación de creadores	`limit`
`get_developer_profile`	Perfil público y reputación del creador	`username`
`get_gene_reputation`	Desglose detallado de reputación (Arena, Uso, Estabilidad)	`gene_id`
`list_gene_versions`	Cadena de historial de versiones con registros de cambios	`owner`, `gene_name`
`suggest_domain`	Sugiere dominios coincidentes del registro	`description`

Espacio de Trabajo Local

Herramienta	Descripción	Parámetros Clave
`list_local_genes`	Escanea el espacio de trabajo local en busca de Genes instalados	`project_root`, `domain`, `fidelity`
`list_local_agents`	Lista los Agentes en el espacio de trabajo local	`project_root`, `state`

Ciclo de Vida del Gene

Herramienta	Descripción	Parámetros Clave
`init_gene`	Inicializa un nuevo proyecto Gene con archivos de inicio	`gene_name`, `fidelity`, `domain`, `no_genesis`
`scan_genes`	Escanea en busca de funciones candidatas o archivos SKILL.md	`path`, `skills`, `skills_path`
`wrap_gene`	Envuelve una función/habilidad como un Gene	`gene_name`, `domain`, `fidelity`, `from_skill`, `from_clawhub`
`test_gene`	Prueba un Gene (validación de esquema + sandbox)	`gene_name`, `verbose`, `compliance`
`compile_gene`	Compila un Gene a IR WASM	`gene_name`, `check`, `wasm_path`, `lang`
`doctor`	Verifica la cadena de herramientas local TypeScript→WASM (esbuild / javy) e informa qué falta — solo lectura; úsalo cuando `compile_gene` falle	`project_root`
`run_gene`	Ejecuta un Gene local	`gene_name`, `input`, `verbose`, `no_sandbox`, `trust_unsigned`
`publish_gene`	Publica en Rotifer Cloud	`gene_name`, `all`, `description`, `changelog`, `skip_arena`, `skip_security`
`install_gene`	Instala un Gene desde el Registro Cloud. `force` guarda una instantánea de la copia que reemplaza	`gene_id`, `project_root`, `force`
`rollback_gene`	Deshace la última sobrescritura de un Gene local; llámalo sin nombre para listar lo que se puede deshacer	`gene_name`, `project_root`
`vg_scan`	Escaneo de seguridad V(g) — análisis estático para la seguridad del código Gene/Skill	`path`, `gene_id`, `all`, `project_root`
`arena_submit`	Mide un Gene local en el sandbox y envía la medición a la Arena. Las puntuaciones se producen ejecutando el Gene, nunca las proporciona el llamador	`gene_name`, `project_root`

Composición de Agentes

Herramienta	Descripción	Parámetros Clave
`create_agent`	Crea un Agente componiendo múltiples Genes	`agent_name`, `gene_ids`, `composition` (`Seq`/`Par`/`Cond`/`Try`/`TryPool`), `domain`, `top`, `strategy`, `par_merge`
`agent_run`	Ejecuta un Agente local por nombre	`agent_name`, `input`, `verbose`, `no_sandbox`

Autenticación y Analítica

Herramienta	Descripción	Parámetros Clave
`auth_status`	Verifica el estado de inicio de sesión	—
`login`	Inicio de sesión OAuth (GitHub/GitLab)	`provider`, `endpoint`
`logout`	Borra las credenciales	—
`get_mcp_stats`	Analítica de llamadas MCP	`days`
`get_my_reputation`	Reputación del usuario actual	—

Recursos (7)

Los Recursos MCP permiten a los clientes de IA referenciar datos de Rotifer como contexto:

Plantilla URI	Descripción
`rotifer://genes/{gene_id}/stats`	Estadísticas de descargas de Genes
`rotifer://genes/{gene_id}`	Detalle del Gene + fenotipo
`rotifer://developers/{username}`	Perfil del creador + reputación
`rotifer://leaderboard`	Principales creadores por puntuación de reputación
`rotifer://local/genes`	Inventario local de Genes
`rotifer://local/agents`	Registro local de Agentes
`rotifer://version`	Versión del Servidor MCP y disponibilidad de actualizaciones

Cada recurso devuelve lo que devuelve la herramienta del mismo trabajo, por lo que un conjunto declarado cubre ambos: con --tools=evolve, rotifer://genes/{gene_id}/stats, rotifer://developers/{username} y rotifer://leaderboard desaparecen del listado y se rechazan si se leen directamente, porque get_gene_stats, get_developer_profile y get_leaderboard no fueron solicitados. rotifer://version siempre responde — es el servidor describiéndose a sí mismo, no una capacidad. Antes de 0.16.0 estos eran accesibles sin importar lo que dijera el conjunto de herramientas.

Prompts (4)

Los Prompts MCP dan a los clientes de IA flujos de trabajo guiados para tareas comunes:

Prompt	Descripción	Argumentos Clave
`rotifer-hello`	Creación interactiva de agentes — elige una plantilla y ejecuta inmediatamente	`template`, `input`
`rotifer-guide`	Entiende el Protocolo Rotifer — genes, agentes, Arena, modelo de fidelidad	—
`rotifer-architect`	Diseña un Agente — búsqueda de genes impulsada por tareas + planificación de composición	`task`
`rotifer-challenge`	Evaluación en la Arena — envía un gen, compara con competidores	`gene`

Prueba preguntando a tu IA: "Usa el prompt rotifer-hello para construirme un agente" o "Usa rotifer-architect para diseñar un agente para Q&A de documentos".

Arquitectura

┌─────────────────────────────────────────────────┐
│  AI IDE (Cursor / Claude / Windsurf)            │
│                                                 │
│  "Find genes for code formatting"               │
│       │                                         │
│       ▼                                         │
│  ┌─────────────────────┐                        │
│  │  MCP Client         │                        │
│  │  (stdio transport)  │                        │
│  └────────┬────────────┘                        │
└───────────┼─────────────────────────────────────┘
            │ MCP Protocol
            ▼
┌─────────────────────────────────────────────────┐
│  @rotifer/mcp-server                            │
│                                                 │
│  30 Tools  7 Resources  4 Prompts  Local Scanner│
│  ┌──────────┐  ┌───────────┐   ┌────────────┐  │
│  │ discover │  │rotifer:// │   │ ./genes/    │  │
│  │ lifecycle│  │genes/stats│   │ phenotype   │  │
│  │ agents   │  │developers │   │ agents      │  │
│  │ auth     │  │leaderboard│   └────────────┘  │
│  └────┬─────┘  └─────┬─────┘         │         │
└───────┼──────────────┼────────────────┼─────────┘
        │              │                │
        ▼              ▼                ▼
┌─────────────────────────────────────────────────┐
│  Rotifer Cloud API          Local File System   │
│  (Supabase)                 (genes/, .rotifer/) │
└─────────────────────────────────────────────────┘

Configuración

Configuración cero por defecto — se conecta a la API pública de Rotifer Cloud.

Para usar un endpoint personalizado, crea ~/.rotifer/cloud.json:

{
  "endpoint": "https://your-supabase-instance.supabase.co",
  "anonKey": "your-anon-key"
}

O establece variables de entorno:

ROTIFER_CLOUD_ENDPOINT=https://your-instance.supabase.co
ROTIFER_CLOUD_ANON_KEY=your-anon-key

Elegir qué herramientas exponer

Las treinta y una herramientas están disponibles por defecto. ROTIFER_MCP_TOOLS reduce eso a lo que una integración dada realmente necesita — útil cuando el servidor está adjunto a un asistente que no debería poder publicar o iniciar sesión en tu nombre:

npx @rotifer/mcp-server --tools=evolve          # the rank-and-swap preset (10 tools)
npx @rotifer/mcp-server --tools=readonly        # nothing that writes (14 tools)
ROTIFER_MCP_TOOLS=search_genes,get_gene_detail  # an exact list
ROTIFER_MCP_TOOLS=evolve,vg_scan                # a preset plus one

La bandera y la variable hacen lo mismo, y la bandera gana si ambas están establecidas. Ambas existen porque los llamadores difieren en lo que pueden alcanzar: un usuario de shell establece la variable, mientras que algo que lanza este servidor desde un manifiesto controla solo la línea de comandos.

Un conjunto declarado cubre toda la superficie, no solo tools/list. Las herramientas fuera de él se rechazan cuando se llaman por nombre; los recursos que duplican una herramienta excluida se eliminan del listado y se rechazan al leerlos; y las vías de escape del sandbox a continuación permanecen desactivadas a menos que se declaren por separado. Una restricción con una vía no listada para sortearla no es una restricción.

Las herramientas fuera del conjunto desaparecen de listTools y se rechazan si se llaman de todos modos. El rechazo dice cómo añadir la herramienta de nuevo y, donde existe, el comando CLI rotifer que hace el mismo trabajo — así que un conjunto reducido es un límite que puedes ver y cruzar deliberadamente, no un callejón sin salida.

Déjalo sin establecer y nada cambia.

Desactivar el sandbox

agent_run y run_gene toman no_sandbox, y run_gene también toma trust_unsigned — opciones que ejecutan código Gene como Node.js plano en lugar de dentro del sandbox WASM. Reducir el conjunto de herramientas significaría poco si una herramienta dentro del conjunto reducido aún pudiera hacer eso, así que estas se rechazan a menos que se declaren al lanzamiento:

npx @rotifer/mcp-server --allow=no-sandbox
npx @rotifer/mcp-server --allow=no-sandbox,trust-unsigned
ROTIFER_MCP_ALLOW=no-sandbox                    # same thing

Nada se elimina. La opción pasa de "cualquier llamador puede establecerla" a "alguien la declaró al lanzamiento", y siempre puedes hacerlo tú mismo:

rotifer agent run <name> --no-sandbox
rotifer run <gene> --trust-unsigned

Lo que cambia es que un asistente ya no puede decidir desactivar el sandbox por su cuenta. Pasar no_sandbox: false es pedir el comportamiento seguro y nunca se rechaza.

Deshacer una instalación

install_gene con force solía sobrescribir un Gene sin forma de volver atrás. Ahora mueve la copia antigua a <genes>/.snapshots/ primero, y rollback_gene la devuelve:

rollback_gene {}                          → what can be rolled back
rollback_gene { gene_name: "formatter" }  → restore the copy that was replaced

Una instantánea por Gene: la siguiente sobrescritura de ese Gene la reemplaza, y una restauración la consume. Esto deshace la última actualización en lugar de mantener un historial — list_gene_versions ya responde qué versiones existen upstream.

Mantener el servidor actualizado

El servidor siempre te ha dicho cuando estaba desactualizado — una línea en stderr al inicio, una vez al día. self-update es la otra mitad:

rotifer-mcp-server self-update              # check, verify, install
rotifer-mcp-server self-update --rollback   # back to the version it replaced

Rechaza cualquier versión para la que npm no tenga atestación de procedencia — este paquete publica desde CI con --provenance, así que una compilación sin atestar no es una que este proyecto haya lanzado.

Dos cosas que vale la pena saber:

Un servidor en ejecución sigue sirviendo el código antiguo. Instalar reemplaza archivos en disco; no reemplaza el proceso con el que tu editor ya está hablando. Reinicia tu host MCP después.
Si lanzas a través de npx, no hay nada que actualizar. Un npx @rotifer/mcp-server sin fijar re-resuelve la última versión publicada en cada ejecución, así que self-update lo dice y se detiene en lugar de instalar una copia global que lo ocultaría.

Este es un comando que ejecutas, no una herramienta que el modelo pueda llamar. Actualizar significa una instalación global, y una herramienta ni siquiera podría informar el resultado honestamente — el modelo diría "actualizado" mientras aún está siendo servido por el proceso antiguo.

Informe de uso

Cuando estás con sesión iniciada, cada llamada de herramienta informa un registro de uso a Rotifer Cloud: el nombre de la herramienta, el id del Gene sobre el que actuó, si tuvo éxito, cuánto tiempo tomó y tu id de usuario. Eso es lo que get_mcp_stats lee de vuelta. Ejecutar un Gene también registra la invocación, de la que dependen las métricas anti-manipulación del protocolo.

No envía los argumentos que pasas, el contenido de ningún archivo, tus variables de entorno o tu configuración local.

Con sesión cerrada, no se envía ningún registro de uso. Una solicitud sí sale de cualquier manera: instalar un Gene incrementa el contador público de instalaciones de ese Gene. Lleva el id del Gene y nada más — sin id de usuario, sin sesión, sin argumentos — y es así como la Arena cuenta las instalaciones. Hasta 0.15.1 nada lo detenía, y esta sección decía "con sesión cerrada, no se informa nada", lo cual no era cierto para una instalación.

ROTIFER_TELEMETRY=0 ahora detiene los tres:

ROTIFER_TELEMETRY=0    # also accepts false / off

Los tres son logMcpCall, logGeneInvocation y la llamada track_download dentro de installGene, todos en src/cloud.ts — lo suficientemente cortos como para leerlos completos. Nada más aquí informa nada por sí solo: cada otra llamada saliente en este servidor es una herramienta que invocaste haciendo su trabajo — una consulta, una publicación, un inicio de sesión — más la descarga del artefacto WASM y una verificación de versión de npm por día.

Requisitos

Node.js >= 20

Combínalo con la CLI

Este servidor MCP funciona mejor junto con la CLI de Rotifer. La CLI proporciona el entorno de ejecución local (sandbox WASM, motor Arena, compilador IR) mientras que el servidor MCP lo expone todo a tu asistente de IA:

npm install -g @rotifer/playground
rotifer init my-agent && cd my-agent
rotifer hello --template quality-advisor   # your first Agent workspace in seconds

Enlaces

Protocolo Rotifer — Sitio principal
Guía de configuración de MCP — Configuración paso a paso
Mercado de Genes — Explora y descubre Genes
Playground de CLI — Construye y prueba Genes localmente
Especificación del protocolo — Especificación formal

Licencia

Apache-2.0