realmaker LocalFonts – MCP Server für KI Agenten

KI-Agenten bauen heute Websites in Minuten – aber sie binden Google Fonts per CDN ein. Das ist ein DSGVO-Verstoß. Mit realmaker LocalFonts haben wir einen MCP-Server entwickelt, der KI-Coding-Assistenten befähigt, Google Fonts automatisch herunterzuladen und lokal in Webprojekte einzubinden. Datenschutzkonform, vollautomatisch, ohne dass der Entwickler einen einzigen Font manuell anfassen muss.

Das neue Problem: KI-Agenten und Google Fonts

Die Art, wie Websites entstehen, hat sich fundamental verändert. KI-gestützte Coding-Assistenten generieren heute ganze Webprojekte in Minuten – Frontend, Backend, Styling, alles. Was früher Tage dauerte, passiert jetzt in einer einzigen Prompt-Session.

Aber es gibt ein Problem, das dabei fast immer übersehen wird: KI-Agenten binden Google Fonts standardmäßig per CDN ein. In nahezu jedem generierten CSS steht eine Zeile wie diese:

@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap');

Für den KI-Agenten ist das die einfachste Lösung – ein Einzeiler, funktioniert sofort, sieht gut aus. Aber für den deutschen Rechtsraum ist es eine Zeitbombe. Denn bei jeder Einbindung werden Nutzerdaten an Google-Server in den USA übermittelt: IP-Adresse, Browser-Informationen, Zugriffszeit. Ohne Einwilligung. Ohne Rechtsgrundlage.

Und das passiert nicht einmal, sondern bei jedem einzelnen Seitenaufruf. Tausende von Websites, generiert von KI-Agenten, gehen mit eingebautem DSGVO-Verstoß live – weil der Entwickler dem Agenten vertraut hat und die Font-Einbindung nicht manuell geprüft hat.

Genau dieses Problem hat uns motiviert, realmaker LocalFonts zu entwickeln. Nicht als weiteres Font-Hosting-Tool. Sondern als MCP-Server, der KI-Agenten beibringt, Fonts richtig einzubinden – lokal, datenschutzkonform, automatisch.

Kurzer Rückblick: Das LG-München-Urteil

Für alle, die den Hintergrund kennen möchten: Am 20. Januar 2022 hat das Landgericht München I (Az. 3 O 17493/20) ein wegweisendes Urteil gefällt. Ein Website-Betreiber wurde zur Zahlung von 100 Euro Schadensersatz verurteilt – weil er Google Fonts direkt von Google-Servern eingebunden hatte, ohne Einwilligung der Besucher.

Was danach kam, war eine regelrechte Abmahnwelle. Tausende Website-Betreiber erhielten Abmahnungen, oft mit Forderungen zwischen 150 und 500 Euro. Das Urteil hat unmissverständlich klargestellt: Wer Google Fonts per CDN einbindet, verstößt gegen Artikel 6 Abs. 1 DSGVO.

Die Lösung war bekannt: Fonts lokal hosten. Was für einen einzelnen Entwickler machbar ist – herunterladen, @font-face schreiben, auf den Server laden – wird bei KI-generierten Projekten zum Massenproblem. Denn der KI-Agent weiß nichts von DSGVO, LG München oder Abmahnrisiken. Er kennt nur den Code aus seinen Trainingsdaten.

Die Ironie: Wir haben die Werkzeuge, um Websites schneller zu bauen als je zuvor. Aber diese Werkzeuge produzieren standardmäßig Code, der in Deutschland rechtswidrig ist. Das musste sich ändern.

Was ist ein MCP-Server?

Bevor wir in die Details von LocalFonts einsteigen, kurz zum Konzept: MCP steht für Model Context Protocol – ein offener Standard, der es KI-Agenten ermöglicht, externe Dienste und Tools zu nutzen.

Stellen Sie sich das so vor: Ein KI-Coding-Assistent kann von Haus aus Text generieren, Code schreiben, Dateien lesen und bearbeiten. Aber er kann nicht selbstständig im Internet suchen, keine APIs aufrufen und keine spezialisierten Werkzeuge nutzen – es sei denn, man gibt ihm welche. Genau das macht MCP.

Ein MCP-Server stellt dem KI-Agenten spezialisierte Tools zur Verfügung. Im Fall von realmaker LocalFonts sind das Tools zum Suchen, Herunterladen und Einbinden von Schriftarten. Der Agent kann diese Tools bei Bedarf aufrufen – genau wie ein Handwerker, der zum richtigen Werkzeug greift.

realmaker LocalFonts: So funktioniert es

Das Konzept von LocalFonts ist elegant in seiner Einfachheit:

1. Der KI-Agent braucht eine Schriftart für ein Webprojekt
2. Statt einen Google-Fonts-CDN-Link zu generieren, ruft er das LocalFonts-MCP-Tool auf
3. Das Tool liefert: Download-Befehle für die Font-Dateien, fertiges CSS mit lokalen Pfaden und eine HTML-Einbindung
4. Der Agent führt die Befehle aus: Fonts werden direkt ins Projekt heruntergeladen
5. Ergebnis: Die Schriftarten liegen lokal im Projektordner – kein externer Server, kein Google-Kontakt, DSGVO-konform

Der entscheidende Punkt: Die Fonts werden nicht von fonts.realmaker.de ausgeliefert. Unser Server ist ein Vermittler – er kennt den kompletten Google-Fonts-Katalog, weiß welche Weights und Formate verfügbar sind, und gibt dem KI-Agenten die Werkzeuge an die Hand, um die Fonts lokal einzurichten. Am Ende liegen die woff2-Dateien im Projekt des Entwicklers, nicht auf unserem Server.

Die sechs MCP-Tools im Detail

Der MCP-Server stellt KI-Agenten sechs spezialisierte Tools zur Verfügung. Jedes Tool hat eine klar definierte Aufgabe – vom Durchstöbern des Katalogs bis zur kompletten Installation:

1. search_fonts – Schriftarten finden

   Durchsucht den Katalog mit 1.600+ Schriftarten nach Name, Kategorie (sans-serif, serif, monospace, display, handwriting) oder Stil. Liefert eine übersichtliche Liste passender Fonts mit allen verfügbaren Varianten. Perfekt, wenn der Agent eine passende Schriftart auswählen soll.

2. get_font_css – CSS generieren

   Generiert produktionsfertiges @font-face CSS für die gewünschte Schriftart – mit lokalen Dateipfaden statt CDN-URLs. Der Agent kann Weights, Styles und das gewünschte Format angeben. Das CSS ist sofort einsatzbereit, mit korrekten relativen Pfaden zwischen CSS-Ordner und Font-Verzeichnis.

3. download_font – Download-URLs und Befehle

   Liefert alle Download-URLs und fertige curl-Befehle für die gewünschten Font-Dateien. Der Agent erhält ein komplettes Bash-Skript, das er direkt ausführen kann – mkdir für den Ordner, curl für jede Datei. Unterstützt woff2, woff und ttf.

4. install_font – Alles in einem Schritt

   Das mächtigste Tool: Kombiniert Download-Befehle, @font-face CSS und HTML-Einbindung in einer einzigen Antwort. Der Agent bekommt alles, was er braucht, um eine Schriftart komplett in ein Projekt zu integrieren. Inklusive korrekter Pfadberechnung zwischen CSS- und Font-Verzeichnis.

5. get_font_link – HTML-Link-Tag

   Generiert ein fertiges HTML-Link-Tag zur Einbindung im Head-Bereich. Nützlich, wenn der Agent schnell eine Referenz braucht, ohne die komplette Installation durchzuführen.

6. list_popular_fonts – Beliebte Schriftarten

   Zeigt die meistgenutzten Fonts, sortiert nach Beliebtheit. Hilft dem Agenten bei der Auswahl, wenn keine spezifische Schriftart vorgegeben ist – er kann dem Nutzer die Top-Fonts empfehlen.

Das install_font-Tool ist dabei der Star. Ein einziger Aufruf und der Agent hat alles, was er braucht:

Was install_font zurueckliefert

install_font Response
├── Step 1: Download-Befehle
│   ├── mkdir -p assets/fonts/roboto
│   ├── curl -s -o roboto/400-normal.woff2 [URL]
│   ├── curl -s -o roboto/600-normal.woff2 [URL]
│   └── curl -s -o roboto/700-normal.woff2 [URL]
├── Step 2: Fertiges @font-face CSS
│   ├── @font-face (400, normal, woff2)
│   ├── @font-face (600, normal, woff2)
│   └── @font-face (700, normal, woff2)
│   └── Pfade relativ: ../fonts/roboto/400-normal.woff2
└── Step 3: HTML-Einbindung
    └── <link rel="stylesheet" href="css/fonts.css">

Der Workflow: Vom Prompt zur lokalen Schriftart

Schauen wir uns den konkreten Ablauf an. Ein Entwickler sagt seinem KI-Assistenten: „Erstelle mir eine Landing-Page mit der Schriftart Inter.“

Ohne LocalFonts (der riskante Weg)

Der KI-Agent generiert eine HTML-Datei. Im Head steht:

<!-- KI-Agent generiert standardmäßig einen CDN-Link -->
<link rel="stylesheet"
  href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap">

Die Seite sieht gut aus. Die Schrift lädt. Alles funktioniert. Aber: Jeder Besucher sendet seine IP-Adresse an Google. Der Entwickler hat das vielleicht gar nicht bemerkt, weil der KI-Agent die Entscheidung getroffen hat. Die Website geht live – mit eingebautem DSGVO-Verstoß.

Mit LocalFonts (der sichere Weg)

Der KI-Agent erkennt, dass er das LocalFonts-MCP-Tool nutzen kann. Er ruft install_font auf:

# Was der KI-Agent im Hintergrund macht:

# 1. Font-Dateien herunterladen
mkdir -p assets/fonts/inter
curl -s -o "assets/fonts/inter/400-normal.woff2" "https://fonts.realmaker.de/v1/font/inter/400-normal.woff2"
curl -s -o "assets/fonts/inter/600-normal.woff2" "https://fonts.realmaker.de/v1/font/inter/600-normal.woff2"
curl -s -o "assets/fonts/inter/700-normal.woff2" "https://fonts.realmaker.de/v1/font/inter/700-normal.woff2"

Dann schreibt der Agent das CSS – nicht mit CDN-URLs, sondern mit lokalen Pfaden:

/* Generiert vom KI-Agent via LocalFonts MCP – DSGVO-konform */
@font-face {
  font-family: 'Inter';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url('../fonts/inter/400-normal.woff2') format('woff2');
}

@font-face {
  font-family: 'Inter';
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url('../fonts/inter/600-normal.woff2') format('woff2');
}

@font-face {
  font-family: 'Inter';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url('../fonts/inter/700-normal.woff2') format('woff2');
}

Die Dateistruktur im Projekt sieht danach so aus:

Projektstruktur nach install_font

mein-webprojekt/
├── index.html
├── assets/
│   ├── css/
│   │   ├── style.css
│   │   └── fonts.css          ← @font-face Deklarationen
│   └── fonts/
│       └── inter/
│           ├── 400-normal.woff2  ← Lokal heruntergeladen
│           ├── 600-normal.woff2  ← Lokal heruntergeladen
│           └── 700-normal.woff2  ← Lokal heruntergeladen
└── ...

Kein einziger externer Request. Die Schriftarten liegen physisch im Projektordner. Wenn die Website online geht, lädt der Browser die Fonts vom eigenen Server. Google erfährt nichts. Der Besucher ist geschützt. Der Betreiber ist rechtssicher.

1.600+ Fonts im Katalog

realmaker LocalFonts spiegelt den kompletten Google-Fonts-Katalog – alle 1.600+ Schriftfamilien in allen verfügbaren Weights und Stilen. Der Katalog synchronisiert sich täglich automatisch. Wenn Google eine neue Schriftart veröffentlicht, ist sie innerhalb von 24 Stunden bei uns verfügbar.

Die Fonts werden lazy heruntergeladen – erst wenn ein Agent eine bestimmte Schriftart zum ersten Mal anfragt, wird sie von Google geholt, verarbeitet und gecacht. Ab dem zweiten Aufruf liegt sie direkt bereit. So belegen nur die tatsächlich nachgefragten Fonts Speicherplatz auf dem Server.

Der User-Agent-Trick

Ein technisches Detail, das Font-Nerds freuen wird: Google Fonts liefert unterschiedliche Formate je nach Browser. Um die optimalen woff2-Dateien zu bekommen, simuliert unser Server einen modernen Chrome-Browser. Für woff-Dateien wird ein älterer Firefox verwendet, für ttf ein Android-Browser. So bekommen wir immer exakt das gewünschte Format – ohne Kompromisse.

Die REST-API für Entwickler

Neben der MCP-Integration bietet LocalFonts auch eine klassische REST-API. Für Entwickler, die Fonts in ihre eigenen Tools, Build-Pipelines oder Workflows integrieren möchten:

# Schnell einen API-Key erstellen (anonym, keine E-Mail nötig)
curl -X POST https://fonts.realmaker.de/v1/register
# → {"api_key": "rf_a1b2c3...", "tier": "free", "daily_limit": 100}

# Font-Katalog durchsuchen
curl "https://fonts.realmaker.de/v1/fonts?search=inter&category=sans-serif"

# CSS generieren (mit lokalen Pfaden)
curl "https://fonts.realmaker.de/v1/css?family=Inter&weights=400,600,700&local_paths=true&api_key=rf_..."

# Einzelne Font-Datei herunterladen
curl -o inter-400-normal.woff2 "https://fonts.realmaker.de/v1/font/inter/400-normal.woff2?api_key=rf_..."

Technik unter der Haube

Für die Technik-Interessierten: So ist realmaker LocalFonts aufgebaut.

Architektur

realmaker LocalFonts
├── MCP-Server (JSON-RPC 2.0)
│   ├── Session-Management
│   ├── 6 spezialisierte Tools
│   └── API-Key-Validierung pro Tool
├── REST-API (Slim 4 Framework)
│   ├── /v1/fonts (Katalog-Suche)
│   ├── /v1/css (CSS-Generierung)
│   ├── /v1/font/ (Font-Download)
│   ├── /v1/register (Registrierung)
│   └── /v1/account (Nutzung)
├── Middleware-Chain
│   ├── CORS (Preflight-Handling)
│   ├── Auth (API-Key-Validierung, SHA256)
│   ├── Rate-Limiting (tagliches Kontingent)
│   └── Usage-Logging (Analytics)
├── Services
│   ├── GoogleFontsSync (Katalog-Sync)
│   ├── GoogleFontFetcher (CSS parsen + Download)
│   ├── FontDownloader (Lazy-Loading)
│   └── CssGenerator (@font-face Erstellung)
├── Storage
│   ├── /fonts/ (gecachte Font-Dateien)
│   ├── /cache/ (File-basierter Cache)
│   └── /logs/ (Monolog)
└── Datenbank (MySQL 8)
    ├── fonts (1.600+ Eintraege)
    ├── font_variants (Weights, Styles, Formate)
    ├── users + api_keys
    └── usage_log + font_requests

Die gesamte Infrastruktur läuft auf einem einzigen VPS – kein Redis, kein komplexes Cloud-Setup. PHP-FPM und Nginx reichen völlig aus. Das macht LocalFonts nicht nur schnell, sondern auch einfach zu warten und günstig zu betreiben.

Pakete und Preise

Ein Dienst, der DSGVO-Probleme löst, sollte selbst keine Hürden aufbauen. Deshalb ist der Free-Plan dauerhaft kostenlos – mit echtem Mehrwert, nicht als künstlich beschränkte Testversion.

Einrichtung in 2 Minuten

Den MCP-Server mit Ihrem KI-Coding-Assistenten zu verbinden, dauert keine 2 Minuten. So geht’s:

1. API-Key erstellen

   Registrieren Sie sich auf fonts.realmaker.de – anonym, ohne E-Mail, kostenlos. Sie bekommen sofort einen API-Key (beginnt mit rf_). Alternativ per Terminal: curl -X POST https://fonts.realmaker.de/v1/register

2. MCP-Server verbinden

   Fuegen Sie den MCP-Server zu Ihrem KI-Coding-Assistenten hinzu. Der Befehl sieht je nach Tool unterschiedlich aus, aber das Prinzip ist immer gleich: MCP-URL und API-Key angeben. Ab sofort hat Ihr Agent Zugriff auf alle LocalFonts-Tools.

3. Fonts einbinden lassen

   Ab jetzt kann Ihr KI-Agent bei jedem neuen Webprojekt automatisch lokale Fonts einbinden. Sagen Sie einfach: ‚Verwende die Schriftart Montserrat‘ – der Agent nutzt das install_font-Tool, laedt die Dateien herunter und bindet sie lokal ein. Kein manuelles Eingreifen noetig.

Fazit: Die Zukunft der Font-Integration ist automatisiert

KI-gestützte Webentwicklung ist keine Zukunftsmusik – sie ist Realität. Millionen von Websites werden heute mit Hilfe von KI-Agenten erstellt. Aber solange diese Agenten standardmäßig Google Fonts per CDN einbinden, entstehen millionenfach DSGVO-Verstöße. Manuell nachbessern? Funktioniert bei einem Projekt. Aber nicht bei zehn, zwanzig oder hundert.

realmaker LocalFonts löst dieses Problem an der Wurzel. Nicht indem es den Entwickler zwingt, etwas zu tun – sondern indem es dem KI-Agenten beibringt, es richtig zu machen. Der Agent sucht die passende Schriftart, lädt sie herunter, schreibt das CSS mit lokalen Pfaden und bindet alles korrekt ein. Vollautomatisch. DSGVO-konform. Ohne dass der Entwickler einen einzigen Font manuell anfassen muss.

Das Ziel war nicht, ein weiteres Font-Hosting-Tool zu bauen. Das Ziel war, KI-Agenten datenschutzkonform zu machen – beim Thema Fonts, automatisch, von Anfang an.

Michael Rademacher, Gründer realmaker

Und das Beste: Sie können sofort loslegen. Kostenlos, ohne E-Mail, ohne Kreditkarte. 100 Requests pro Tag, der komplette Google-Fonts-Katalog, alle sechs MCP-Tools. Registrieren Sie sich, verbinden Sie den MCP-Server und lassen Sie Ihren KI-Agenten von jetzt an Fonts richtig einbinden.

Jetzt kostenlos starten · Fragen? Kontaktieren Sie uns

realmaker LocalFonts ist ein Produkt von realmaker – Ihrer Kreativagentur für Film, Web und KI-Lösungen.