> 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/de/produkte/rome-cli.md).

# Rome CLI + MCP

Die Rome-Entwickler-CLI und der MCP-Server — fundierte Chain-Fakten, das richtige Build-Muster und die Rome-eigenen Aktionen (fund, deploy, verify) für einen Menschen oder einen KI-Agenten.

`rome` begleitet einen Builder — Mensch oder KI-Agent — durch den gesamten Build-on-Rome-Lebenszyklus: fundierte Chain-Fakten, das richtige Muster, Vertragsaufrufe, die Funding-On-Ramp, Deploy/Send, Cross-VM-Diagnose und ein Works-Gate für beide Lanes. Ein Fähigkeitskern, zwei abgestimmte Oberflächen — ein CLI (`rome <command>`) und ein [MCP](https://modelcontextprotocol.io) Server (`rome mcp`) — damit ein Agent und ein Mensch dasselbe mentale Modell teilen.

## Installieren

Repo-first (npm-Publish ausstehend):

```bash
# Einmalig, keine Installation:
npx github:rome-protocol/rome-cli#v0.12.0 facts chain hadrian

# dauerhafte Installation — klonen + verlinken:
git clone --branch v0.12.0 https://github.com/rome-protocol/rome-cli
cd rome-cli && npm install && npm install -g .
```

Ein einfaches `npm install -g github:rome-protocol/rome-cli` funktioniert **nicht** heute nicht — npm bereitet die Git-Abhängigkeiten des Pakets ohne eigene node\_modules vor ([rome-cli#25](https://github.com/rome-protocol/rome-cli/issues/25)). Verwende die npx-Einmalvariante oder clone + link, und pinne wie oben ein Tag: npx behält die zuerst abgerufene Kopie, sodass ein nicht gepinntes `npx github:rome-protocol/rome-cli` weiter eine alte Version ausführen kann, während ein gepinntes Tag immer genau diese Version abruft.

## Zwei Ebenen über einem Kern

**Lesen — Grounding + Diagnose.** Keine Schlüssel; sowohl im CLI als auch auf dem MCP-Server.

| Befehl                                                   | Was es zurückgibt                                                                                                                           |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome facts chain·tokens·contracts·gas·balance·programs` | Live-Chain-Fakten aus der Registry + RPC — keine halluzinierten IDs, Adressen oder Selektoren                                               |
| `rome cookbook patterns·cpi-recipe·errors`               | welches Beispiel zu deinem Ziel passt · die CPI-Account-Regeln, die Agenten falsch machen · einen Rome-Fehler dekodieren → Ursache + Fix    |
| `rome call <chain> <addr> <sig> [args]`                  | einen Vertrag lesen (`eth_call`) — Argumente mit mehreren Werten werden kommasepariert in einem Argument übergeben: `"0xOwner…,0xSpender…"` |
| `rome doctor <chain>`                                    | Preflight — Chain live? RPC erreichbar? Programm konfiguriert? Wallet finanziert?                                                           |
| `rome tx <chain> <hash>`                                 | eine Tx diagnostizieren — EVM-Receipt + die Solana-Settlement-Tx(s) + ein Via-Link (Rome hat kein `debug_traceTransaction`)                 |
| `rome preset foundry\|hardhat <chain>`                   | eine fertige Rome-Netzwerkkonfiguration für deine Toolchain + die Eigenheiten                                                               |

**Aktionen — on-chain signieren.** nur im CLI, Schlüssel aus der Umgebung, **niemals** auf MCP.

| Befehl                                                                     | Was es macht                                                                                                                                                                                                                                                                                                                         |
| -------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `rome deploy <chain> <artifact>`                                           | einen kompilierten Vertrag bereitstellen und dabei Roms Gas-Eigenheiten handhaben                                                                                                                                                                                                                                                    |
| `rome send <chain> <addr> <sig>`                                           | in einen Vertrag über den korrekten Rome-Write-Pfad schreiben                                                                                                                                                                                                                                                                        |
| `rome fund <chain> --from <src> --amount <usdc>`                           | USDC → Rome-Gas (CCTP) bridgen — die On-Ramp „von zu Hause“                                                                                                                                                                                                                                                                          |
| `rome bridge <chain> --from <src> --amount <usdc> [--intent gas\|wrapper]` | USDC bridgen **in** als Gas oder wUSDC                                                                                                                                                                                                                                                                                               |
| `rome bridge <chain> --to <dest> --amount <usdc>`                          | wUSDC bridgen **hinaus** — auf Rome verbrennen; du claimst auf dem Ziel (Rome unterstützt eingehend, nicht den ausgehenden Claim)                                                                                                                                                                                                    |
| `rome activate <chain>`                                                    | optionales PDA-Funding; das Bridgen hinaus braucht es nicht, weil der Bridge-Contract (RomeBridgeWithdraw v12 und neuer) die Message-Rent bezahlt und sie in Gas abrechnet                                                                                                                                                           |
| `rome verify <chain> [--path …]`                                           | der **pfadbewusste Works-Gate**, eines pro Zugangsweg: `solidity` — derselbe Vertrag antwortet auf der EVM-Lane *und* die Solana-Lane · `solana-program` — ein Aufruf auf der EVM-Lane steuert dein Solana-Programm via CPI · `von zu Hause` — herein bridgen → auf Rome handeln → hinaus bridgen, die Hin-und-zurück-Reise bewiesen |

## Binde es in einen KI-Agenten ein (MCP)

Du musst nichts ausführen oder hosten — dein MCP-Client startet `rome mcp` (einen stdio-Server) bei Bedarf. Einmal registrieren:

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

(Mit der clone + link-Installation, `{ "command": "rome", "args": ["mcp"] }` funktioniert ebenfalls — die npx-Form braucht nur keine vorherige Installation.)

Der Agent ruft dann Tools auf wie `facts_chain`, `cookbook_cpi_recipe`, `doctor`, `tx`, und `preset` — gestützt auf die Live-Registry + RPC, sodass er aufhört, Adressen und Selektoren zu erraten. Die MCP-Oberfläche ist **nur lesend und enthält keine Schlüssel** — sicher in jeden Agenten einzubinden; er kann niemals signieren oder Gelder bewegen. Die Signieraktionen bleiben im CLI, mit dem Schlüssel, der über die Umgebung bereitgestellt wird.

## Die Grounding-Schleife des Agenten

1. `rome cookbook patterns <was ich baue>` → welches Beispiel-Repo + welche Architektur
2. `rome facts chain <chain>` → RPC, Program-ID, Gas-Token (kein Hardcoding)
3. …schreibe Code gegen genau diese Werte…
4. `rome verify <chain> --path <your way in>` → beweise, dass es funktioniert, egal über welchen Pfad du gekommen bist

## Mehr erfahren

* Repo + vollständige Anleitungen: [`rome-protocol/rome-cli`](https://github.com/rome-protocol/rome-cli)
* [Ökosystem & Repos](https://docs.rome.builders/de/erste-schritte-1/ecosystem.md) · [Eine Dual-Lane-App bauen](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md) · [Von zu Hause: Rome von einer anderen Chain aus erreichen](https://docs.rome.builders/de/entwicklerleitfaden/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/de/produkte/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.
