Was ist llms.txt? — Format, Inhalt und dynamische Generierung vollständig erklärt[LLMO-Massnahme]

Das Zeitalter der KI-Suche ist angebrochen. ChatGPT-Websuche, Perplexity, Google AI Overviews — die Zahl der Nutzer, die Informationen über KI beziehen, wächst rasant. Dadurch wird es immer wichtiger, dass KI-Systeme Ihre Website korrekt verstehen.

Genau dafür wurde llms.txt geschaffen. Wenn robots.txt die Datei ist, die Suchmaschinen-Crawlern wie Googlebot mitteilt „diese Seite darf/darf nicht gecrawlt werden“, dann ist llms.txt die Datei, die KI-Crawlern wie GPTBot oder ClaudeBot sagt: „Das ist unsere Website und das bieten wir an“.

Dieser Artikel erklärt umfassend das Format von llms.txt, welche Informationen eingetragen werden sollten, die Entscheidungskriterien zwischen statischer und dynamischer Generierung sowie Implementierungscode für gängige Frameworks.

1. Was ist llms.txt?

llms.txt ist eine Klartextdatei im Markdown-Format, die im Stammverzeichnis einer Website platziert wird. Ihr Zweck ist es, LLMs (Large Language Models) eine Übersicht über Inhalt, Struktur und Angebot der Website zu vermitteln.

Grundlegende Informationen

Kurz gesagt

robots.txt = „Zutritt verboten“ / llms.txt = „Das ist unsere Website“

Während robots.txt eine Zugriffskontrolle darstellt (erlauben/verbieten), ist llms.txt eine Inhaltsbeschreibung (Selbstvorstellung). Beide stehen nicht im Widerspruch zueinander — sie sind vielmehr dazu gedacht, zusammen eingesetzt zu werden.

2. Warum wird es gebraucht? — Unterschied zu robots.txt

„Reichen Sitemap und Meta-Tags nicht aus, damit auch KI die Website versteht?“ — ein berechtigter Gedanke. Doch llms.txt bietet eigene Vorteile.

Rollenvergleich: robots.txt / sitemap.xml / llms.txt

Drei Gründe, warum llms.txt nötig ist

Grund 1: LLMs können eine Website nicht effizient vollständig crawlen

Der Googlebot crawlt Milliarden von Seiten und baut einen riesigen Index auf, doch LLM-Crawler arbeiten nicht annähernd so umfassend. Mit llms.txt kann man der KI effizient mitteilen: „Das sind die wichtigsten Inhalte unserer Website.“

Grund 2: Die Chance steigt, in KI-Antworten zitiert zu werden

Wenn ChatGPT oder Perplexity Antworten per Websuche generieren, kann eine klare Darstellung der Fachkompetenz und Inhalte über llms.txt dazu führen, dass die Website als vertrauenswürdige Quelle wahrgenommen wird. Dies ist Teil von LLMO (Large Language Model Optimization).

Eine ausführliche Erklärung zu LLMO finden Sie in „Was ist LLMO?“.

Grund 3: Meta-Informationen übermitteln, die sitemap.xml nicht bietet

sitemap.xml ist lediglich eine URL-Liste. Mit llms.txt lassen sich zusätzlich folgende Informationen vermitteln:

• Thema und Fachgebiet der Website
• Zusammenfassungen und Kategorien einzelner Inhalte
• Aktualisierungshäufigkeit und Umfang der Website
• Ob Mehrsprachigkeit unterstützt wird
• Kontaktinformationen

3. Formatspezifikation — was und wie schreiben

llms.txt wird im Markdown-Format geschrieben. Das Format gemäß der Spezifikation von llmstxt.org sieht wie folgt aus:

Grundstruktur

# Website-Name

> Kurzbeschreibung der Website. In 1-3 Saetzen Thema, Zielgruppe und Mehrwert vermitteln.

## Abschnittsname 1

- [Seitentitel](URL): Zusammenfassung der Seite

## Abschnittsname 2

- [Seitentitel](URL): Zusammenfassung der Seite
- [Seitentitel](URL): Zusammenfassung der Seite

Formatregeln

Konkretes Beispiel

# My Tech Blog

> My Tech Blog is a software engineering blog covering web development, cloud infrastructure, and AI tools. Updated weekly with practical tutorials and comparisons.

## Main Sections

- [Articles](https://example.com/articles): 50+ in-depth technical articles
- [Tutorials](https://example.com/tutorials): Step-by-step coding tutorials

## Popular Articles

- [React vs Vue in 2026](https://example.com/articles/react-vs-vue): A detailed comparison of React and Vue.js for modern web development, covering performance, ecosystem, and learning curve.
- [Docker for Beginners](https://example.com/articles/docker-beginners): Complete guide to Docker containers for developers who have never used containerization.

## Site Information

- URL: https://example.com
- Sitemap: https://example.com/sitemap.xml
- Languages: en, ja
- Contact: admin@example.com

Hinweise

• Standardmäßig auf Englisch schreiben. Die llms.txt-Spezifikation und Beispiele sind durchweg auf Englisch, was es zur Best Practice macht. Für mehrsprachige Websites wird empfohlen, auf Englisch zu schreiben und die unterstützten Sprachen mit Languages: ja, en, es, ... anzugeben. Für einsprachige Websites (z.B. eine Website komplett auf Französisch oder Russisch) ist es jedoch völlig akzeptabel, in der Sprache der Website zu schreiben. Die führenden LLMs (GPT, Claude, Gemini usw.) verarbeiten die meisten Sprachen mit hoher Genauigkeit, und die Nutzer solcher Websites werden in derselben Sprache anfragen, was konsistente Antworten gewährleistet.
• Zeichenkodierung muss UTF-8 sein. Andere Kodierungen können zu Darstellungsfehlern führen
• Sonderzeichen wie Em-Dash (—) vermeiden. Da die Datei als Klartext angezeigt wird, können bestimmte Browser solche Zeichen falsch darstellen. Stattdessen Bindestrich (-) oder Doppelbindestrich (--) verwenden
• URLs als absolute Pfade angeben (vollständige URLs beginnend mit https://)
• Nur eine H1-Überschrift pro Datei. Für die Unterteilung H2 verwenden

4. Welche Informationen eingetragen werden — Pflicht, empfohlen, optional

Viele sind unsicher, was genau eingetragen werden soll. Hier eine Übersicht nach Priorität:

Pflichtangaben (ohne diese ist llms.txt sinnlos)

Empfohlene Angaben (verbessern das KI-Verständnis)

Optionale Angaben (wuenschenswert, aber nicht zwingend)

• Technologie-Stack: Womit die Website erstellt wurde (Framework usw.)
• Aktualisierungshäufigkeit: Wie oft neue Inhalte veröffentlicht werden
• Gesamtzahl der Inhalte: Anzahl der Artikel usw.
• Lizenz-/Zitierrichtlinien: Ob KI-Systeme die Inhalte zitieren dürfen
• API-Informationen: Falls programmatischer Zugriff möglich ist

Was nicht eingetragen werden sollte

• Vertrauliche Informationen: Admin-Panel-URLs, interne API-Endpunkte usw.
• Personenbezogene Daten: Überflüssige persönliche Angaben (Adresse, Telefonnummer usw.)
• Zugangsdaten: API-Schlüssel, Passwörter usw.

5. Unterschied zwischen llms.txt und llms-full.txt

Die Spezifikation von llmstxt.org definiert neben llms.txt auch eine Datei namens llms-full.txt.

Wann llms-full.txt sinnvoll ist

• Technische Dokumentation: API-Referenzen oder Bibliotheksdokumentation, bei denen das Verständnis des Volltextes die Antwortgenauigkeit der KI verbessert
• Wissensdatenbanken: FAQ-Sammlungen oder Glossare, die häufig in Auszuegen zitiert werden

Wann llms-full.txt nicht nötig ist

• Blogs und Medien-Websites: Bei vielen Artikeln würde eine einzelne Datei zu groß werden. Die Zusammenfassungen in llms.txt genügen
• E-Commerce-Websites: Produktinformationen werden besser über strukturierte Daten (JSON-LD usw.) bereitgestellt
• Unternehmenswebsites: Bei wenigen Seiten reicht llms.txt allein aus

Für gewöhnliche Blogs und Medien-Websites genügt llms.txt vollkommen. llms-full.txt ist eher für technische Dokumentation gedacht.

6. Statische Datei vs. dynamische Generierung — was wählen?

Für den Betrieb von llms.txt gibt es zwei grundlegende Ansätze.

Ansatz 1: Statische Datei

Bei dieser Methode wird eine Textdatei direkt unter public/llms.txt (oder einem vergleichbaren Pfad) abgelegt.

Vorteile:

• Einfachste Implementierung (Datei ablegen, fertig)
• Keinerlei Serverlast
• Funktioniert ohne Framework

Nachteile:

• Bei jeder Inhaltsänderung muss die Datei manuell aktualisiert werden
• Wird die Aktualisierung vergessen, erhält die KI veraltete Informationen
• Anzahl der Inhalte und Kategorien können von der Realität abweichen

Ansatz 2: Dynamische Generierung

Bei dieser Methode nimmt die Anwendung Anfragen an /llms.txt entgegen und generiert den Text dynamisch aus der Datenbank.

Vorteile:

• Immer auf dem neuesten Stand
• Neue Artikel erscheinen automatisch in llms.txt
• Inhaltsanzahl und Kategorienamen sind stets korrekt

Nachteile:

• Höherer Implementierungsaufwand (Routendefinition + Controller)
• Bei jeder Anfrage erfolgt ein Datenbankzugriff (durch Caching reduzierbar)
• Framework erforderlich

Entscheidungshilfe

Im Zweifel: dynamische Generierung. Der anfängliche Implementierungsaufwand ist höher, aber langfristig sinken die Betriebskosten, weil man es „einrichten und vergessen“ kann. Das schlimmste Szenario ist eine statische Datei, deren Aktualisierung vergessen wird und die der KI veraltete Informationen liefert.

7. Implementierung — Codebeispiele für gängige Frameworks

Im Folgenden werden Implementierungsbeispiele für die dynamische Generierung von llms.txt in gängigen Frameworks vorgestellt.

Laravel (PHP)

Routendefinition (routes/web.php):

use App\Http\Controllers\LlmsTxtController;

Route::get('/llms.txt', [LlmsTxtController::class, 'index']);

Controller (app/Http/Controllers/LlmsTxtController.php):

class LlmsTxtController extends Controller
{
    public function index()
    {
        $articles = Article::published()
            ->with(['translations' => fn($q) => $q->where('locale', 'en')])
            ->orderBy('published_at')
            ->get();

        $lines = [];
        $lines[] = '# My Site Name';
        $lines[] = '';
        $lines[] = '> Site description here.';
        $lines[] = '';
        $lines[] = '## All Articles (' . $articles->count() . ')';
        $lines[] = '';

        foreach ($articles as $article) {
            $t = $article->translations->first();
            if (!$t) continue;
            $url = 'https://example.com/en/articles/' . $article->slug;
            $lines[] = '- [' . $t->title . '](' . $url . '): ' . $t->meta_description;
        }

        $content = implode("\n", $lines);
        return response($content, 200)
            ->header('Content-Type', 'text/plain; charset=utf-8');
    }
}

Wichtig ist die explizite Angabe von Content-Type: text/plain; charset=utf-8. Ohne diese Angabe wird die Datei möglicherweise als HTML interpretiert.

Django (Python)

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('llms.txt', views.llms_txt, name='llms_txt'),
]

# views.py
from django.http import HttpResponse
from .models import Article

def llms_txt(request):
    articles = Article.objects.filter(
        status='published'
    ).order_by('published_at')

    lines = ['# My Site', '', '> Description.', '', '## Articles', '']
    for a in articles:
        lines.append(f'- [{a.title}](https://example.com/articles/{a.slug}): {a.meta_description}')

    content = '\n'.join(lines)
    return HttpResponse(content, content_type='text/plain; charset=utf-8')

Next.js (TypeScript)

// app/llms.txt/route.ts (App Router)
import { NextResponse } from 'next/server'

export async function GET() {
  // Daten aus DB oder CMS abrufen
  const posts = await getAllPosts()

  const lines = [
    '# My Site',
    '',
    '> Description.',
    '',
    '## Articles',
    '',
    ...posts.map(p =>
      `- [${p.title}](https://example.com/posts/${p.slug}): ${p.description}`
    ),
  ]

  return new NextResponse(lines.join('\n'), {
    headers: { 'Content-Type': 'text/plain; charset=utf-8' },
  })
}

WordPress (PHP)

In die functions.php oder als Plugin einfügen:

// functions.php
add_action('init', function() {
    add_rewrite_rule('^llms\.txt$', 'index.php?llms_txt=1', 'top');
});

add_filter('query_vars', function($vars) {
    $vars[] = 'llms_txt';
    return $vars;
});

add_action('template_redirect', function() {
    if (!get_query_var('llms_txt')) return;

    header('Content-Type: text/plain; charset=utf-8');
    $posts = get_posts(['numberposts' => -1, 'post_status' => 'publish']);

    echo "# " . get_bloginfo('name') . "\n\n";
    echo "> " . get_bloginfo('description') . "\n\n";
    echo "## Articles (" . count($posts) . ")\n\n";

    foreach ($posts as $post) {
        $url = get_permalink($post);
        $desc = get_the_excerpt($post);
        echo "- [{$post->post_title}]({$url}): {$desc}\n";
    }
    exit;
});

Bei WordPress nicht vergessen, die Permalink-Einstellungen neu zu speichern (Rewrite-Regeln flushen).

Statische Website-Generatoren (Hugo / Astro usw.)

Ein Skript schreiben, das die Datei beim Build automatisch erzeugt:

# build-llms-txt.sh (Beispiel fuer Hugo)
#!/bin/bash
echo "# My Site" > public/llms.txt
echo "" >> public/llms.txt
echo "> Site description." >> public/llms.txt
echo "" >> public/llms.txt
echo "## Articles" >> public/llms.txt
echo "" >> public/llms.txt

for file in content/posts/*.md; do
  title=$(grep '^title:' "$file" | sed 's/title: //')
  slug=$(basename "$file" .md)
  desc=$(grep '^description:' "$file" | sed 's/description: //')
  echo "- [${title}](https://example.com/posts/${slug}): ${desc}" >> public/llms.txt
done

Wenn dieses Skript in der CI-Pipeline (GitHub Actions usw.) vor dem Build ausgeführt wird, wird llms.txt bei jedem Deployment automatisch aktualisiert.

8. Prüfung und Validierung nach der Einrichtung

Nach der Einrichtung von llms.txt sollten folgende Punkte geprüft werden:

Grundlegende Checkliste

Zusätzliche Prüfung bei dynamischer Generierung

• Nach dem Hinzufügen eines Artikels llms.txt prüfen: Wird der neue Artikel angezeigt?
• Ist die angezeigte Inhaltsanzahl korrekt? Stimmt die Zahl bei „All Articles (27)“ mit der tatsächlichen Anzahl veröffentlichter Artikel überein?
• Sind unveröffentlichte Artikel ausgeschlossen? Sicherstellen, dass Entwürfe und geplante Beiträge nicht angezeigt werden

Validierungstools

Stand April 2026 gibt es keinen offiziellen llms.txt-Validator. Die Validierung ist jedoch auf folgenden Wegen möglich:

• Von ChatGPT oder Claude lesen lassen: Fragen wie „Lies https://ihreseite.de/llms.txt und erkläre mir, worum es auf dieser Website geht“
• Markdown-Previewer: Den Inhalt von llms.txt in einen Markdown-Previewer einfügen und prüfen, ob die Struktur korrekt gerendert wird
• SEO-Audit-Tools: Einige SEO-Audit-Tools beginnen, die Existenz von llms.txt zu überprüfen

9. Praxisbeispiele von llms.txt auf echten Websites

Werfen wir einen Blick auf Trends bei Websites, die llms.txt bereits eingeführt haben.

Merkmale von Websites mit llms.txt-Einführung

Merkmale einer guten llms.txt

• Knappe und verständliche Beschreibung — Das Fachgebiet der Website ist auf einen Blick erkennbar
• Alle Inhalte mit Zusammenfassung aufgelistet — Die KI kann das Gesamtbild erfassen
• Kategorie-System angegeben — Die Informationsstruktur wird sichtbar
• Dynamisch generiert — Stets auf dem aktuellen Stand

Merkmale einer schlechten llms.txt

• Nur Website-Name und Kontakt — Zu wenig Information, um der KI beim Verständnis zu helfen
• Volltexte aller Inhalte hineinkopiert — llms.txt ist ein „Inhaltsverzeichnis“, kein „Volltext“. Dafür gibt es llms-full.txt
• Veraltete Informationen belassen — Wenn „10 Artikel“ angegeben sind, tatsächlich aber 50 existieren, schadet das der Glaubwuerdigkeit
• Vertrauliche Informationen enthalten — Fälle, in denen Admin-URLs oder API-Schlüssel eingetragen sind

FAQ