> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/es/productos/rome-cli.md).

# Rome CLI + MCP

La CLI para desarrolladores de Rome y el servidor MCP: hechos de cadena fundamentados, el patrón de compilación correcto y las acciones exclusivas de Rome (financiar, desplegar, verificar) para una persona o un agente de IA.

`rome` transporta a un desarrollador — humano o agente de IA — a lo largo de todo el ciclo de vida de build-on-Rome: hechos de cadena fundamentados, el patrón correcto, llamadas a contratos, la ruta de entrada de financiación, desplegar/enviar, diagnóstico entre VM y una compuerta de trabajo en ambas vías. Un núcleo de capacidad, dos superficies alineadas — una CLI (`rome <command>`) y un [MCP](https://modelcontextprotocol.io) servidor (`rome mcp`) — para que un agente y un humano compartan un mismo modelo mental.

## Instalar

Primero el repositorio (publicación en npm pendiente):

```bash
# ejecución única, sin instalar:
npx github:rome-protocol/rome-cli#v0.12.0 facts chain hadrian

# instalación persistente — clonar + enlazar:
git clone --branch v0.12.0 https://github.com/rome-protocol/rome-cli
cd rome-cli && npm install && npm install -g .
```

Un `npm install -g github:rome-protocol/rome-cli` no **no** funciona hoy — npm prepara las dependencias git del paquete sin sus propios node\_modules ([rome-cli#25](https://github.com/rome-protocol/rome-cli/issues/25)). Usa la ejecución única con npx o clona + enlaza, y fija una etiqueta como arriba: npx conserva la copia que obtuvo primero, así que un `npx github:rome-protocol/rome-cli` sin fijar puede seguir ejecutando una versión antigua, mientras que una etiqueta fijada siempre obtiene esa versión.

## Dos capas sobre un núcleo

**Lecturas — base + diagnóstico.** Sin claves; tanto en la CLI como en el servidor MCP.

| Comando                                                  | Qué devuelve                                                                                                                                  |
| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome facts chain·tokens·contracts·gas·balance·programs` | hechos en vivo de la cadena desde el registro + RPC — sin ids, direcciones ni selectores inventados                                           |
| `rome cookbook patterns·cpi-recipe·errors`               | qué ejemplo se ajusta a tu objetivo · las reglas de cuentas CPI que los agentes suelen errar · decodifica un fallo de Rome → causa + solución |
| `rome call <chain> <addr> <sig> [args]`                  | leer un contrato (`eth_call`) — los argumentos con múltiples valores se separan por comas en un solo argumento: `"0xOwner…,0xSpender…"`       |
| `rome doctor <chain>`                                    | preverificación — ¿la cadena está activa? ¿el RPC responde? ¿el programa está configurado? ¿la wallet tiene fondos?                           |
| `rome tx <chain> <hash>`                                 | diagnosticar una tx — recibo EVM + las transacciones de liquidación de Solana + un enlace Via (Rome no tiene `debug_traceTransaction`)        |
| `rome preset foundry\|hardhat <chain>`                   | una configuración de red de Rome lista para tu toolchain + las particularidades                                                               |

**Acciones — firma en cadena.** solo CLI, clave desde el entorno, **nunca** en MCP.

| Comando                                                                    | Qué hace                                                                                                                                                                                                                                                                                                                                                               |
| -------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome deploy <chain> <artifact>`                                           | desplegar un contrato compilado, manejando las particularidades de gas de Rome                                                                                                                                                                                                                                                                                         |
| `rome send <chain> <addr> <sig>`                                           | escribir en un contrato mediante la ruta de escritura correcta de Rome                                                                                                                                                                                                                                                                                                 |
| `rome fund <chain> --from <src> --amount <usdc>`                           | puentear USDC → gas de Rome (CCTP) — la ruta de entrada "desde casa"                                                                                                                                                                                                                                                                                                   |
| `rome bridge <chain> --from <src> --amount <usdc> [--intent gas\|wrapper]` | puentear USDC **en** como gas o wUSDC                                                                                                                                                                                                                                                                                                                                  |
| `rome bridge <chain> --to <dest> --amount <usdc>`                          | puentear wUSDC **hacia fuera** — quemar en Rome; tú reclamas en el destino (Rome subvenciona la entrada, no la reclamación de salida)                                                                                                                                                                                                                                  |
| `rome activate <chain>`                                                    | financiación PDA opcional; puentear hacia fuera no la necesita, porque el contrato del puente (RomeBridgeWithdraw v12 y posteriores) paga la renta del mensaje y la factura en gas                                                                                                                                                                                     |
| `rome verify <chain> [--path …]`                                           | la **compuerta de trabajo consciente de la ruta**, una por cada vía de entrada: `solidity` — el mismo contrato responde en el carril EVM *y* el carril Solana · `solana-program` — una llamada en el carril EVM impulsa tu programa de Solana vía CPI · `desde casa` — puentea hacia dentro → actúa en Rome → puentea hacia fuera, el viaje de ida y vuelta comprobado |

## Conéctalo a un agente de IA (MCP)

No ejecutas ni alojas nada — tu cliente MCP lanza `rome mcp` (un servidor stdio) bajo demanda. Regístralo una vez:

```json
{ "mcpServers": { "rome": { "command": "npx", "args": ["-y", "github:rome-protocol/rome-cli#v0.12.0", "mcp"] } } }
```

(Con la instalación de clonar + enlazar, `{ "command": "rome", "args": ["mcp"] }` también funciona — la forma con npx solo no necesita instalación previa.)

Luego el agente llama herramientas como `facts_chain`, `cookbook_cpi_recipe`, `doctor`, `tx`, y `preset` — fundamentado en el registro + RPC en vivo, así que deja de adivinar direcciones y selectores. La superficie MCP es **de solo lectura y no contiene claves** — seguro para conectarlo a cualquier agente; nunca puede firmar ni mover fondos. Las acciones de firma permanecen en la CLI, con la clave suministrada a través del entorno.

## El bucle de base del agente

1. `rome cookbook patterns <lo que estoy construyendo>` → qué repo de ejemplo + arquitectura
2. `rome facts chain <chain>` → RPC, id del programa, token de gas (sin codificar de forma rígida)
3. …escribir código con esos valores exactos…
4. `rome verify <chain> --path <tu vía de entrada>` → demostrar que funciona, por cualquier vía por la que hayas llegado

## Más información

* Repositorio + guías completas: [`rome-protocol/rome-cli`](https://github.com/rome-protocol/rome-cli)
* [Ecosistema y repos](https://docs.rome.builders/es/primeros-pasos-1/ecosystem.md) · [Crear una app de doble vía](https://docs.rome.builders/es/guias-para-desarrolladores/dual-lane-app.md) · [Desde casa: llega a Rome desde otra cadena](https://docs.rome.builders/es/guias-para-desarrolladores/from-home.md)


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/es/productos/rome-cli.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
