realmaker LocalFonts – MCP Server for AI Agents

AI agents build websites in minutes today – but they embed Google Fonts via CDN. That is a GDPR violation. With realmaker LocalFonts, we developed an MCP server that enables AI coding assistants to automatically download Google Fonts and integrate them locally into web projects. Privacy-compliant, fully automatic, without the developer ever having to touch a single font manually.

The new problem: AI agents and Google Fonts

The way websites are made has changed fundamentally. AI-powered coding assistants now generate entire web projects in minutes – frontend, backend, styling, everything. What used to take days now happens in a single prompt session.

But there is a problem that almost always gets overlooked: AI agents embed Google Fonts via CDN by default. Almost every generated stylesheet contains a line like this:

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

For the AI agent, that is the easiest solution – a one-liner, works immediately, looks good. But under German law it is a time bomb. Every time the font is embedded, user data is transmitted to Google servers in the USA: IP address, browser information, time of access. Without consent. Without a legal basis.

And that doesn’t happen just once, but on every single page view. Thousands of websites generated by AI agents go live with a built-in GDPR violation – because the developer trusted the agent and didn’t check the font embedding manually.

This very problem motivated us to develop realmaker LocalFonts. Not as yet another font hosting tool. But as an MCP server that teaches AI agents to embed fonts correctly – locally, in compliance with privacy law, automatically.

A quick look back: the Munich court ruling

For anyone who wants the background: on January 20, 2022, the Munich Regional Court I (Landgericht München I, case no. 3 O 17493/20) handed down a landmark ruling. A website operator was ordered to pay 100 euros in damages – because he had embedded Google Fonts directly from Google servers without the visitors’ consent.

What followed was a veritable wave of formal cease-and-desist warnings (Abmahnungen). Thousands of website operators received warnings, often with demands between 150 and 500 euros. The ruling made it unmistakably clear: Anyone who embeds Google Fonts via CDN violates Article 6(1) GDPR.

The solution was known: host fonts locally. What is doable for a single developer – download, write @font-face, upload to the server – becomes a mass problem with AI-generated projects. Because the AI agent knows nothing about the GDPR, the Munich ruling or the risk of warnings. It only knows the code from its training data.

The irony: We have the tools to build websites faster than ever. But by default, these tools produce code that is unlawful in Germany. That had to change.

What is an MCP server?

Before we get into the details of LocalFonts, a quick word on the concept: MCP stands for Model Context Protocol – an open standard that allows AI agents to use external services and tools.

Think of it like this: an AI coding assistant can generate text, write code, and read and edit files out of the box. But it can’t search the internet on its own, call APIs or use specialized tools – unless you give it some. That is exactly what MCP does.

An MCP server provides the AI agent with specialized tools. In the case of realmaker LocalFonts, these are tools for searching, downloading and embedding fonts. The agent can call these tools when needed – just like a craftsman reaching for the right tool.

realmaker LocalFonts: how it works

The concept behind LocalFonts is elegant in its simplicity:

1. The AI agent needs a font for a web project
2. Instead of generating a Google Fonts CDN link, it calls the LocalFonts MCP tool
3. The tool returns: download commands for the font files, ready-made CSS with local paths and an HTML embed
4. The agent runs the commands: fonts are downloaded directly into the project
5. Result: the fonts are stored locally in the project folder – no external server, no contact with Google, GDPR-compliant

The crucial point: The fonts are not served from fonts.realmaker.de. Our server is an intermediary – it knows the complete Google Fonts catalog, knows which weights and formats are available, and gives the AI agent the tools to set up the fonts locally. In the end, the woff2 files sit in the developer’s project, not on our server.

The six MCP tools in detail

The MCP server gives AI agents six specialized tools. Each tool has a clearly defined job – from browsing the catalog to complete installation:

1. search_fonts – find fonts

   Searches the catalog of 1,600+ fonts by name, category (sans-serif, serif, monospace, display, handwriting) or style. Returns a clear list of matching fonts with all available variants. Perfect when the agent has to choose a suitable font.

2. get_font_css – generate CSS

   Generates production-ready @font-face CSS for the desired font – with local file paths instead of CDN URLs. The agent can specify weights, styles and the desired format. The CSS is ready to use immediately, with correct relative paths between the CSS folder and the font directory.

3. download_font – download URLs and commands

   Returns all download URLs and ready-made curl commands for the desired font files. The agent receives a complete bash script it can run directly – mkdir for the folder, curl for each file. Supports woff2, woff and ttf.

4. install_font – everything in one step

   The most powerful tool: it combines download commands, @font-face CSS and HTML embed in a single response. The agent gets everything it needs to integrate a font into a project completely. Including correct path calculation between the CSS and font directories.

5. get_font_link – HTML link tag

   Generates a ready-made HTML link tag for embedding in the head section. Useful when the agent quickly needs a reference without running the complete installation.

6. list_popular_fonts – popular fonts

   Shows the most-used fonts, sorted by popularity. Helps the agent choose when no specific font is given – it can recommend the top fonts to the user.

The install_font tool is the star. A single call and the agent has everything it needs:

What install_font returns

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">

The workflow: from prompt to local font

Let’s look at the actual process. A developer tells their AI assistant: “Create a landing page with the Inter font.”

Without LocalFonts (the risky way)

The AI agent generates an HTML file. The head contains:

<!-- 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">

The page looks good. The font loads. Everything works. But: Every visitor sends their IP address to Google. The developer may not even have noticed, because the AI agent made the decision. The website goes live – with a built-in GDPR violation.

With LocalFonts (the safe way)

The AI agent recognizes that it can use the LocalFonts MCP tool. It calls install_font:

# 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"

Then the agent writes the CSS – not with CDN URLs, but with local paths:

/* 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');
}

The file structure in the project then looks like this:

Project structure after 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
└── ...

Not a single external request. The fonts are physically in the project folder. When the website goes online, the browser loads the fonts from your own server. Google learns nothing. The visitor is protected. The operator is legally safe.

1,600+ fonts in the catalog

realmaker LocalFonts mirrors the complete Google Fonts catalog – all 1,600+ font families in all available weights and styles. The catalog synchronizes automatically every day. When Google publishes a new font, it is available with us within 24 hours.

The fonts are downloaded lazily – only when an agent requests a particular font for the first time is it fetched from Google, processed and cached. From the second request on, it is ready right away. That way, only the fonts that are actually requested take up storage space on the server.

The user-agent trick

A technical detail that font nerds will enjoy: Google Fonts delivers different formats depending on the browser. To get the optimal woff2 files, our server simulates a modern Chrome browser. For woff files an older Firefox is used, for ttf an Android browser. That way we always get exactly the desired format – without compromises.

The REST API for developers

In addition to the MCP integration, LocalFonts also offers a classic REST API. For developers who want to integrate fonts into their own tools, build pipelines or workflows:

# 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_..."

Technology under the hood

For the technically curious: this is how realmaker LocalFonts is built.

Architecture

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

The entire infrastructure runs on a single VPS – no Redis, no complex cloud setup. PHP-FPM and Nginx are completely sufficient. That makes LocalFonts not only fast, but also easy to maintain and inexpensive to run.

Plans and pricing

A service that solves GDPR problems shouldn’t put up hurdles itself. That’s why the Free plan is free permanently – with real value, not as an artificially limited trial version.

Set up in 2 minutes

Connecting the MCP server to your AI coding assistant takes less than 2 minutes. Here’s how:

1. Create an API key

   Register at fonts.realmaker.de – anonymous, no email, free. You get an API key immediately (it starts with rf_). Alternatively via terminal: curl -X POST https://fonts.realmaker.de/v1/register

2. Connect the MCP server

   Add the MCP server to your AI coding assistant. The command looks different depending on the tool, but the principle is always the same: provide the MCP URL and API key. From now on, your agent has access to all LocalFonts tools.

3. Have fonts embedded

   From now on, your AI agent can automatically embed local fonts in every new web project. Just say: ‘Use the Montserrat font’ – the agent uses the install_font tool, downloads the files and embeds them locally. No manual intervention needed.

Conclusion: the future of font integration is automated

AI-assisted web development is not a vision of the future – it is reality. Millions of websites are created with the help of AI agents today. But as long as these agents embed Google Fonts via CDN by default, GDPR violations arise by the million. Fix them manually? Works for one project. But not for ten, twenty or a hundred.

realmaker LocalFonts solves this problem at the root. Not by forcing the developer to do something – but by teaching the AI agent to do it right. The agent searches for the suitable font, downloads it, writes the CSS with local paths and embeds everything correctly. Fully automatic. GDPR-compliant. Without the developer ever having to touch a single font manually.

The goal was never to build yet another font hosting tool. The goal was to make AI agents privacy-compliant – when it comes to fonts, automatically, from the start.

Michael Rademacher, Founder of realmaker

And the best part: you can get started right away. Free, no email, no credit card. 100 requests per day, the complete Google Fonts catalog, all six MCP tools. Register, connect the MCP server and let your AI agent embed fonts correctly from now on.

Get started for free · Questions? Contact us

realmaker LocalFonts is a product by realmaker – your creative agency for film, web and AI solutions.