> 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` acompaña 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 rampa de entrada de financiamiento, deploy/send, diagnóstico entre VMs y una puerta de validación para ambas vías. Un núcleo de capacidades, dos superficies alineadas — una CLI (`rome <comando>`) y un [MCP](https://modelcontextprotocol.io) servidor (`rome mcp`) — para que un agente y un humano compartan un único modelo mental.

## Instalación

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

```bash
# uso único, sin instalación:
npx github:rome-protocol/rome-cli#v0.11.0 facts chain hadrian

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

Un simple `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 el modo de un solo uso de 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` puede seguir ejecutando una versión antigua, mientras que una etiqueta fijada siempre obtiene esa versión.

## Dos capas sobre un único núcleo

**Lecturas — fundamento + 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 de cadena en vivo 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 de CPI que los agentes suelen equivocarse · decodifica un fallo de Rome → causa + solución |
| `rome call <chain> <addr> <sig> [args]`                  | leer un contrato (`eth_call`) — los argumentos de múltiples valores se separan por comas en un solo argumento: `"0xOwner…,0xSpender…"`                 |
| `rome doctor <chain>`                                    | preflight — ¿la cadena está activa? ¿RPC accesible? ¿programa configurado? ¿wallet financiada?                                                         |
| `rome tx <chain> <hash>`                                 | diagnostica una tx — recibo EVM + la(s) tx(s) 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 peculiaridades                                                                          |

**Acciones — firmar en cadena.** Solo CLI, clave desde el entorno, **nunca** en MCP.

| Comando                                                                    | Qué hace                                                                                                                                                                                                                                                                                                                                                         |
| -------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome deploy <chain> <artifact>`                                           | despliega un contrato compilado, gestionando las peculiaridades de gas de Rome                                                                                                                                                                                                                                                                                   |
| `rome send <chain> <addr> <sig>`                                           | escribe en un contrato a través de la ruta de escritura correcta de Rome                                                                                                                                                                                                                                                                                         |
| `rome fund <chain> --from <src> --amount <usdc>`                           | puente USDC → gas de Rome (CCTP) — la rampa de entrada «desde casa»                                                                                                                                                                                                                                                                                              |
| `rome bridge <chain> --from <src> --amount <usdc> [--intent gas\|wrapper]` | puente USDC **en** como gas o wUSDC                                                                                                                                                                                                                                                                                                                              |
| `rome bridge <chain> --to <dest> --amount <usdc>`                          | puente wUSDC **salida** — se quema en Rome; tú reclamas en el destino (Rome subsidia la entrada, no la reclamación de salida)                                                                                                                                                                                                                                    |
| `rome activate <chain>`                                                    | se requiere financiamiento de PDA de una sola vez antes del **primer puente de salida** (la entrada es sin fricción — no necesita ninguna)                                                                                                                                                                                                                       |
| `rome verify <chain> [--path …]`                                           | la **puerta de validación consciente de la ruta**, una por cada vía de entrada: `solidity` — el mismo contrato responde en la vía EVM *y* la vía de Solana · `solana-program` — una llamada por la vía EVM impulsa tu programa de Solana mediante CPI · `desde casa` — entrada por puente → actuar en Rome → salida por puente, el viaje de ida y vuelta probado |

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

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

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

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

Entonces el agente llama herramientas como `facts_chain`, `cookbook_cpi_recipe`, `doctor`, `tx`y `preset` — fundamentado en el registro en vivo + RPC, así 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 se quedan en la CLI, con la clave suministrada a través del entorno.

## El bucle de fundamentación del agente

1. `rome cookbook patterns <lo que estoy construyendo>` → qué repositorio de ejemplo + arquitectura
2. `rome facts chain <chain>` → RPC, id del programa, token de gas (sin codificación fija)
3. …escribe código usando esos valores exactos…
4. `rome verify <chain> --path <your way in>` → demuestra que funciona, por la vía que hayas usado

## Más información

* Repositorio + guías completas: [`rome-protocol/rome-cli`](https://github.com/rome-protocol/rome-cli)
* [Ecosistema y repos](/es/introduccion/ecosystem.md) · [Construir una app de doble carril](/es/guias-para-desarrolladores/dual-lane-app.md) · [Desde casa: llega a Rome desde otra cadena](/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.