# Grav 2: das Flat-File-CMS, das KI-Agenten Markdown und MCP anbietet

> Grav 2 an der Quelle geprüft: Geschichte, neuer Stack, Markdown für Agenten, der MCP-Server und wo das Marketing mehr verspricht als der Code.

Source: https://www.jpkc.com/db/blog/grav-cms/

Ich bin ein großer Fan von Grav. Das CMS speichert alles als Dateien, Inhalte in Markdown, Einstellungen in YAML (einem gut lesbaren Textformat für Konfiguration), und braucht dafür keinen Datenbankserver. Eine Knowledge Base auf Grav betreibe ich selbst, ausgeliefert über FrankenPHP. Wie die Caddy-Konfiguration dafür aussieht, steht im [Artikel zu FrankenPHP und Caddy](https://www.jpkc.com/db/blog/frankenphp-caddy/#grav). Mit Version 2 wirbt Grav nun damit, bereit für KI und MCP zu sein (Model Context Protocol, ein Standard, über den KI-Assistenten Werkzeuge aufrufen), und genau diese Richtung finde ich spannend. Sie ist der Grund für diesen Artikel.

Fan sein heißt für mich nicht, das Marketing abzuschreiben. Für diesen Artikel sind Doku, Changelogs, der Quellcode des MCP-Servers und die Sicherheitsmeldungen ausgewertet, und an einigen Stellen verspricht die Website mehr, als der Code hält. Das kommt hier offen zur Sprache. Falls du Grav noch nicht kennst: Jeder Abschnitt beginnt einfach und geht danach in die Tiefe.

## Die Kurzfassung

| Frage | Antwort |
| --- | --- |
| **Was ist Grav?** | Ein Flat-File-CMS in PHP: Seiten sind Ordner mit einer Markdown-Datei, Konfiguration ist YAML, Templates sind Twig, ein Datenbankserver ist nicht nötig |
| **Was ist neu in Grav 2?** | Ein neuer Stack (PHP 8.3+, Twig 3, Symfony 7.4), ein neues Admin als App über eine REST-API und eine Sandbox für Twig in Seiteninhalten |
| **Was heißt „AI ready"?** | Seit 2.1.0 liefert jede Seite auf Wunsch Markdown statt HTML, standardmäßig an. Dazu kommt eine API, über die Agenten mit echten Nutzerrechten arbeiten |
| **Ist der MCP-Server eingebaut?** | Nein. Der offizielle Server ist das separate npm-Paket `grav-mcp` 0.1.5 für Node.js, laut Doku „not a Grav plugin". Ein MCP-Endpunkt direkt in der Site kommt bisher nur als Plugin eines externen Autors |
| **Welche Rechte hat ein Agent?** | Die des Grav-Nutzers, dem sein API-Key gehört. Das ist ein echter Vorteil gegenüber Lösungen mit festen Super-Admin-Rechten |
| **Wie steht es um die Sicherheit?** | 219 Advisories (Sicherheitsmeldungen) im Grav-Repository, 184 davon aus 2026. Gefixt wird schnell, du musst aber ebenso schnell updaten |
| **Kann ich von 1.7 einfach upgraden?** | Nein. Grav 2 kommt als frische Installation neben der alten Site, ein Migrations-Plugin hilft beim Umzug |

Geschrieben habe ich den Artikel mit Stand 12. November 2026. Am 20. November habe ich ihn auf Grav 2.2.31, das API-Plugin 1.1.22, `grav-mcp` 0.1.5 und das Plugin `mcp-server` 1.11.3 von Sandy McArthur nachgezogen; was sich seither geändert hat, steht im [Nachtrag vom 20. November](#nachtrag-vom-20-november). Stack-Tabelle, Standardwerte und Download-Paket beziehen sich weiter auf Grav 2.2.29, Abhängigkeiten und Standardwerte sind laut Vergleich der beiden Versionen bis 2.2.31 unverändert. „Laut Doku" und „laut Quelltext" heißt: dort nachgelesen. Die Agenten-Funktionen habe ich für diesen Artikel nicht in Betrieb genommen, was hier über sie steht, stammt aus Doku, Changelogs und Code. Leistungszahlen stammen vom Hersteller und stehen mit ihren Messbedingungen da.

## Nachtrag vom 20. November

Seit dem Stichtag sind Grav 2.2.30 und 2.2.31 erschienen, im Wesentlichen mit Fehlerkorrekturen, dazu 1.7.53.11. Abhängigkeiten, Standardwerte und Markdown-Ausgabe sind laut Vergleich unverändert, ebenso `grav-mcp`, die MCP-Doku und die Aussagen der Website. Neu sind Sicherheitsfixes in zwei Releases genau dort, wo Agenten andocken:

- **API-Plugin 1.1.21** schließt [GHSA-fqv4-9pm4-v2q2](https://github.com/getgrav/grav/security/advisories/GHSA-fqv4-9pm4-v2q2) (englisch) vom 19. November, eingestuft als kritisch. Bis 1.1.20 konnte jemand ohne Anmeldung über `POST /api/v1/auth/forgot-password` eine echte Mail zum Zurücksetzen des Passworts auslösen, deren Link das Token an einen Host des Angreifers schickte. Wer die E-Mail-Adresse eines Kontos kannte, auch die eines Super-Admins, konnte es so übernehmen, sobald das Opfer in der echten Mail auf den Link klickte. Laut Advisory umgeht die Lücke eine Prüfung, die nach CVE-2026-61839 eingebaut worden war. Aktuell ist 1.1.22.
- **`mcp-server` 1.11.3** vom 12. November schließt laut [Release Notes](https://github.com/sandymac/grav-plugin-mcp-server/releases/tag/1.11.3) (englisch) zwei Lücken im OAuth-Code des Plugins: Über die Prüfung der Redirect-URIs konnten Autorisierungscodes an Hosts außerhalb der erlaubten Liste gelangen, und abgelehnte Registrierungen konnten anonym beliebigen Text in `grav.log` schreiben, den das Werkzeug `get_logs` an KI-Clients weitergibt. Connectors, die vor 1.11.3 registriert wurden, bekommen unter Umständen eine Fehlerseite. Dann entfernst du sie und fügst sie neu hinzu.

Zahlen und Versionen habe ich im Text nachgezogen und die neuen Sicherheitsfixes an den passenden Stellen ergänzt, im [Agenten-Setup](#wie-ich-ein-agenten-setup-aufsetzen-wuerde) stehen jetzt Mindestversionen.

## Was Grav ist

Ein klassisches CMS wie WordPress legt Inhalte in einer Datenbank ab. Jede Seite entsteht, indem PHP Daten aus MySQL holt und in ein Template füllt. Grav lässt die Datenbank weg. Jede Seite ist ein Ordner unter `user/pages/`, darin liegt eine Markdown-Datei mit einem YAML-Kopf (Frontmatter, also die Metadaten wie Titel und Datum am Anfang der Datei). Die Konfiguration steht in YAML-Dateien unter `user/config/`. Der Name der Markdown-Datei wählt das Template: Aus `default.md` wird `default.html.twig`. Twig ist eine verbreitete Template-Sprache aus dem Umfeld des PHP-Frameworks Symfony.

Das [README](https://raw.githubusercontent.com/getgrav/grav/2.2.29/README.md) (englisch) beschreibt Grav als „file-based Web-platform" ohne Installation: „Just extract the ZIP archive, and you are already up and running." Für mich liegt der eigentliche Reiz woanders. Weil alles Datei ist, kannst du deine Site mit Git versionieren, per rsync sichern und in jedem Editor bearbeiten, ohne Export und ohne Datenbank-Dump.

Mehrsprachigkeit läuft ebenfalls über Dateien. Laut [Doku](https://learn.getgrav.org/2/content/multi-language) (englisch) liegen `default.de.md` und `default.en.md` im selben Ordner, mit Fallback auf `default.md`. Für den Alltag gibt es drei Kommandozeilen-Werkzeuge: `bin/grav` für Cache, Backups und Scheduler, `bin/gpm` für Plugins und Themes und `bin/plugin` für Befehle, die Plugins mitbringen. Die wichtigsten Befehle stehen im [Cheat-Sheet zu Grav](https://www.jpkc.com/db/cheatsheets/build-languages/grav/).

### Unter der Haube

Flat-File heißt nicht statisch. Grav rendert jede Seite per PHP, die Geschwindigkeit kommt aus mehreren Cache-Schichten: kompilierte YAML-Konfiguration, Seiten-Cache, Twig-Cache und Bild-Cache. Mit Grav 2 hat das Projekt den Unterbau fast komplett ausgetauscht. Die Tabelle vergleicht die `composer.json` (die Liste der Abhängigkeiten für Composer, die Paketverwaltung von PHP) von [1.7.53.10](https://raw.githubusercontent.com/getgrav/grav/1.7.53.10/composer.json) (englisch) mit der von [2.2.29](https://raw.githubusercontent.com/getgrav/grav/2.2.29/composer.json) (englisch) und deren [Lockfile](https://raw.githubusercontent.com/getgrav/grav/2.2.29/composer.lock) (englisch), in dem die exakt installierten Versionen stehen:

| Baustein | Grav 1.7 | Grav 2.2.29 |
| --- | --- | --- |
| PHP | ab 7.3.6 | ab 8.3 |
| Twig | 1.44 | 3.x, eigener Fork |
| Symfony | 4.4 | 7.4 |
| Monolog | 1.25 | 3.12 |
| Cache | Doctrine Cache | Symfony Cache |
| Markdown | Parsedown 1.7 | Parsedown 2.0.2, dazu `league/html-to-markdown` |

Ein Detail für Profis: Twig steht im Lockfile als `3.x-dev` aus dem Repository `getgrav/Twig`, einem Fork (einer eigenen Abspaltung des Projekts), der Developer-Guide nennt es „forked for Defer". Eine stabile Version hängt damit an einem Entwicklungszweig eines eigenen Forks. Auch Parsedown 2.0.2 und Parsedown Extra kommen laut Lockfile aus Grav-Forks (`getgrav/parsedown`, `getgrav/parsedown-extra`). Das ist kein Fehler, aber du solltest es wissen, wenn du Twig-Erweiterungen schreibst.

Beim PHP-Minimum widersprechen sich Code und Doku leicht. Der Code prüft laut `defines.php` auf 8.3.0, die [Anforderungen](https://learn.getgrav.org/2/basics/requirements) (englisch) nennen „PHP 8.3.11 or higher". Ich würde mich an die Doku halten, zumal ohnehin nur ein aktuelles PHP sinnvoll ist. Die [Features-Seite](https://getgrav.org/features) (englisch) nennt PHP 8.3, 8.4 und 8.5 als unterstützt.

## Zwölf Jahre in Kürze

Grav erschien im Sommer 2014. Das GitHub-Repository wurde am 2. August 2014 angelegt, der [Changelog](https://raw.githubusercontent.com/getgrav/grav/2.2.31/CHANGELOG.md) (englisch) führt Version 0.8.0 vom 13. August als „Initial Release", [Wikipedia](https://en.wikipedia.org/wiki/Grav_(software)) (englisch) nennt dagegen den 30. Juli. Der Paketmanager GPM kam schon mit 0.9.3 im Oktober 2014. Grav 1.0 folgte am 11. Dezember 2015, 1.6 brachte im April 2019 die ersten Einträge zur Flex-API (eine Schicht für strukturierte Datenobjekte wie Nutzer oder eigene Datentypen), und 1.7 erschien am 19. Januar 2021.

Die Zeitleiste auf der [About-Seite](https://getgrav.org/about) (englisch) weicht davon ab. Sie nennt „Sep 2015" für 1.0, 2016 für GPM und 2018 für Flex Objects, die Changelog-Einträge sagen etwas anderes. Für Daten würde ich mich deshalb an den Changelog halten.

Danach wurde es lang. Grav 1.8 ging am 23. Oktober 2024 in die Beta und kam in dreißig Betas nie zur stabilen Version. Am 16. April 2026 vermerkt der Changelog: „Rebranded 1.8-beta as 2.0-beta." Laut dem [Blogbeitrag zum Release](https://getgrav.org/blog/grav-2-stable-released) (englisch) war der Upgrade-Ansatz das Hauptproblem, also der Versuch, alles als Update über eine bestehende Installation zu legen. Grav 2.0.0 erschien am 20. Juni 2026, der GitHub-Release ist auf den 21. datiert. Danach ging es schnell. Laut Changelog erschienen 2.1.0 am 11. September, 2.2.0 am 24. September und 2.2.29 am 10. November 2026, der GitHub-Release ist auf den 11. datiert. Bis 2.2.31 vom 18. November führt der Changelog seit 2.0.0 insgesamt 72 stabile Releases in 151 Tagen, im Schnitt also etwa alle zwei Tage eines.

### Wer dahintersteht

Gründer und Lead ist Andy Miller. Die About-Seite sagt, Grav sei „designed, built, and maintained by Andy". Im [Vergleich mit WordPress](https://getgrav.org/blog/grav-vs-wordpress) (englisch) schreibt er über sich: „I co-founded Joomla, I created Grav". Wikipedia nennt zusätzlich Djamil Legato und Matias Griese als Entwickler, welche Rolle die beiden heute spielen, habe ich nicht geklärt. Die Firma hinter Grav ist Trilby Media, laut einem [Rückblick von 2016](https://getgrav.org/blog/year-in-review-2016) (englisch) vom Kernteam gegründet, um professionelle Dienstleistungen rund um Grav anzubieten. Der Kern steht unter MIT-Lizenz, finanziert wird er über Open Collective mit Adyen als Platin-Sponsor, über Premium-Plugins und über Dienste. Ein dokumentiertes Governance-Modell oder eine Stiftung gibt es nicht. Die [SECURITY.md](https://raw.githubusercontent.com/getgrav/grav/develop/SECURITY.md) (englisch) sagt es selbst: „Grav is maintained by a very small team."

Aus meiner Sicht ist das zugleich Stärke und Risiko. Ein kleines Team entscheidet schnell und hält die Linie, das Tempo seit 2.0 zeigt das. Es hängt aber auch viel an wenigen Menschen. Das GitHub-Repository hat rund 15.700 Sterne, und Grav hat zwischen 2016 und 2021 mehrere Preise der CMS Critic Awards gewonnen.

## Was sich mit Grav 2 ändert

Wer von 1.7 kommt, sieht die größten Unterschiede nicht im Frontend, sondern in der Verwaltung und bei den Templates. Deine Seiteninhalte laufen laut [Migrationsübersicht](https://learn.getgrav.org/2/migration/overview) (englisch) ohne Konvertierung weiter. Alles drumherum ist neu.

**Das klassische Admin ist weg.** Laut [Developer-Guide](https://learn.getgrav.org/2/migration/developer-upgrade-guide) (englisch) wurde es „removed from Grav 2.0 entirely". An seine Stelle tritt Admin 2, auch „Admin Next" genannt. Das [README von Admin 2](https://github.com/getgrav/grav-plugin-admin2) (englisch) beschreibt es als „SvelteKit single-page application that communicates with Grav exclusively through the Grav API plugin". Eine Single-Page-Application ist eine App im Browser, die ihre Daten nur noch über Schnittstellen holt. Für Plugin-Entwickler heißt das: Die Events `onAdmin*` (Stellen, an denen sich Plugins in den Ablauf einklinken) werden zu `onApi*`, und eigene Erweiterungen fürs alte Admin müssen neu geschrieben werden.

**Twig in Seiteninhalten läuft in einer Sandbox mit Allowlist.** Eine Sandbox ist ein abgeschotteter Bereich, eine Allowlist die Liste der Funktionen, die darin ausdrücklich erlaubt sind. Seit 2.0.19 ist es bei Neuinstallationen standardmäßig eingeschaltet (`security.twig_content.process_enabled: true`), abschalten lässt es sich siteweit über diesen Schalter. Die Migrationsübersicht schreibt noch, es laufe nicht mehr standardmäßig, das ist laut Changelog überholt. Die Option `undefined_functions` ist entfernt, PHP-Funktionen für Templates gibt es nur noch als Opt-in (nur, wenn du sie ausdrücklich freischaltest) über `safe_functions`. Für alte Templates gibt es den Schalter `twig3_compat`, der in 2.2.29 an ist und alte Twig-1-Syntax umschreibt. Der Developer-Guide rät trotzdem: „update templates permanently rather than rely on the transforms". Das würde ich dir auch raten, denn ein Kompatibilitätsschalter ist eine Brücke und keine Dauerlösung.

**Markdown folgt jetzt GitHub.** GitHub Flavored Markdown ist der Standard, und die alten Markdown Notices werden zu GitHub Alerts, den Hinweisboxen mit `> [!NOTE]`.

### Migration statt Upgrade

Das ist der Punkt, den du vor jedem Umstieg kennen solltest. Der Developer-Guide sagt klar: „Grav 2.0 is not delivered as an in-place upgrade." Stattdessen gibt es das Plugin „Migrate to Grav 2.0". Es legt laut Doku eine frische Grav-2-Installation in einen Unterordner neben deine Site, kopiert den `user/`-Ordner hinein, prüft die Kompatibilität deiner Plugins und lässt dich die neue Version unter `/grav-2/` testen. Danach wählst du „Promote", dann sichert es die alte Version als ZIP und tauscht, oder „Reset", dann bleibt alles beim Alten. Getestet ist der Weg laut Doku mit Apache, für nginx und Caddy musst du die Regeln selbst anpassen.

Den Ansatz finde ich gut. Deine laufende Site bleibt erreichbar, bis du umschaltest, und solange du testest, kostet dich ein Fehlschlag nur einen Unterordner. Beim „Promote" selbst löscht der Assistent allerdings die Dateien im Webroot und schiebt die neue Version nach oben. Bricht das mittendrin ab, ist laut [README](https://github.com/getgrav/grav-plugin-migrate-grav) (englisch) die Live-Site teilweise weg und das Backup-ZIP deine Rettung. Die Kompatibilitätsprüfung hängt allerdings an einer Angabe, die viele Plugins nicht machen, dazu mehr im Abschnitt zum Ökosystem.

Bei der 1.7-Linie widerspricht sich die Doku. Die Migrationsübersicht nennt 1.7.51 „the final stable release in the 1.7 series", tatsächlich gibt es danach 1.7.52, 1.7.53 und vierstellige Patch-Releases bis 1.7.53.11 vom 18. November 2026. Laut [Blog](https://getgrav.org/blog/migrating-to-grav-2) (englisch) bekommt 1.7 nur noch kritische Sicherheitsfixes, die SECURITY.md fasst das noch enger: Zurückportiert wird nur, was ohne Publisher- oder Admin-Konto ausnutzbar ist. Ich würde 1.7 deshalb als Auslaufmodell behandeln, auch wenn es keine feste Frist gibt. In der Praxis geht das Projekt allerdings darüber hinaus: 1.7.53.11 bringt auch den Fix für [GHSA-qgmc-p8w7-7x5p](https://github.com/getgrav/grav/security/advisories/GHSA-qgmc-p8w7-7x5p) (englisch), eingestuft als hoch, der ein Admin-Konto mit dem Recht `admin.users` voraussetzt.

### Tempo mit Version 2.2

Grav 2.2 war laut den [Release Notes](https://github.com/getgrav/grav/releases/tag/2.2.0) (englisch) ein Performance-Release. Die wichtigste Änderung für große Sites betrifft `lazy_index`, seit 2.0.7 als Opt-in vorhanden und seit 2.2.0 standardmäßig auf `auto`. Statt alle Seiten, Routen und Taxonomien (Einteilungen wie Kategorien und Tags) als einen großen Cache-Block zu laden, liest Grav sie bei Bedarf aus einem Index je Seite. Der Kommentar in der `system.yaml` nennt dafür „SQLite/YetiSQL" und sagt, der Modus `auto` schalte ab 1.000 Seiten ein. Ohne die PHP-Erweiterung pdo_sqlite springt laut `composer.json` die reine PHP-Engine YetiSQL aus dem Plugin `database-yetisql` ein. „Keine Datenbank" heißt damit spätestens seit 2.2 genauer: kein Datenbankserver. Ohne verfügbare Datenbank-Engine fällt Grav laut demselben Kommentar auf den alten Cache-Block zurück.

```yaml
# user/config/system.yaml (defaults as shipped in 2.2.29)
pages:
  lazy_index: auto   # true, false, or auto (on from 1,000 pages)
session:
  lazy: false        # opt-in: no session cookie for anonymous page views
```

Die zweite Neuerung ist `session.lazy`. Dann setzt Grav für anonyme Seitenaufrufe kein Session-Cookie, und ein Proxy oder CDN (ein Netz aus Servern, das Seiten zwischenspeichert und ausliefert) kann die Antworten zwischenspeichern. Der Schalter ist ein Opt-in, und die Kommentare warnen, dass Plugins, die direkt in `$_SESSION` schreiben, damit Daten verlieren können. Testen würde ich das also vor dem Einschalten.

Der [Blogbeitrag zu 2.2](https://getgrav.org/blog/grav-2-2-released) (englisch) zeigt Messungen des Herstellers: Der erste Aufruf ohne Cache (Cold Start) sank auf einer Testsite mit 1.081 Seiten von 1.047 auf 526 ms (Median der Zeit bis zum ersten Byte, Startseite, erster Aufruf nach Cache-Leerung, verglichen mit 2.1.10), bei 10.321 Seiten von 4.633 auf 2.326 ms, der Speicherbedarf der großen Site von 241,8 auf 9,6 MB. Gemessen wurde auf einem Apple M4 Max mit PHP 8.3, OPcache und Apache, per curl auf derselben Maschine, also ohne Netzwerkzeit. Die große Site war dieselbe Site, deren Doku-Bereich mit 770 Seiten zwölfmal kopiert wurde, laut Autor „a size test, not a real 10,000-page site". Die Verbesserung ist deutlich. Die „Sub-100ms page loads" der Features-Seite gelten aber für einen warmen Cache, nach einem Cache-Neuaufbau dauert eine große Site weiter Sekunden.

## „AI and MCP ready": was dahintersteckt

Grav 2 verspricht drei Dinge für KI: Inhalte in einer Form, die Agenten gut lesen können, eine Schnittstelle, über die sie schreiben dürfen, und einen MCP-Server dazu. MCP, das Model Context Protocol, ist ein offener Standard, über den KI-Assistenten wie Claude Code oder Cursor Werkzeuge externer Systeme aufrufen. Ein MCP-Server beschreibt diese Werkzeuge, der Assistent entscheidet, wann er sie nutzt. Die drei Versprechen sind unterschiedlich weit, deshalb nehme ich sie einzeln.

### Markdown für Agenten, direkt im Core

Das ist für mich das stärkste Stück, und es kommt mir sehr bekannt vor. Seit [Grav 2.1.0](https://github.com/getgrav/grav/releases/tag/2.1.0) (englisch) liefert jede Seite auf Wunsch Markdown statt HTML: „Add `.md` to any page URL, or send an `Accept: text/markdown` request header". Die Antwort enthält den gerenderten Hauptinhalt, einen YAML-Kopf mit Titel, URL, Datum, Beschreibung und Taxonomie und am Ende Links zu Eltern-, Nachbar- und Kindseiten, wieder als `.md`-URLs. Dazu kommen ein `<link rel="alternate" type="text/markdown">` im HTML, ein `Vary: Accept` und ein Header `X-Markdown-Tokens` mit einer Schätzung der Token-Zahl, laut Release Notes „matching Cloudflare's Markdown for Agents". Eingeschaltet ist das standardmäßig.

```bash
# Per the 2.1.0 release notes, both requests return the page as Markdown
curl https://example.com/blog/my-post.md
curl -H "Accept: text/markdown" https://example.com/blog/my-post
```

Fast dasselbe Muster nutzt diese Knowledge Base, nur auf anderem Weg. Hier entstehen die Markdown-Zwillinge beim Build, wie in [Warum 11ty](https://www.jpkc.com/db/blog/warum-11ty/) beschrieben, und der Apache verhandelt per `Accept: text/markdown` (ein Beispiel steht im Artikel [Redesign durch KI](https://www.jpkc.com/db/blog/redesign-durch-ki/)). Bei Grav rendert PHP das Markdown zur Laufzeit. Der [Blogbeitrag zu 2.1](https://getgrav.org/blog/grav-2-1-released) (englisch) fasst den Vorteil gut zusammen: „Grav doesn't have to guess. It wrote the page." Ein CMS, das seine Seiten aus Markdown baut, muss das HTML nicht erst zurückübersetzen.

Wer das abstimmen will, findet die Schalter laut `system.yaml` unter `pages.markdown_output`, etwa `frontmatter`, `links`, `max_links`, `absolute_urls` und `token_header`. Eigene Templates sind mit Dateien wie `default.md.twig` möglich. Was in so ein Markdown hineingehört, damit KI-Systeme es gut verwerten, beschreibe ich in [Schreiben für KI](https://www.jpkc.com/db/blog/schreiben-fuer-ki/).

Die `llms.txt`, eine Index-Datei für Sprachmodelle, ist dagegen nicht Teil des Cores. Sie kommt laut [Ankündigung zu 2.1](https://getgrav.org/blog/grav-2-1-released) (englisch) über das Sitemap-Plugin 5.3.0, eine `llms-full.txt` mit allen Inhalten ist dort optional und standardmäßig aus.

### Die API als gemeinsames Fundament

Das zweite Versprechen ist eine Schnittstelle zum Schreiben. Grav 2 bringt dafür das API-Plugin mit, eine REST-API (eine Programmierschnittstelle, die über normale HTTP-Anfragen arbeitet) unter `/api/v1`. Admin 2 spricht ausschließlich mit ihr, und Agenten tun es auch. Die [MCP-Doku](https://learn.getgrav.org/2/advanced/mcp-server) (englisch) sagt dazu: „Admin2 is the client for humans, the MCP server is the client for AI, and both go through the same API." Das finde ich die sauberste Idee im ganzen KI-Paket von Grav 2. Es gibt keinen Sonderweg für Agenten, sondern dieselbe Schnittstelle mit denselben Prüfungen.

Angemeldet wird ein Agent mit einem API-Key im Header `X-API-Key`. Der Schlüssel gehört zu einem Grav-Nutzer und erbt dessen Rechte. Die MCP-Doku sagt es so: „A key can never exceed the permissions of the user it belongs to, so the user account is your security boundary." Die Rechte sind laut [API-Plugin](https://github.com/getgrav/grav-plugin-api) (englisch) fein aufgeteilt, etwa `api.pages.read` und `api.pages.write`, `api.media`, `api.config`, `api.users`, `api.gpm` und `api.system.backup`. Backups haben ein eigenes Recht, weil sie Passwort-Hashes und Geheimnisse enthalten. Jeder Aufruf braucht dazu das Grundrecht `api.access`. Super-Admin-Rechte in der API laufen über `api.super`. Die README behauptet noch, ein klassisches `admin.super` übergehe alle Rechteprüfungen. Laut Quelltext gilt die Abkürzung für Super-Admins aber nur für `api.super`, `admin.super` öffnet zusammen mit `api.access` lediglich die Endpunkte, die Super-Rechte verlangen.

Für den Alltag mit Agenten wichtig ist ein Detail: Schreibzugriffe laufen mit ETag und `If-Match`, der Agent schickt also die Versionskennung der Seite mit, die er zuletzt gelesen hat. Hat ein Mensch eine Seite inzwischen geändert, bekommt der Agent ein `409 Conflict` statt die Änderung still zu überschreiben, und Admin 2 meldet umgekehrt „Page was modified elsewhere". Dazu kommen HMAC-signierte Webhooks (Benachrichtigungen an andere Systeme, deren Echtheit eine Signatur belegt) und Rate-Limits (Obergrenzen für Anfragen) je Nutzer.

Einen Widerspruch gibt es bei den Key-Scopes, also Einschränkungen eines Schlüssels unter die Rechte seines Nutzers. Die MCP-Doku sagt noch: „Per-key permission scoping is not yet enforced independently of the user." Laut [Advisory zu CVE-2026-62667](https://github.com/getgrav/grav/security/advisories/GHSA-x7hm-jc32-v39j) (englisch) werden Scopes aber seit API 1.0.6 geprüft, und laut Changelog folgten ab 1.0.13 mehrere weitere Sicherheitsfixes genau dazu. Ich halte die Doku-Stelle für veraltet. Der CLI-Befehl `keys:generate` hat laut Quelltext keine Option für Scopes. Begrenzte Schlüssel entstehen über Admin 2 oder über den Zustimmungsdialog des Plugins `mcp-server` (siehe unten).

### Der offizielle MCP-Server: grav-mcp

Das dritte Versprechen ist der MCP-Server. Die Features-Seite formuliert: „Built-in Model Context Protocol server exposes the Grav API to agentic AI." Eingebaut ist er nicht. Der offizielle Server ist das npm-Paket `grav-mcp`, laut MCP-Doku ausdrücklich „not a Grav plugin: it runs inside your AI client". Du brauchst Node.js 18 oder neuer auf dem Rechner, auf dem dein KI-Client läuft, und der Server spricht von dort per HTTP mit dem API-Plugin deiner Site. Im Download-Paket von Grav 2.2.29 mit Admin 2 steckt kein MCP-Server, enthalten sind die Plugins `admin2`, `api`, `email`, `error`, `flex-objects`, `form`, `github-markdown-alerts`, `login`, `problems` und `shortcode-core` sowie das Theme Quark 2.

Die Einrichtung ist laut Doku kurz. Zuerst erzeugst du auf der Site einen Schlüssel:

```bash
# As in the docs; use a dedicated least-privilege user instead of admin (key shown only once)
bin/plugin api keys:generate --user=admin --name="Claude MCP"
```

Danach trägst du den Server in deinem Client ein, mit URL und Schlüssel als Umgebungsvariablen:

```json
{
  "mcpServers": {
    "grav": {
      "command": "npx",
      "args": ["-y", "grav-mcp"],
      "env": {
        "GRAV_API_URL": "https://my-site.example/api",
        "GRAV_API_KEY": "grav_..."
      }
    }
  }
}
```

Das Beispiel nutzt `--user=admin`, weil die Doku es so zeigt. Gleich danach rät dieselbe Doku: „Create a dedicated, least-privilege user for AI access rather than reusing your primary admin account." Genau so würde ich es auch machen.

Laut Doku bietet der Server „70 semantic tools across 11 domains". Im Quelltext von 0.1.5 stehen 70 Werkzeuge plus `refresh_plugin_tools`, verteilt auf Seiten, Mehrsprachigkeit, Medien, Konfiguration, Nutzer, Paketverwaltung, System, Dashboard, Webhooks, Blueprints und Plugin-Werkzeuge. Dazu kommen fünf Ressourcen und sechs vorgefertigte Prompts wie `create_blog_post` und `site_health_check`. Die Werkzeuge reichen weit: Unter der Paketverwaltung stehen `install_package`, `update_all_packages` und `upgrade_grav`. Nur sieben Werkzeuge tragen im Code den Hinweis `destructiveHint`, mit dem ein Client vor riskanten Aktionen warnen kann. `upgrade_grav`, `update_all_packages` und `update_config` gehören nicht dazu. Ich würde mich deshalb nicht auf Warnungen des Clients verlassen, sondern auf die Rechte des Nutzers.

Für Plugin-Entwickler interessant: Seit `grav-mcp` 0.1.2 kann ein Plugin seine API-Routen in einer Datei `mcp.yaml` beschreiben. Das API-Plugin liefert die Liste gefiltert nach den Rechten des Aufrufers, und `grav-mcp` macht daraus Werkzeuge mit dem Namen `<plugin>_<name>`. Als erstes Plugin nutzt das der Shop KahunaCart. Den deklarativen Ansatz finde ich elegant, weil ein Plugin damit keinen eigenen MCP-Code braucht.

Zum Reifegrad gehört die Versionsnummer. `grav-mcp` steht bei 0.1.5 vom 4. November 2026, die erste Version erschien laut npm am 5. Juli, also nach dem [Ankündigungsbeitrag](https://getgrav.org/blog/grav-2-mcp-server) (englisch) vom 31. Mai. Der Server kennt zwei Transportwege: stdio, bei dem der Client den Server als lokalen Prozess startet, und HTTP auf Port 3100. Laut Quelltext bindet der HTTP-Modus ohne Host-Angabe und ohne eigene Anmeldung, der API-Schlüssel gilt für den ganzen Prozess. Wer den Port erreicht, handelt also mit den Rechten dieses Schlüssels. Das habe ich nur gelesen und nicht getestet, eine Lücke behaupte ich damit nicht. Vor 0.1.5 brach der HTTP-Modus zudem beim zweiten Request ab, behoben ist das erst mit 0.1.5. Ein Plan von Andy Miller im Repository vom Juli, Status „Proposed, not started", nennt weitere offene Punkte und einen künftigen nativen MCP-Endpunkt im API-Plugin. Ich würde `grav-mcp` deshalb nur per stdio auf dem eigenen Rechner nutzen und den HTTP-Modus nicht offen ins Netz stellen.

### Die Alternative in der Site: das Plugin mcp-server

Gehostete Assistenten wie claude.ai oder ChatGPT können keinen lokalen Prozess starten, sie brauchen einen MCP-Endpunkt im Netz. Diesen Weg geht das Plugin [`mcp-server`](https://github.com/sandymac/grav-plugin-mcp-server) (englisch) von Sandy McArthur, installierbar mit `bin/gpm install mcp-server`, aktuell 1.11.3 vom 12. November 2026, MIT-lizenziert. Es läuft als echtes Grav-Plugin und stellt den Endpunkt unter `/mcp` bereit. Laut README bringt es einen OAuth-2.1-Server (OAuth ist ein Standard für Anmeldung und Zugriffsfreigabe) mit dynamischer Client-Registrierung mit, wie ihn gehostete Connectors erwarten, und einen Zustimmungsdialog, in dem du einzelne Rechte abwählst, bevor der Schlüssel entsteht. Voraussetzung sind Grav 2.1.5 und API-Plugin 1.1.12 oder neuer. Eine Sicherheitsbewertung des Plugins gibt es in diesem Artikel nicht. Es stammt von einem einzelnen externen Autor und bringt mit dem OAuth-Server eigenen, öffentlich erreichbaren Anmelde-Code mit, und es entwickelt sich schnell: Zwischen dem 3. und 12. November 2026 erschienen sechs Versionen, von 1.9.0 bis 1.11.3. Mit 1.11.3 kamen erneut zwei Sicherheitsfixes genau in diesem OAuth-Code, schon 1.4.1 hatte laut Changelog einen im Refresh-Ablauf. Mehr dazu im [Nachtrag vom 20. November](#nachtrag-vom-20-november). Wenn du es nutzt, halte es so aktuell wie das API-Plugin und lass im Zustimmungsdialog nur die Rechte stehen, die der Assistent wirklich braucht.

Das Plugin liegt nicht unter `getgrav/`, sondern im Konto des Autors. Ob Sandy McArthur zum Grav-Team gehört, habe ich nicht klären können. Die [/ai-Seite](https://getgrav.org/ai) (englisch) von Grav bewirbt einen „Built-in MCP Server" mit „One click to enable, no sidecar service to babysit" und schreibt „The MCP server ships with Grav." Ihr Link „How the MCP server works" führt aber zur Ankündigung von `grav-mcp`, also genau zu dem separaten Node-Paket.

### Marketing und Wirklichkeit

So sieht das für mich nebeneinander aus:

| Aussage der Website | Was Doku und Code sagen |
| --- | --- |
| „Built-in Model Context Protocol server" (Features-Seite) | Separates npm-Paket für Node.js, Version 0.1.5, nicht im Grav-Paket |
| „The MCP server ships with Grav." (/ai) | Im Download-Paket von 2.2.29 steckt kein MCP-Server, die Doku nennt `grav-mcp` „not a Grav plugin" |
| „One click to enable, no sidecar service to babysit" (/ai) | Für `grav-mcp` braucht es Node.js und eine Client-Konfiguration. Einen MCP-Schalter gibt es laut Quelltext weder in Admin 2 noch in Core oder API-Plugin |
| „Agents inherit exactly the permissions of the user account" (Features-Seite) | Stimmt laut Doku und Code, hängt aber am API-Plugin, das 2026 viele Sicherheitsfixes bekam |
| „full audit trail via Revisions Pro" (Features-Seite) | Revisions Pro ist ein Premium-Plugin. Laut MCP-Doku „The MCP server does not add its own audit log", das API-Plugin hat einen optionalen Audit-Trail, standardmäßig aus |
| Markdown für Agenten | Stimmt, im Core seit 2.1.0, standardmäßig an |

Mein Urteil: „AI ready" trifft auf die Markdown-Ausgabe und die API voll zu. „MCP ready" stimmt in dem Sinne, dass es einen offiziellen Server gibt. „Built-in" stimmt nicht, und ich würde mir wünschen, dass die Website das genauso klar sagt wie die eigene Doku.

### Im Vergleich zu WordPress

Im Artikel zu [Oxygen 6.2](https://www.jpkc.com/db/blog/oxygen-6-2-ki-agenten/) habe ich beschrieben, wie WordPress das löst: Abilities API und `wordpress/mcp-adapter`, der MCP-Server läuft in WordPress, und der Agent Connector arbeitet dort fest mit Super-Admin-Rechten. Grav geht den umgekehrten Weg. Der offizielle Server läuft außerhalb, dafür bekommt der Agent wirklich nur die Rechte eines Nutzers, den du anlegst. Für mich wiegt dieser Unterschied schwerer als die fehlende Ein-Klick-Lösung. Einen Agenten mit eng begrenzten Rechten auf eine echte Site zu lassen, kann ich mir bei Grav vorstellen, bei festen Super-Admin-Rechten nur auf Staging.

## Sicherheit

Eine Sicherheitsmeldung zu einer Software heißt Advisory, die CVE-Nummer ist ihre weltweit eindeutige Kennung. Zu Grav sind 2026 sehr viele solcher Meldungen erschienen. Ich ordne sie hier ein, weil sie für jede Entscheidung über Grav 2 zählen, und für Agenten erst recht.

### Die Zahlen

Das Repository [`getgrav/grav`](https://github.com/getgrav/grav/security/advisories) (englisch) führt am 20. November 219 Advisories zu Core und Plugins, davon 11 kritisch und 119 hoch. 184 davon stammen aus 2026. Dutzende betreffen allein das API-Plugin, also genau die Schnittstelle, über die Agenten arbeiten, zuletzt am 19. November das kritische GHSA-fqv4-9pm4-v2q2 (siehe [Nachtrag vom 20. November](#nachtrag-vom-20-november)).

Darunter sind Meldungen, die das Rechtemodell direkt betreffen. CVE-2026-62667 trägt den Titel „API Key 'scopes' Never Enforced", eingestuft als hoch und behoben in API 1.0.6, und noch am 5. November 2026 erschien GHSA-9g3m-8mr9-78vr, eingestuft als moderat: Von API 1.0.16 bis 1.1.10 konnte ein eingeschränkter Schlüssel die Rechteregeln einer Seite umgehen, behoben in 1.1.11. Gefixt wurde in beiden Fällen. Für mich folgt daraus: Die Aussage „Agenten erben genau die Rechte des Nutzers" gilt nur mit einem aktuellen API-Plugin.

### Von der Denylist zur Sandbox

Eine lange Geschichte hat die Server-Side Template Injection (SSTI), bei der jemand über Twig im Seiteninhalt PHP-Code auf dem Server ausführt. In 1.7 schützte eine Denylist, also eine Liste verbotener Funktionen. Im Juni 2023 kam CVE-2023-34251, kritisch, mit einem Beweis, bei dem ein Seiteneditor über Twig Systembefehle ausführte, behoben in 1.7.42. Im März 2024 folgten CVE-2024-28116 bis -28119, behoben in 1.7.45. Im Dezember 2025 beschrieb [CVE-2025-66299](https://github.com/getgrav/grav/security/advisories/GHSA-52hh-vxfw-p6rg) (englisch) ausdrücklich einen Weg um den Fix für CVE-2024-28116 herum. Jede Runde ergänzte die Liste, die nächste fand einen Umweg.

Grav 2 wechselt deshalb zu einer Sandbox mit Allowlist, die nur ausdrücklich erlaubte Funktionen zulässt. Die SECURITY.md nennt sie „the actual boundary" und stellt klar, dass die älteren Prüfungen nur Heuristiken sind. Auch diese Sandbox hatte Ausbrüche, etwa über `sort()` vor 2.0.18 oder über einen Filter, der bis 2.0.24 die komplette Konfiguration ausgab, und weitere, die erst 2.2.18 behob. Weil Twig im Inhalt seit 2.0.19 standardmäßig läuft, betrafen solche Ausbrüche auch Standardinstallationen. Den Wechsel zur Allowlist halte ich trotzdem für richtig. Eine Allowlist kannst du nachbessern, ohne jedes Mal einen neuen Umweg zu übersehen.

### KI auf beiden Seiten

Ende Oktober 2026 nahm Grav an Anthropics OSS Scanner teil, einem Programm, bei dem KI Open-Source-Code nach Lücken durchsucht. Laut [Blogbeitrag](https://getgrav.org/blog/oss-scanner-security-releases) (englisch) von Andy Miller kamen „99 findings, with 1 rated critical and 35 rated high", nach Prüfung blieben „22 security advisories: 1 critical, 18 high and 3 moderate". Grav 2.2.18 und 1.7.53.7 erschienen am 31. Oktober, am selben Abend 2.2.19 und 1.7.53.8. Beim Prüfen haben KI-Agenten laut Beitrag viel Arbeit übernommen, die Entscheidungen lagen bei ihm: „every call on what to fix and what to publish was mine."

Dazu muss ich offenlegen, dass auch ich mit KI von Anthropic arbeite. Bemerkenswert finde ich die Offenheit des Beitrags. Er räumt ein, dass ein Advisory vom August einen Fix in 2.0.16 gemeldet hatte, und schreibt: „It wasn't." Er warnt, dass die strengere Sandbox bestehende Seiten brechen kann, und dass Sites mit nginx, Caddy, lighttpd oder IIS die neuen Regeln aus `webserver-configs/` „by hand" übernehmen müssen. Wer Grav mit Caddy betreibt, wie im [FrankenPHP-Artikel](https://www.jpkc.com/db/blog/frankenphp-caddy/#grav) beschrieben, sollte das nach jedem Release prüfen. Das eine kritische Advisory dieser Runde erlaubte laut Beitrag anonymen Besuchern, über ein öffentliches Formular und Medien-Metadateien Serverdateien samt Konten und Geheimnissen zu lesen.

Wie wichtig die Server-Regeln sind, zeigte schon ein früherer Fall. Im September 2026 erschien [GHSA-5vx9-x8f2-f55w](https://github.com/getgrav/grav/security/advisories/GHSA-5vx9-x8f2-f55w) (englisch), ebenfalls kritisch: Mehrere mitgelieferte Server-Konfigurationen sperrten `.git` nur im Webroot, ein Repository wie `user/.git` war also anonym lesbar. Behoben ist das in 2.1.7. Für 1.7 kam der Fix erst gut fünf Wochen später, mit 1.7.53.8 am 31. Oktober.

### Die Regeln des Projekts

Die SECURITY.md bewertet Meldungen nach Vertrauensgrenze und nicht nach CVSS-Punktzahl (einer verbreiteten Skala für den Schweregrad): Wer als Publisher Twig in eigenen Seiten ausführt, tut laut Policy genau das, was ihm erlaubt ist. Bug-Bounties (Prämien für gemeldete Lücken) gibt es nicht, und das Projekt beantragt keine CVEs selbst. Die Unterstützungstabelle dort nennt noch „2.0.x" als aktiv, obwohl 2.2 aktuell ist. Das wirkt eher nicht nachgezogen als absichtlich.

Die Werbung im [Vergleich mit WordPress](https://getgrav.org/blog/grav-vs-wordpress) (englisch) lautet: „There's no database, so there's no SQL injection and no database password to leak." Für den Core stimmt das. Das optionale Plugin `database` hatte aber CVE-2026-58492, eine SQL-Injection. Ohne Datenbank verschiebt sich die Angriffsfläche auf Twig, YAML, Uploads und Dateipfade, verschwunden ist sie nicht.

### PHP2Shell betrifft Grav wie jede PHP-Site

Grav ist eine PHP-Anwendung, also gilt für sie alles aus dem [Artikel zu PHP2Shell](https://www.jpkc.com/db/blog/php2shell/). Der Hersteller hat dazu einen [eigenen Beitrag](https://getgrav.org/blog/php-critical-security-release-october-2026) (englisch) veröffentlicht: PHP aktualisieren und neu starten und übergangsweise `session.upload_progress.enabled = 0` setzen, denn „Grav doesn't use upload progress, so turning it off won't break your site". Dazu rät der Beitrag zu PHP-FPM (PHP als eigener Dienst) statt mod_php (PHP als Modul im Apache). Flat-File heißt eben nicht statisch, bei jedem nicht gecachten Aufruf läuft PHP.

### Wie ich ein Agenten-Setup aufsetzen würde

Aus all dem ergibt sich für mich eine kurze Liste. Sie ist eine Einschätzung aus Doku, Code und Advisories, kein erprobtes Rezept:

1. **Ein eigener Nutzer für den Agenten**, mit genau den Rechten, die die Aufgabe braucht, etwa `api.access` (Grundrecht für jeden API-Aufruf) plus `api.pages.read` und `api.pages.write`, bei Bildern zusätzlich `api.media`. Kein `api.gpm`, kein `api.system.backup`, weder `api.super` noch `admin.super`.
2. **Ein eigener Schlüssel je Agent**, mit Ablaufdatum. `keys:generate` kennt dafür laut API-Plugin die Option `--expiry` mit einer Zahl von Tagen.
3. **`grav-mcp` nur per stdio** auf dem eigenen Rechner. Den HTTP-Modus würde ich nicht offen erreichbar machen.
4. **Die API nicht offen ins Netz stellen, wo es geht.** Auch per stdio spricht `grav-mcp` über HTTP mit `/api` deiner Site. Diesen Pfad würde ich am Webserver auf bekannte IPs oder ein VPN beschränken, denn genau das API-Plugin betrafen 2026 Dutzende Advisories, zuletzt eines, das ohne Anmeldung ausnutzbar war.
5. **API-Plugin (mindestens 1.1.21), Grav und gegebenenfalls `mcp-server` (mindestens 1.11.3) immer aktuell halten.** Bei diesem Release-Tempo heißt das: mehrmals pro Woche nachsehen.
6. **Erst auf Staging oder lokal**, und Inhalte vorher in Git sichern. Bei Grav ist das leicht, weil alles Datei ist.

## Ökosystem und Kosten

Die Website zählt 548 Plugins, 140 Themes und 56 Skeletons, also fertige Startpakete. Der GPM-Index für Grav 2 listet 542 Plugins. Gelistet heißt aber nicht getestet: 312 davon machen keine Angabe zur Kompatibilität, und 287 hatten 2026 kein Release. Die Prüfung im Migrations-Plugin stützt sich vor allem auf diese Angabe. Ohne sie gilt ein Plugin im empfohlenen Modus „Strict" laut Quelltext als nur 1.7-tauglich und wird nicht mitgenommen. Erst im Modus „Permissive" übernimmt der Assistent auch Plugins ohne Angabe ungeprüft. Der Fehler geht also in die vorsichtige Richtung, du verlierst eher ein Plugin, als dass ein ungetestetes durchrutscht. Vor einem Umstieg würde ich deshalb jedes Plugin, das ich brauche, einzeln ansehen.

Ein paar Eckpunkte für Grav 2:

- **Admin:** Das klassische Admin gibt es nur für 1.7, für Grav 2 kommt Admin 2.
- **Theme:** Standard ist Quark 2. Laut [README](https://github.com/getgrav/grav-theme-quark2) (englisch) baut es auf Blades CSS v2 auf, dem gepflegten Nachfolger von Pico CSS, die Features-Seite nennt noch Pico CSS v2. Das alte Quark ist nur für 1.7 gelistet.
- **Git Sync** von Trilby Media synchronisiert den `user/`-Ordner mit GitHub, GitLab oder einem eigenen Git und unterstützt 1.7 und 2.0. Laut einem Advisory im Grav-Repository (GHSA-c89w-55m3-fmf7) hatte es im September 2026 eine Command Injection über Commit-Autoren, behoben in 3.4.13. Zum [Repository](https://github.com/trilbymedia/grav-plugin-git-sync) (englisch).
- **Statischer Export:** Das Plugin Static Generator hatte sein letztes Release 2023 und macht keine Angabe für Grav 2. Für einen statischen Export unter Grav 2 würde ich mich darauf nicht verlassen.

Der Kern ist kostenlos. Premium-Plugins kaufst du laut [Premium-Seite](https://getgrav.org/premium) (englisch) einmalig je Site, Entwicklungs- und Staging-Umgebungen zählen nicht mit. Für KI gibt es zwei: [AI Pro](https://getgrav.org/premium/ai-pro) (englisch) für 75 US-Dollar, eine Anbindung an OpenAI, Claude, Gemini, OpenRouter und eigene Anbieter mit Assistent im Admin, und [AI Translate](https://getgrav.org/premium/ai-translate) (englisch) für ebenfalls 75 US-Dollar, Übersetzung über DeepL, Google oder die Anbieter aus AI Pro. Mit MCP haben beide nichts zu tun. Neu ist seit 6. November 2026 [Grav Guard](https://getgrav.org/blog/introducing-grav-guard) (englisch), ein Dienst für Updates, Backups und Überwachung. Für bis zu drei Sites ist Guard kostenlos, mit Updates, die du selbst anstößt (vorher ein Backup, bei Fehlern automatisch rückgängig), Backups auf dem eigenen Server, Integritätsprüfung und Uptime-Check. Automatische Updates, Rollback auf Abruf, Rettung defekter Sites und externe Backups (Guard Vault) gibt es erst mit Premium für 2 US-Dollar je Site und Monat, mindestens drei Sites, ab der elften Site günstiger.

## Für wen Grav passt und für wen nicht

Gut passt Grav aus meiner Sicht für Dokumentationen, Knowledge Bases, Firmen- und Projektseiten, Blogs und kleinere Mehrsprachen-Sites, also überall dort, wo Inhalte in Markdown leben und Git der natürliche Arbeitsplatz ist. Wenn du KI-Agenten Inhalte lesen und pflegen lassen willst, ist Grav 2 durch Markdown-Ausgabe und echtes Rechtemodell aus meiner Sicht einer der interessanteren Kandidaten.

Wann es nicht passt, sagt Andy Miller im Vergleich mit WordPress erstaunlich offen selbst: „A large newsroom or multi-author publication with a heavy editorial workflow", „A site that depends on a specific WordPress plugin with no Grav equivalent" und „A client who will hire a different agency next year, and needs a platform any freelancer can pick up". Dazu schreibt er: „There's no one-click WordPress importer for Grav today, and I'd rather be upfront about that." Ich würde einen Punkt ergänzen: Grav 2 passt nicht, wenn niemand Updates zeitnah einspielt. Bei 72 Releases in rund fünf Monaten und so vielen Advisories ist das keine Nebensache.

Und wenn du gar kein PHP zur Laufzeit brauchst, kann auch ein statischer Generator mit Git-basiertem CMS die Lösung sein. Wie das mit 11ty aussieht, zeigt der Artikel zu [Sveltia CMS](https://www.jpkc.com/db/blog/sveltia-cms/).

## FAQ

### Hat Grav 2 einen eingebauten MCP-Server?

Nein. Der offizielle Server ist das npm-Paket `grav-mcp` 0.1.5, das neben deinem KI-Client unter Node.js läuft und über die API mit der Site spricht. Einen Endpunkt direkt in der Site bietet das Plugin `mcp-server` von Sandy McArthur, das nicht im Konto von getgrav liegt.

### Brauche ich für die Markdown-Ausgabe ein Plugin?

Nein. Seit Grav 2.1.0 beantwortet der Core `.md`-URLs und Anfragen mit `Accept: text/markdown`, standardmäßig an. Nur für die `llms.txt` brauchst du das Sitemap-Plugin ab 5.3.0.

### Welche Rechte hat ein KI-Agent in Grav?

Die des Nutzers, dem sein API-Key gehört. Ein Schlüssel kann laut Doku nie mehr als dieser Nutzer. Lege dafür einen eigenen Nutzer mit wenigen Rechten an und halte das API-Plugin aktuell, mindestens auf 1.1.21, denn genau dort gab es 2026 mehrere Fixes zu Schlüsselrechten und zuletzt einen kritischen zur Übernahme von Konten.

### Kann ich Grav 1.7 direkt auf 2.0 aktualisieren?

Nicht als Update über die bestehende Installation. Das Plugin „Migrate to Grav 2.0" baut eine frische Version im Unterordner auf, kopiert deinen `user/`-Ordner und lässt dich testen, bevor du umschaltest. Deine Markdown-Inhalte brauchen keine Konvertierung, Templates und Plugins musst du prüfen.

### Braucht Grav wirklich keine Datenbank?

Einen Datenbankserver braucht Grav nicht. Seit 2.2 legt es für Sites ab 1.000 Seiten aber standardmäßig einen Seitenindex an, in SQLite über pdo_sqlite. Ersatzweise läuft er mit der reinen PHP-Engine YetiSQL aus dem Plugin `database-yetisql`. Fehlen beide, nutzt Grav den alten Cache.

### Läuft Grav mit FrankenPHP?

Ja. Mit welchen Anpassungen am mitgelieferten Caddyfile und welchen PHP-Erweiterungen, steht im [Artikel zu FrankenPHP und Caddy](https://www.jpkc.com/db/blog/frankenphp-caddy/#grav). Dort geprüft ist nur Grav-Core ohne Admin im klassischen Modus.

## Fazit

Aus meiner Sicht ist Grav 2 der größte Schritt des Projekts seit Version 1.0: neuer Stack, neues Admin über eine echte API und eine Template-Sandbox, die aus Jahren mit Denylist-Fixes die richtige Lehre zieht. Für KI ist die Markdown-Ausgabe im Core das Stück, das heute schon voll trägt, und das Rechtemodell der API gefällt mir besser als die festen Super-Admin-Rechte, die ich im Oxygen-Artikel beschrieben habe. Der MCP-Server ist offiziell, aber jung, extern und nicht so eingebaut, wie die Website sagt.

Ich bleibe Fan. Wenn du mit Grav 2 und Agenten arbeiten willst, würde ich dir raten: nimm die Markdown-Ausgabe sofort mit, gib Agenten eigene, eng begrenzte Nutzer, und plane Updates als festen Teil des Betriebs ein.

Bei diesem Artikel hat mich Claude Code bei Erstellung, Korrektur und Verifikation unterstützt. Die Vorgaben und die redaktionelle Verantwortung liegen bei mir. Mehr dazu auf der Seite zur [KI-Transparenz](https://www.jpkc.com/db/ki-transparenz/).

## Weiterlesen

Wie Grav mit FrankenPHP und Caddy läuft, steht im [Artikel zu FrankenPHP und Caddy](https://www.jpkc.com/db/blog/frankenphp-caddy/), die Befehle für `bin/grav` und `bin/gpm` im [Cheat-Sheet zu Grav](https://www.jpkc.com/db/cheatsheets/build-languages/grav/), die Direktiven im Cheat-Sheet zu [FrankenPHP](https://www.jpkc.com/db/cheatsheets/web-servers/frankenphp/). Wie ein MCP-Server mit Super-Admin-Rechten in WordPress aussieht, zeigt [Oxygen 6.2](https://www.jpkc.com/db/blog/oxygen-6-2-ki-agenten/). Was in Markdown für KI-Systeme gehört, beschreibt [Schreiben für KI](https://www.jpkc.com/db/blog/schreiben-fuer-ki/), warum diese Seite statisch und mit Markdown-Zwillingen läuft, [Warum 11ty](https://www.jpkc.com/db/blog/warum-11ty/). Was bei PHP2Shell zu tun ist, erklärt [der Artikel dazu](https://www.jpkc.com/db/blog/php2shell/).

