> 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, Contract-Aufrufe, die Funding-On-Ramp, Deploy/Send, Cross-VM-Diagnose und ein Works-Gate für beide Schienen. Ein Fähigkeitskern, zwei abgestimmte Oberflächen — eine CLI (`rome <command>`) und ein [MCP](https://modelcontextprotocol.io) Server (`rome mcp`) — sodass Agent und Mensch dasselbe mentale Modell teilen.

## Installieren

Repo-first (npm-Veröffentlichung steht noch aus):

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

# dauerhafte Installation — klonen + verlinken:
git clone --branch v0.11.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` tut **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 den npx-Einmalaufruf oder klonen + verlinken und pinne wie oben ein Tag: npx behält die zuerst abgerufene Kopie, sodass ein ungepinntes `npx github:rome-protocol/rome-cli` kann weiter eine alte Version ausführen, während ein gepinntes Tag immer genau diese Version abruft.

## Zwei Schichten über einem Kern

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

| Befehl                                                                              | Was es zurückgibt                                                                                                                              |
| ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome Faktenkette·Token·Verträge·Gas·Guthaben·Programme`                            | live Chain-Fakten aus Registry + RPC — keine halluzinierten IDs, Adressen oder Selektoren                                                      |
| `Kochbuch Muster·CPI-Rezept·Fehler`                                                 | welches Beispiel zu deinem Ziel passt · die CPI-Account-Regeln, bei denen Agenten falsch liegen · einen Rome-Fehler dekodieren → Ursache + Fix |
| `rome call <chain> <addr> <sig> [args]`                                             | einen Contract lesen (`eth_call`) — Argumente mit mehreren Werten kommen kommagetrennt in einem Argument: `"0xOwner…,0xSpender…"`              |
| `Preflight — Chain live? RPC erreichbar? Programm konfiguriert? Wallet aufgeladen?` | eine Transaktion diagnostizieren — EVM-Receipt + die Solana-Abwicklungs-Transaktion(en) + ein Via-Link (Rome hat kein                          |
| `rome tx <chain> <hash>`                                                            | diagnose a tx — EVM receipt + the Solana settlement tx(s) + a Via link (Rome has no `debug_traceTransaction`)                                  |
| `rome preset foundry\|hardhat <chain>`                                              | eine fertige Rome-Netzwerkkonfiguration für deine Toolchain + die Eigenheiten                                                                  |

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

| Befehl                                                                     | Was es macht                                                                                                                                                                                                                                                                                                                                        |
| -------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rome deploy <chain> <artifact>`                                           | einen kompilierten Contract deployen und dabei die Gas-Eigenheiten von Rome handhaben                                                                                                                                                                                                                                                               |
| `rome send <chain> <addr> <sig>`                                           | in einen Contract über den richtigen Rome-Schreibpfad 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 **aus** — auf Rome verbrennen; du beanspruchst auf dem Zielnetzwerk (Rome sponsert den Inbound, nicht den ausgehenden Claim)                                                                                                                                                                                                          |
| `rome activate <chain>`                                                    | einmalige PDA-Finanzierung erforderlich vor dem **ersten Bridge nach außen** (Inbound ist reibungslos — braucht nichts)                                                                                                                                                                                                                             |
| `rome verify <chain> [--path …]`                                           | das **pfadbewusste Works-Gate**, je eines pro Weg hinein: `Solidity` — derselbe Contract antwortet auf der EVM-Schiene *und* die Solana-Schiene · `solana-program` — ein Aufruf auf der EVM-Schiene steuert dein Solana-Programm via CPI · `von zu Hause` — hinein bridgen → auf Rome handeln → hinaus bridgen, die Hin- und Rückreise ist bewiesen |

## In einen KI-Agenten einbinden (MCP)

Du betreibst oder hostest nichts — 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.11.0", "mcp"] } } }
```

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

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

## Die Verankerungsschleife des Agenten

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

## Mehr erfahren

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