Cloudflare gibt Clairic frei: Offene KI-Modelle lesen Rechnungen und PDFs aus

Cloudflare veröffentlicht seine Modelle Clairic (27 Milliarden Parameter) und Clairic-flash (9 Milliarden) mit offenen Gewichten unter Apache 2.0. Die Modelle sind darauf spezialisiert, aus Belegen, PDFs und Support-Tickets saubere, überprüfbare Datenfelder herauszuziehen – schneller und billiger als große Sprachmodelle, zumindest laut Cloudflares eigenen Tests.

Modell-Releases Selbst ausprobieren 19. Nov. 2026 8 Min. Lesezeit Quelle: dev.to #ai
Symbolbild, KI-generiert

Worum es geht

Cloudflare, eigentlich vor allem als Anbieter von Netzwerk- und Sicherheitsdiensten bekannt, entwickelt inzwischen eigene KI-Modelle. Am 18. November 2026 hat das Unternehmen zwei davon mit offenen Gewichten veröffentlicht: Clairic mit 27 Milliarden Parametern und das neue, kleinere Clairic-flash mit 9 Milliarden Parametern. Beide liegen auf Hugging Face unter der freizügigen Apache-2.0-Lizenz. Man darf sie also auch kommerziell nutzen, verändern und weiterverbreiten. Außerdem laufen beide als gehostete Dienste auf Workers AI, Cloudflares Plattform für KI-Modelle in der Cloud.

Die Modelle haben eine einzige Aufgabe: Sie ziehen strukturierte Daten aus unstrukturierten Dokumenten. Aus einem Kassenbon, einer mehrseitigen Rechnung im PDF-Format oder einer Kunden-E-Mail holen sie etwa Lieferant, Einzelpositionen, Gesamtbetrag, Bestellnummer oder Datum heraus. Das Ergebnis ist kein Fließtext. Die Modelle liefern sauber typisierte Werte, also echte Zahlen, Datumsangaben oder Listen, die ein Programm direkt weiterverarbeiten kann.

Eine erste Vorschauversion hatte Cloudflare am 19. Oktober 2026 nur als Cloud-Dienst gestartet und offene Gewichte für später angekündigt. Die jetzige Version ist allerdings mehr als die nachgereichte Vorschau: Cloudflare hat das Modell nach eigenen Angaben grundlegend umgebaut.

Was sich seit der Vorschau geändert hat

Die Vorschau beantwortete alle angefragten Felder in einem einzigen Durchlauf durch das Modell. Sie erzeugte dabei keine Tokens (Textbausteine), sondern las die Antworten direkt ab. Das war sehr schnell, aber fehleranfällig. Laut Marktechpost nannte Cloudflare selbst damals mehrstufige Rechnungen, Schätzungen ohne Belege und einfache Prognosen als Schwachstellen.

Die neue Version arbeitet bei normalen Text- und Zahlenfeldern mit paralleler, slotweiser autoregressiver Generierung. Autoregressiv heißt: Das Modell schreibt eine Antwort Token für Token und richtet sich dabei nach dem, was es schon geschrieben hat, so wie ein Mensch, der ein Wort Buchstabe für Buchstabe tippt. Jedes Feld hat seinen eigenen „Slot“ und endet an seiner eigenen Endmarke. Alle Felder werden gleichzeitig im selben Rechenstapel bearbeitet. Das kostet etwas mehr Zeit, bringt laut Cloudflare aber deutlich mehr Genauigkeit.

Für Rechenaufgaben gibt es eigens trainierte Heads, also spezialisierte Ausgabemodule auf dem Modell. Sie kümmern sich um Schätzungen, Prognosen, Zeitspannen, berechnete Daten und ausdrückliche Rechnungen. Das Modell kann also nicht nur „steht da“ beantworten, sondern auch „was folgt daraus“, etwa einen Gesamtpreis inklusive Steuer oder die Tage seit der Lieferung.

Neu ist auch die PDF-Unterstützung. In einer Anfrage lassen sich Lieferant, Positionen und Summe abfragen, selbst wenn diese auf verschiedenen Seiten stehen. Einzelpositionen kommen als Zeilen zurück, in denen Beschreibung, Menge und Preis zusammenbleiben. Laut Unite.AI gelten feste Grenzen: höchstens vier Bilder oder gerenderte PDF-Seiten pro Anfrage, eingebettete Dateien bis 4 MiB einzeln und 8 MiB zusammen, und Links auf entfernte Mediendateien werden nicht angenommen. Ein ganzes Dokumentenarchiv auf einmal geht also nicht.

Überprüfbare Antworten statt blindem Vertrauen

Die Schnittstelle ist gleich geblieben, und genau sie macht die Modelle interessant. Zu jeder Antwort gibt es einen Konfidenzwert (wie sicher sich das Modell ist), eine Null-Wahrscheinlichkeit (p_null, also wie wahrscheinlich es ist, dass der Wert im Dokument gar nicht vorkommt) und bei Textantworten Character Spans. Das sind Zeichenpositionen, die genau anzeigen, an welcher Stelle im Dokument der Wert steht. Bei reinen Bildbelegen oder mehrdeutigen Fundstellen bleibt dieser Verweis laut Unite.AI leer.

In der Praxis ist das wichtig. Große Sprachmodelle denken sich gern einen plausiblen Gesamtbetrag aus, der nirgends steht. Clairic soll fehlende Werte dagegen als „null“ melden. In Cloudflares Vorschau-Beispiel lieferte das Modell bei einer fehlenden Sendungsnummer kein erfundenes Ergebnis, sondern einen Leerwert. Schätzungen und Prognosen kommen mit Median und einem 80-Prozent-Intervall. Unterstützte Feldtypen sind laut Marktechpost Text, Zahl, Datum, Uhrzeit, Zeitstempel, Dauer, Liste, Schätzung und Prognose.

Zahlen und Geschwindigkeit laut Cloudflare

Cloudflare hat beide Modelle mit internen Tests gegen die Vorschau und gegen zwei Konkurrenten verglichen: Liquid AIs D1.2, kombiniert mit Apple Vision als Texterkennung (OCR), und Scaledowns Extract. Angegeben ist jeweils die Zahl der richtig beantworteten Felder:

Test Vorschau Clairic Clairic-flash D1.2 + OCR ScaleDown
Neue Textfelder (96 Anfragen) 295/336 335/336 328/336 304/336 259/336
Gemischte Eingaben (36 Anfragen) 207/226 221/226 213/226 116/226 156/226
Kundenprüfungen (139 Anfragetypen) 1.033/1.263 1.263/1.263 1.263/1.263 973/1.263 653/1.263
Synthetische Belegfelder (Text und Bild) 369/576 576/576 576/576 397/576 280/576

Nach Cloudflares Angaben sank die Zahl der Fehler beim Lesen von Bildern in den internen Tests von 207 auf null. Das Unternehmen räumt selbst ein, dass es keine öffentlichen Extraktions-Benchmarks gibt, und nennt die Ergebnisse „richtungsweisend“.

Auch die Geschwindigkeit hat Cloudflare gemessen, und zwar als vollständige HTTP-Antwort von einem selbst betriebenen Server mit allen Feldern. p50 ist der Median, p95 der Wert, den 95 Prozent der Anfragen unterschreiten:

Testszenario Clairic p50 / p95 Clairic-flash p50 / p95
Neue Textfelder 358 / 736 ms 155 / 328 ms
Neue Bildfelder 453 / 976 ms 305 / 605 ms
Gewerbemietverträge 691 / 803 ms 379 / 519 ms
Kreditkonditionen 395 / 407 ms 188 / 192 ms
Verkehrsprognose 532 / 585 ms 243 / 261 ms
Spesenprüfung 632 / 742 ms 393 / 512 ms

Alle Werte liegen unter einer Sekunde. Man kann die Modelle also direkt in einer laufenden Anwendung aufrufen und muss sie nicht als nächtlichen Stapeljob einplanen. Schon bei der Vorschau hatte Cloudflare eine Schadensmeldungs-Pipeline vorgeführt. Laut Marktechpost dauerte der Extraktionsschritt dort 0,46 Sekunden, mit dem großen Sprachmodell GLM-5.3 dagegen 16,1 Sekunden.

Preise und Umstellung auf Workers AI

Während der Vorschau lief unter dem Endpunkt @cf/cloudflare/clairic das 9B-Modell. Jetzt ist es umgekehrt: Das 27B-Modell übernimmt @cf/cloudflare/clairic, das 9B-Modell zieht nach @cf/cloudflare/clairic-flash um. Wer schon den Vorschau-Endpunkt nutzt, bekommt automatisch das größere Modell. Die Schnittstelle bleibt unverändert.

  • Bis 1. Dezember 2026: beide Modelle 0,10 US-Dollar pro Million Eingabe-Tokens.
  • Ab 1. Dezember 2026: Clairic 0,24 US-Dollar, Clairic-flash weiterhin 0,10 US-Dollar pro Million Eingabe-Tokens.
  • Ausgabe-Tokens: werden nicht berechnet, obwohl die neue Architektur welche erzeugt. Cloudflare übernimmt diese Kosten nach eigener Aussage selbst.

Wer große Mengen verarbeitet und mit der kleineren Variante auskommt, sollte vor dem 1. Dezember auf den Flash-Endpunkt umstellen. Sonst steigen die Kosten auf mehr als das Doppelte.

Was du zum Ausprobieren brauchst

Am einfachsten ist der gehostete Weg über Workers AI, dafür brauchst du keine eigene Hardware. Wer die Modelle lokal betreiben will, etwa weil Krankenakten, Verträge oder Finanzunterlagen das eigene Netz nicht verlassen dürfen, lädt die Gewichte von Hugging Face. Laut Unite.AI enthalten die Repositorys neben den Gewichten auch die Komponenten für die typisierte Ausgabe, Tokenizer, Prozessor und Python-Hilfsskripte. Die Inferenz läuft über PyTorch und Hugging Face Transformers. Dass Varianten für llama.cpp oder Ollama erscheinen, ist unwahrscheinlich, denn die Spezial-Heads und die Feldlogik gehen über ein normales Chatmodell hinaus.

Hardwarewerte nennt Cloudflare nicht. Grob geschätzt braucht Clairic-flash (9B) in voller BF16-Genauigkeit etwa 18 bis 20 GB Grafikspeicher, also eine Karte mit 24 GB. Mit 4-Bit-Quantisierung (das Modell wird verkleinert, indem seine Zahlen gröber gespeichert werden) könnten etwa 8 GB reichen. Ob die Spezial-Heads quantisiert noch sauber arbeiten, ist allerdings nicht belegt. Clairic (27B) braucht in BF16 rund 55 GB, also eine Rechenzentrumskarte oder mehrere GPUs; mit 4 Bit wären es grob 18 GB. Planen solltest du außerdem 20 bis 60 GB Speicherplatz und mindestens 32 GB Arbeitsspeicher. Auf einem reinen CPU-System läuft das 9B-Modell vermutlich, aber sehr langsam. Für erste lokale Versuche mit dem Flash-Modell eignet sich ein Google-Colab-Notebook mit größerer GPU.

Einordnung

Cloudflare nennt das Konzept „System One“, angelehnt an Daniel Kahnemans schnelles, intuitives Denken. Kleine, spezialisierte Modelle sollen eng umrissene Aufgaben übernehmen, für die heute teure große Sprachmodelle eingesetzt werden. Sie sollen diese ergänzen, nicht ersetzen. Für den Dreiklang aus Extraktion, Entscheidung und Antwort hat Cloudflare neben Clairic auch das Entscheidungsmodell Clef im Angebot. Das Team dahinter nennt sich selbstbewusst „Workers AI Superintelligence team“, und Cloudflare bezeichnet sich inzwischen als „Neolab“, also als eigenes KI-Forschungslabor.

Für Entwickler, die Belege, Rechnungen, Mietverträge oder Support-Tickets automatisch auswerten, ist das Angebot interessant: offene Gewichte, eine freizügige Lizenz, überprüfbare Antworten mit Quellenverweis und niedrige Preise. Die Einschränkungen sind aber deutlich. Alle Genauigkeitswerte stammen von Cloudflare selbst, gemessen mit eigenen Testsätzen auf typischen Cloudflare-Anwendungsfällen, auch die Vergleiche mit der Konkurrenz. Unabhängige Tests fehlen bisher. Offen sind auch die Trainingsdaten und das Trainingsrezept, nur die Gewichte wurden freigegeben. Welche Konfidenzschwelle für eine verlässliche Antwort reicht, muss laut Unite.AI jede Anwendung selbst festlegen. Wer die Modelle produktiv einsetzen will, sollte sie zuerst mit den eigenen, schwierigsten Dokumenten testen.

Quellen

#cloudflare#dokumentenextraktion#open-weights#qwen#workers ai
Originalquelle lesen

Selbst ausprobieren: Clairic (27B) und Clairic-flash (9B)

Schritt für Schritt erklärt, auch ohne Vorkenntnisse – auf deinem Rechner oder kostenlos im Browser.

Was kann ich damit machen?

Clairic liest Texte, JSON, Fotos und PDFs und zieht daraus genau die Felder, die du vorher festlegst, zum Beispiel Lieferant, Rechnungsdatum, Einzelpositionen und Gesamtsumme. Die Antworten kommen als echte Zahlen, Daten oder Listen zurück, nicht als Chat-Text. Zu jedem Wert gibt es einen Konfidenzwert und bei Text auch die genaue Fundstelle im Dokument. Fehlt ein Wert, meldet das Modell „null“, statt etwas zu erfinden. Spezielle Module rechnen außerdem einfache Summen, Zeitspannen oder berechnete Daten aus und liefern Schätzungen und Prognosen mit Unsicherheitsbereich. Pro Anfrage sind höchstens vier Bilder oder PDF-Seiten möglich, ganze Aktenordner auf einmal gehen also nicht. Laut Cloudflares eigenen Tests liegt die Genauigkeit vor Konkurrenten wie Liquid AI D1.2 und ScaleDown Extract, unabhängig bestätigt ist das aber nicht. Plaudern, Texte schreiben oder allgemeine Fragen beantworten kann es nicht, dafür ist es nicht gebaut.

Für wen lohnt es sich?

Lohnend ist es für Entwickler und kleine Firmen, die regelmäßig Belege, Rechnungen, Verträge oder Support-E-Mails auswerten und dafür bisher teure große Sprachmodelle nutzen, besonders wenn die Daten das eigene Netz nicht verlassen dürfen. Wer einfach einen KI-Chat für den Alltag sucht oder keine Programmierkenntnisse hat, ist mit einem normalen Chatmodell besser bedient.

Ideen: Was du damit anstellen kannst

Kassenbons fürs Haushaltsbuch

Fotografiere deine Einkaufsbelege und lass Händler, Datum, Summe und Einzelpositionen auslesen. Die Werte landen per Skript direkt in einer Tabelle, und du siehst am Monatsende ohne Abtippen, wofür das Geld ausgegeben wurde.

Rechnungseingang im Kleinbetrieb

Eingehende PDF-Rechnungen werden automatisch nach Lieferant, Rechnungsnummer, Fälligkeitsdatum und Betrag ausgewertet. Unsichere Werte mit niedriger Konfidenz markiert das System zur manuellen Prüfung, der Rest geht direkt in die Buchhaltungsliste.

Support-Tickets vorsortieren

Aus freien Kunden-E-Mails zieht das Modell Bestellnummer, Lieferdatum und Betrag und berechnet die Tage seit der Lieferung. So lässt sich sofort erkennen, ob eine Reklamation noch in der Rückgabefrist liegt.

Verträge schnell erfassen

Miet- oder Kreditverträge als PDF einlesen und Miete, Laufzeit, Zinssatz und Kündigungsfristen als Felder ausgeben lassen. Über die Fundstellen kannst du jeden Wert direkt im Originaltext gegenprüfen.

Spesenabrechnungen prüfen

Belege von Dienstreisen auswerten und die Summe mit der eingereichten Abrechnung vergleichen lassen. Abweichungen oder fehlende Angaben fallen sofort auf, weil fehlende Werte als „null“ gemeldet und nicht erfunden werden.

Einfache Prognosen aus Zahlenreihen

Gib eine Reihe täglicher Besucher- oder Verkaufszahlen ein und frage eine Prognose für die nächsten Tage ab. Du bekommst einen Mittelwert und ein 80-Prozent-Intervall, das zeigt, wie unsicher die Vorhersage ist.

Größe27,8 Mrd. Parameter
Download56 GB (bei 100 MBit/s ca. 75 Min.)
Lizenzapache-2.0
ArtBild + Text (versteht Bilder)
Hugging FaceCloudflare/clairic

Was dein Rechner braucht

Grafikkarte (NVIDIA) mind. 68 GB VRAMDer Hersteller nennt keinen Wert. Die Zahl ist berechnet: Das Repo enthält genau eine Variante der Gewichte, nämlich 18 Teile in bf16 plus den Zusatzkopf, zusammen 55,9 GB. Das ergibt 55,9 × 1,2 + 1 ≈ 68 GB. Praktisch heißt das: eine Profi-Grafikkarte mit 80 GB (z. B. A100/H100 80 GB). Mit normalen Gaming-Grafikkarten (8–24 GB) klappt es nicht.
Mac (Apple Silicon M1–M5) ab 128 GB gemeinsamer SpeicherGrafik und Prozessor teilen sich den Speicher – etwa 70 % davon kann das Modell nutzen
Speicherplatz ca. 58 GB freiModell-Download plus Programme

Clairic-flash (9B) ist die richtige Wahl für die meisten lokalen Versuche und für große Mengen. Es ist laut Cloudflare etwa doppelt so schnell und erreicht in den internen Tests fast die gleiche Genauigkeit. In voller BF16-Genauigkeit braucht es grob geschätzt 18 bis 20 GB Grafikspeicher, also eine 24-GB-Karte. Clairic (27B) ist für besonders schwierige Dokumente gedacht und braucht ungefähr 55 GB in BF16, also Rechenzentrums-GPUs; 4-Bit-Quantisierung würde den Bedarf grob auf etwa 18 GB senken, offizielle quantisierte Versionen nennt die Quelle aber nicht. Ohne passende Hardware ist der gehostete Endpunkt auf Workers AI der einfachste Weg.

  • Cloudflare nennt keine offiziellen Hardware-Anforderungen. Alle VRAM-Angaben hier sind grobe Schätzungen.
  • Clairic-flash (9B) in BF16: etwa 18 bis 20 GB VRAM, also zum Beispiel eine RTX 3090 oder 4090 mit 24 GB.
  • Clairic (27B) in BF16: etwa 55 GB VRAM. Mit 4-Bit-Quantisierung grob 18 GB, ob die Spezial-Heads das gut vertragen, ist aber ungeprüft.
  • Die Inferenz läuft laut Model Cards über PyTorch und Hugging Face Transformers. Fertige GGUF-Dateien für llama.cpp oder Ollama werden nicht erwähnt.
  • Pro Anfrage höchstens vier Bilder oder PDF-Seiten, jeweils bis 4 MiB und zusammen bis 8 MiB. Mehr Seiten kosten mehr Speicher und Zeit.
  • Ohne eigene GPU kannst du den gehosteten Dienst nutzen: @cf/cloudflare/clairic oder @cf/cloudflare/clairic-flash auf Workers AI.
Wie finde ich heraus, was mein Rechner hat?
  • Windows: Strg + Umschalt + Esc drücken → Task-Manager → Reiter Leistung → links GPU anklicken. Unten steht Dedizierter GPU-Speicher (das ist dein VRAM). Den Arbeitsspeicher findest du unter Arbeitsspeicher.
  • Mac: Apfel-Menü oben links → Über diesen Mac. Dort stehen Chip (z. B. M2) und Speicher (z. B. 16 GB). Bei Apple-Chips teilen sich Grafik und Prozessor diesen Speicher.
  • Linux: Im Terminal nvidia-smi eingeben (zeigt Grafikkarte und Speicher) und free -h für den Arbeitsspeicher.

Anleitung

Dieses Modell läuft mit einem eigenen Programm seiner Entwickler. Die Befehle unten stammen aus der Model Card und der Anleitung der Entwickler.

Windows 10 / 11

Windows 10 / 11: nicht offiziell getestet. Windows erwähnt die Quelle nicht. Es sollte mit einer NVIDIA-Karte mit etwa 80 GB gehen, aber Pakete wie xgrammar machen unter Windows manchmal Probleme. Sicherer ist WSL2 (ein Linux innerhalb von Windows) mit den Linux-Schritten oder ein gemieteter Cloud-Server.

  1. Voraussetzungen prüfen. Installiere Python 3.11 oder neuer und setze dabei den Haken bei „Add Python to PATH“. Du brauchst eine NVIDIA-Grafikkarte mit etwa 80 GB Speicher, einen aktuellen NVIDIA-Treiber und rund 60 GB freien Platz. Öffne die PowerShell und prüfe Python und Treiber.
    python --version
    nvidia-smi
  2. Arbeitsordner anlegen. Lege einen Projektordner an und wechsle hinein.
    mkdir clairic-test
    cd clairic-test
  3. Virtuelle Umgebung anlegen. Die virtuelle Umgebung hält die Pakete getrennt vom Rest des Systems. Meldet PowerShell, dass keine Skripte erlaubt sind, führe vorher einmal „Set-ExecutionPolicy -Scope CurrentUser RemoteSigned“ aus. Danach steht vorne in der Zeile (.venv).
    python -m venv .venv
    .venv\Scripts\Activate.ps1
  4. Download-Werkzeug installieren. Damit installierst du huggingface_hub mit dem Befehl hf zum Herunterladen.
    pip install -U huggingface_hub
  5. Modell und Programm herunterladen. Damit lädst du das komplette Repo (rund 56 GB) in den Ordner clairic. Das dauert eine Weile.
    hf download Cloudflare/clairic --local-dir clairic
  6. Abhängigkeiten installieren. Damit installierst du PyTorch, Transformers, xgrammar und die übrigen Pakete aus der Liste. Falls PyTorch ohne CUDA installiert wird, erkennt es die Grafikkarte nicht. Dann musst du die CUDA-Version von PyTorch nachinstallieren.
    pip install -r clairic\requirements.txt
  7. Testskript anlegen. Speichere diesen Code als demo.py im Ordner clairic-test. Es ist das Rechnungsbeispiel aus der Anleitung.
    import sys
    
    path = "clairic"
    sys.path.insert(0, path)
    from clairic_model import load_release_model, systemone
    
    model, processor = load_release_model(path, device="cuda")
    
    response = systemone(
        model,
        processor,
        {
            "state": (
                "Invoice from Northwind Supply. Issued 2026-09-02. "
                "Items: Pens; Paper. Total: $1080.00."
            ),
            "fields": {
                "vendor": {"type": "text", "instructions": "The invoice vendor."},
                "total": {"type": "number", "decimals": 2},
                "issued": {"type": "date"},
                "items": {
                    "type": "list",
                    "items": "text",
                    "instructions": "The purchased item names, in order.",
                },
            },
        },
    )
    print(response["answers"])
  8. Erstes Ergebnis erzeugen. Starte das Skript. Nach dem Laden erscheinen die erkannten Felder vendor, total, issued und items. Bei „CUDA out of memory“ reicht der Grafikspeicher nicht.
    python demo.py
  9. Ergebnis. Im Terminal erscheinen die Antworten zum Beispielbeleg, also Händler „Northwind Supply“, Summe 1080.00, Datum 2026-09-02 und die Liste der Artikel „Pens“ und „Paper“, jeweils mit Konfidenzwerten.

macOS

macOS: nicht offiziell getestet. Die Anleitung lädt das Modell nur mit device="cuda", also für NVIDIA-Karten. Die gibt es im Mac nicht. Apple-Chips (Backend „mps“) erwähnt die Quelle nicht. Ein Versuch lohnt sich höchstens auf einem Mac mit 96 GB gemeinsamem Speicher oder mehr. Sonst ist ein gemieteter Cloud-Server mit NVIDIA-GPU die bessere Wahl.

  1. Voraussetzungen prüfen. Du brauchst einen Mac mit Apple-Chip und sehr viel Arbeitsspeicher (mindestens 96 GB), dazu Python 3.11 oder neuer und rund 60 GB freien Platz. Installiere die Xcode-Kommandozeilenwerkzeuge (das sind Grundwerkzeuge für Entwickler) und prüfe dann die Python-Version im Terminal.
    xcode-select --install
    python3 --version
  2. Arbeitsordner anlegen. Lege einen Projektordner an und wechsle hinein.
    mkdir clairic-test
    cd clairic-test
  3. Virtuelle Umgebung anlegen. Damit legst du eine abgetrennte Python-Umgebung an. Wenn es geklappt hat, steht vorne in der Zeile (.venv).
    python3 -m venv .venv
    source .venv/bin/activate
  4. Download-Werkzeug installieren. Damit installierst du huggingface_hub mit dem Befehl hf.
    pip install -U huggingface_hub
  5. Modell und Programm herunterladen. Damit lädst du das komplette Repo (rund 56 GB) in den Ordner clairic.
    hf download Cloudflare/clairic --local-dir clairic
  6. Abhängigkeiten installieren. Damit installierst du die Pakete aus requirements.txt. Lässt sich ein Paket wie xgrammar auf dem Mac nicht installieren, kommst du an dieser Stelle nicht weiter.
    pip install -r clairic/requirements.txt
  7. Testskript anlegen. Speichere diesen Code als demo.py. Im Original steht device="cuda". Das geht auf dem Mac nicht, deshalb steht hier "mps" für den Apple-Grafikchip. Das ist ein Versuch und von der Quelle nicht abgedeckt.
    import sys
    
    path = "clairic"
    sys.path.insert(0, path)
    from clairic_model import load_release_model, systemone
    
    model, processor = load_release_model(path, device="mps")
    
    response = systemone(
        model,
        processor,
        {
            "state": (
                "Invoice from Northwind Supply. Issued 2026-09-02. "
                "Items: Pens; Paper. Total: $1080.00."
            ),
            "fields": {
                "vendor": {"type": "text", "instructions": "The invoice vendor."},
                "total": {"type": "number", "decimals": 2},
                "issued": {"type": "date"},
            },
        },
    )
    print(response["answers"])
  8. Erstes Ergebnis erzeugen. Starte das Skript. Klappt es, erscheinen die Felder vendor, total und issued. Bricht es mit einer Fehlermeldung zu mps oder cuda ab, unterstützt der Code den Mac nicht.
    python3 demo.py
  9. Ergebnis. Im Terminal erscheinen die Antworten zum Beispielbeleg, also Händler „Northwind Supply“, Summe 1080.00, Datum 2026-09-02 und die Liste der Artikel „Pens“ und „Paper“, jeweils mit Konfidenzwerten.

Linux

Linux: unterstützt. Laut Anleitung läuft das Modell mit PyTorch und Transformers auf einer NVIDIA-Grafikkarte (device="cuda"). Ein Betriebssystem nennt die Quelle nicht ausdrücklich. Linux mit NVIDIA-Karte ist aber der übliche Weg. Du brauchst rund 68 GB Grafikspeicher, wenn du keine solche Karte hast, miete einen Cloud-Server mit A100/H100 80 GB.

  1. Voraussetzungen prüfen. Du brauchst Python 3.11 oder neuer, eine NVIDIA-Grafikkarte mit etwa 80 GB Speicher und einen aktuellen NVIDIA-Treiber. Außerdem müssen rund 60 GB auf der Festplatte frei sein. Mit den beiden Befehlen prüfst du die Python-Version und ob der Treiber die Grafikkarte erkennt.
    python3 --version
    nvidia-smi
  2. Arbeitsordner anlegen. Lege einen eigenen Ordner für das Projekt an und wechsle hinein. Alle weiteren Befehle führst du dort aus.
    mkdir clairic-test
    cd clairic-test
  3. Virtuelle Umgebung anlegen. Eine virtuelle Umgebung (venv) ist ein abgetrennter Bereich für Python-Pakete. So kommt nichts mit anderen Programmen durcheinander. Wenn es geklappt hat, steht vorne in der Eingabezeile (.venv).
    python3 -m venv .venv
    source .venv/bin/activate
  4. Download-Werkzeug installieren. Das Paket huggingface_hub bringt den Befehl hf mit. Damit lädst du Dateien von Hugging Face herunter.
    pip install -U huggingface_hub
  5. Modell und Programm herunterladen. Damit lädst du das ganze Repo in den Ordner clairic. Es enthält die Gewichte (rund 56 GB), den Python-Code clairic_model.py und die requirements.txt. Das kann je nach Internetverbindung lange dauern. Am Ende liegen 18 model-…safetensors-Dateien im Ordner.
    hf download Cloudflare/clairic --local-dir clairic
  6. Abhängigkeiten installieren. Damit installierst du alle Pakete aus der mitgelieferten Liste, darunter PyTorch, Transformers und xgrammar. xgrammar sorgt dafür, dass die Antworten genau zum gewünschten Schema passen. Wenn keine roten Fehlermeldungen kommen, hat es geklappt.
    pip install -r clairic/requirements.txt
  7. Testskript anlegen. Speichere den folgenden Code als demo.py im Ordner clairic-test. Das ist das Rechnungsbeispiel aus der Anleitung. Der Unterschied: Der Code verwendet direkt den heruntergeladenen Ordner clairic.
    import sys
    
    path = "clairic"
    sys.path.insert(0, path)
    from clairic_model import load_release_model, systemone
    
    model, processor = load_release_model(path, device="cuda")
    
    response = systemone(
        model,
        processor,
        {
            "state": (
                "Invoice from Northwind Supply. Issued 2026-09-02. "
                "Items: Pens; Paper. Total: $1080.00."
            ),
            "fields": {
                "vendor": {"type": "text", "instructions": "The invoice vendor."},
                "total": {"type": "number", "decimals": 2},
                "issued": {"type": "date"},
                "items": {
                    "type": "list",
                    "items": "text",
                    "instructions": "The purchased item names, in order.",
                },
            },
        },
    )
    print(response["answers"])
  8. Erstes Ergebnis erzeugen. Starte das Skript. Das Laden des Modells in die Grafikkarte dauert ein paar Minuten. Danach werden die Antworten zu vendor, total, issued und items ausgegeben. Meldet das Programm „CUDA out of memory“, reicht der Grafikspeicher nicht.
    python demo.py
  9. Ergebnis. Im Terminal erscheinen die Antworten zum Beispielbeleg, also Händler „Northwind Supply“, Summe 1080.00, Datum 2026-09-02 und die Liste der Artikel „Pens“ und „Paper“, jeweils mit Konfidenzwerten.

So geht es nach dem ersten Ergebnis weiter

  • Ersetze den Text bei "state" durch eigene Texte, zum Beispiel E-Mails oder Rechnungen. Unter "fields" legst du fest, welche Felder du zurückbekommen willst. Möglich sind unter anderem text, number, date, boolean, enum, list, estimate und forecast.
  • Bilder gibst du mit "images": [Image.open("receipt.png")] mit (dazu: from PIL import Image). Erlaubt sind höchstens vier Bilder oder PDF-Seiten. Jede Datei darf höchstens 4 MiB groß sein, alle zusammen höchstens 8 MiB.
  • Für Schätzungen und Prognosen gibst du bei estimate oder forecast ein min und ein max an. Mit "options": {"include_quantiles": True} bekommst du zusätzlich Unsicherheitsbereiche.
  • Sieh dir in der Antwort confidence, p_null und truncated an, bevor du dich auf ein Ergebnis verlässt. Brauchst du ein kleineres Modell, nimm Cloudflare/clairic-flash (9B).

Das kannst du ausprobieren

Kassenbon-Foto mit den Feldern: haendler (Text), datum (Datum), gesamtbetrag (Zahl), rabatt (Zahl)
Rechnungs-PDF mit zwei Seiten, Felder: lieferant (Text), positionen (Liste mit Beschreibung, Menge, Einzelpreis), rechnungssumme (Zahl), faelligkeitsdatum (Datum)
Support-E-Mail „Ich habe am 3. November Bestellung 48213 erhalten, der Wasserkocher ist defekt, er kostete 39,90 € plus Versand 4,90 €“, Felder: bestellnummer (Text), lieferdatum (Datum), gesamtpreis inkl. Versand (Zahl), sendungsnummer (Text)
Mietvertrag als PDF, Felder: monatliche_miete (Zahl), mietbeginn (Datum), vertragslaufzeit (Dauer), kuendigungsfrist (Dauer)
Tabelle mit Besucherzahlen der letzten 30 Tage, Feld: prognose_naechste_7_tage (Prognose mit 80-Prozent-Intervall)

Tipps für bessere Ergebnisse

  • Gib jedem Feld eine kurze Anweisung in normaler Sprache mit, zum Beispiel „Bruttobetrag inklusive Mehrwertsteuer“, damit das Modell den richtigen Wert wählt.
  • Leg eine Regel fest: Ist der Konfidenzwert niedrig oder fehlt die Fundstelle (Character Span), wird der Wert von einem Menschen geprüft statt ungeprüft übernommen.
  • Teste mit deinen schwierigsten echten Dokumenten, also schief fotografierten Belegen oder Handschrift, nicht mit sauberen Demo-Rechnungen.
  • Lass dieselben Dokumente durch Clairic und Clairic-flash laufen und vergleiche die Ergebnisse. Oft reicht das schnellere 9B-Modell.
  • Fordere Einzelpositionen als Liste an, dann bleiben Beschreibung, Menge und Preis jeder Zeile zusammen.

Wenn es hakt

Das ist kein Chatmodell. In Ollama oder LM Studio funktioniert es voraussichtlich nicht, weil die typisierten Ausgabe-Module eigenen Python-Code aus dem Repository brauchen.

Du musst die gewünschten Felder samt Typ (Text, Zahl, Datum, Dauer, Liste, Schätzung, Prognose) vorher festlegen. Eine freie Frage wie „Was steht da drin?“ ist nicht vorgesehen.

Entfernte Bild- oder PDF-Links werden nicht angenommen. Dateien müssen eingebettet mitgeschickt werden und unter 4 MiB pro Datei bzw. 8 MiB insgesamt bleiben.

Mehr als vier Bilder oder PDF-Seiten pro Anfrage gehen nicht. Lange Dokumente musst du in Abschnitte aufteilen.

Auf Workers AI liegt hinter @cf/cloudflare/clairic jetzt das 27B-Modell. Ab 1. Dezember 2026 kostet es 0,24 statt 0,10 US-Dollar pro Million Eingabe-Tokens. Wer günstig bleiben will, muss explizit auf @cf/cloudflare/clairic-flash umstellen.

Laut Vorschau-Dokumentation kann ein sehr breites Feld-Schema mehr Tokens kosten als das Dokument selbst. Unnötige Felder solltest du weglassen.

„out of memory“, Absturz oder der Rechner hängt

Das Modell ist zu groß für deinen Grafikspeicher. Nimm eine kleinere Variante aus der Tabelle oben und schließe andere Programme, vor allem Spiele und Browser mit vielen Tabs.

Es läuft, aber extrem langsam

Wahrscheinlich rechnet der Prozessor statt der Grafikkarte. Bei Ollama zeigt ollama ps in der Spalte PROCESSOR, wie viel auf der GPU läuft. Steht dort „100% CPU“, Grafiktreiber aktualisieren oder eine kleinere Variante nehmen, die komplett in den Grafikspeicher passt.

„ollama“ bzw. „python“ wird nicht gefunden

Das Eingabefenster schließen und neu öffnen, damit es das frisch installierte Programm kennt. Bei Python unter Windows: neu installieren und das Häkchen Add python.exe to PATH setzen.

Windows: „Die Ausführung von Skripts ist auf diesem System deaktiviert“

Das Skript genau mit dem Befehl oben starten: powershell -ExecutionPolicy Bypass -File try_windows.ps1. Das erlaubt die Ausführung nur dieses einen Mal.

Fehlermeldung beim Laden des Modells (Version, „trust_remote_code“, unbekannte Architektur)

Ganz neue Modelle brauchen oft die neueste Programmversion. Bei Ollama: Ollama aktualisieren. Bei Python: pip install -U transformers in der aktivierten Umgebung. Die Model Card nennt meist die genaue Version.

Skripte und Notebook erzeugt Tokenstrom automatisch. Bitte vor dem Ausführen kurz ansehen – sie sind lesbarer Klartext. Lizenz des Modells beachten: apache-2.0.

Frag den KI-Assistenten

Fragen zu diesem Artikel, zur Installation oder zu Hintergründen? Unser Assistent kennt diese Seite und läuft auf unserem eigenen Rechner, nicht in einer fremden Cloud.

Verbinde …

Der Assistent ist eine KI (Gemma 4) und kann sich irren – wichtige Angaben bitte in der Quelle prüfen. Fragen werden nur zum Beantworten genutzt und nach einer Stunde gelöscht. Bitte keine persönlichen Daten eingeben.

Kommentare

Was meinst du dazu? Schon ausprobiert? Schreib es hier, ohne Anmeldung.

  1. Kommentare werden geladen …

Kommentare sind öffentlich. Links sind nicht erlaubt, beleidigende Beiträge löschen wir. Deinen eigenen Kommentar kannst du in diesem Browser jederzeit wieder löschen. Mehr dazu in der Datenschutzerklärung.