> 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/pt-br/produtos/rome-cli.md).

# Rome CLI + MCP

A CLI de desenvolvedor da Rome e o servidor MCP — fatos fundamentados sobre a chain, o padrão de build correto e as ações exclusivas da Rome (fund, deploy, verify) para um humano ou um agente de IA.

`rome` leva um builder — humano ou um agente de IA — por todo o ciclo de build-on-Rome: fatos da chain fundamentados, o padrão certo, chamadas de contrato, a rampa de entrada de funding, deploy/send, diagnóstico entre VMs e uma works-gate em ambas as lanes. Um núcleo de capacidades, duas interfaces alinhadas — uma CLI (`rome <command>`) e um [MCP](https://modelcontextprotocol.io) servidor (`rome mcp`) — assim, um agente e um humano compartilham um único modelo mental.

## Instalar

Repo-first (publicação no npm pendente):

```bash
# uso único, sem instalação:
npx github:rome-protocol/rome-cli#v0.11.0 facts chain hadrian

# instalação durável — clone + link:
git clone --branch v0.11.0 https://github.com/rome-protocol/rome-cli
cd rome-cli && npm install && npm install -g .
```

Um simples `npm install -g github:rome-protocol/rome-cli` faz **não** funciona hoje — o npm prepara as dependências git do pacote sem os próprios node\_modules ([rome-cli#25](https://github.com/rome-protocol/rome-cli/issues/25)). Use o uso único com npx ou clone + link, e fixe uma tag como acima: o npx mantém a cópia que buscou primeiro, então um `npx github:rome-protocol/rome-cli` pode continuar executando uma versão antiga, enquanto uma tag fixada sempre busca essa versão.

## Duas camadas sobre um único núcleo

**Leituras — fundamentação + diagnóstico.** Sem chaves; tanto na CLI quanto no servidor MCP.

| Comando                                                  | O que ele retorna                                                                                                                                    |
| -------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome facts chain·tokens·contracts·gas·balance·programs` | fatos vivos da chain vindos do registro + RPC — sem IDs, endereços ou seletores inventados                                                           |
| `rome cookbook patterns·cpi-recipe·errors`               | qual exemplo se encaixa no seu objetivo · as regras de conta de CPI que os agentes costumam errar · decodifique uma falha no Rome → causa + correção |
| `rome call <chain> <addr> <sig> [args]`                  | leia um contrato (`eth_call`) — argumentos com vários valores vão separados por vírgula em um único argumento: `"0xOwner…,0xSpender…"`               |
| `rome doctor <chain>`                                    | pré-voo — a chain está ativa? O RPC está acessível? O programa está configurado? A carteira está financiada?                                         |
| `rome tx <chain> <hash>`                                 | diagnostique uma tx — receipt EVM + a(s) tx(s) de liquidação na Solana + um link Via (Rome não tem `debug_traceTransaction`)                         |
| `rome preset foundry\|hardhat <chain>`                   | uma configuração de rede Rome pronta para sua toolchain + as particularidades                                                                        |

**Ações — assinar on-chain.** somente na CLI, chave vinda do ambiente, **nunca** no MCP.

| Comando                                                                    | O que faz                                                                                                                                                                                                                                                                                                                    |
| -------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome deploy <chain> <artifact>`                                           | implanta um contrato compilado, lidando com as particularidades de gas do Rome                                                                                                                                                                                                                                               |
| `rome send <chain> <addr> <sig>`                                           | escreve em um contrato pelo caminho correto de escrita do Rome                                                                                                                                                                                                                                                               |
| `rome fund <chain> --from <src> --amount <usdc>`                           | faça bridge de USDC → gas do Rome (CCTP) — a rampa de entrada "from home"                                                                                                                                                                                                                                                    |
| `rome bridge <chain> --from <src> --amount <usdc> [--intent gas\|wrapper]` | faça bridge de USDC **em** como gas ou wUSDC                                                                                                                                                                                                                                                                                 |
| `rome bridge <chain> --to <dest> --amount <usdc>`                          | faça bridge de wUSDC **saída** — queime no Rome; você reivindica no destino (o Rome subsidia a entrada, não a reivindicação de saída)                                                                                                                                                                                        |
| `rome activate <chain>`                                                    | financiamento único de PDA necessário antes do **primeira saída via bridge** (a entrada é sem atrito — não precisa de nada)                                                                                                                                                                                                  |
| `rome verify <chain> [--path …]`                                           | o **works-gate ciente do caminho**, uma por caminho de entrada: `solidity` — o mesmo contrato responde na lane EVM *e* a lane Solana · `solana-program` — uma chamada na lane EVM aciona seu programa Solana via CPI · `de casa` — entrada via bridge → ação no Rome → saída via bridge, o trajeto de ida e volta comprovado |

## Conecte isso a um agente de IA (MCP)

Você não executa nem hospeda nada — seu cliente MCP inicia `rome mcp` (um servidor stdio) sob demanda. Registre-o uma vez:

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

(Com a instalação via clone + link, `{ "command": "rome", "args": ["mcp"] }` também funciona — a forma com npx só não precisa de instalação prévia.)

Então o agente chama ferramentas como `facts_chain`, `cookbook_cpi_recipe`, `doctor`, `tx`, e `preset` — fundamentado no registro em tempo real + RPC, então ele para de adivinhar endereços e seletores. A interface MCP é **somente leitura e não guarda chaves** — seguro para conectar a qualquer agente; ele nunca pode assinar nem movimentar fundos. As ações de assinatura ficam na CLI, com a chave fornecida pelo ambiente.

## O ciclo de fundamentação do agente

1. `rome cookbook patterns <o que estou construindo>` → qual repositório de exemplo + arquitetura
2. `rome facts chain <chain>` → RPC, ID do programa, token de gas (sem codificação fixa)
3. …escreva código usando exatamente esses valores…
4. `rome verify <chain> --path <your way in>` → prove que funciona, por qualquer caminho que você tenha vindo

## Saiba mais

* Repositório + guias completos: [`rome-protocol/rome-cli`](https://github.com/rome-protocol/rome-cli)
* [Ecossistema e repositórios](/pt-br/introducao/ecosystem.md) · [Construir um app de duas lanes](/pt-br/guias-do-desenvolvedor/dual-lane-app.md) · [De casa: acesse o Rome a partir de outra chain](/pt-br/guias-do-desenvolvedor/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/pt-br/produtos/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.