Paperless NGX 3.0: Native KI-Funktionen im Praxis-Test

Mit der Paperless NGX 3.0 Beta wandert die KI endlich da hin, wo sie eigentlich hingehört: direkt in den Core. Bisher musstest du dir die Funktion über einen extra Container wie Paperless GPT oder Paperless AI dazustricken, in 3.0 hinterlegst du in den Einstellungen ein LLM-Backend, wählst ein Einbettungsmodell und lässt Tags, Korrespondenten, Dokumenttypen und Titel direkt am Dokument per Klick generieren.

Und das ist nicht mal alles: Mit derselben Konfiguration bekommst du obendrauf einen RAG-Chat, der dein komplettes Dokumentenarchiv durchsuchbar macht – inklusive verlinkter Quellen unter jeder Antwort. Ich habe die Paperless 3.0 Beta einmal mit OpenRouter und einmal mit lokalem Ollama verbunden und geschaut, was die nativen KI-Funktionen heute wirklich abliefern – mit einer Überraschung, die ich beim ersten Schreiben dieses Beitrags glatt übersehen hatte.

Wichtiger Nachtrag zum Video: Den RAG-Chat über deinen kompletten Dokumentenbestand — die wohl spannendste KI-Funktion in Paperless NGX 3.0 — habe ich erst NACH der Aufnahme entdeckt. Im Video kommt sie deshalb (noch) nicht vor. Wie der Chat funktioniert, was er kann und wo das Sprechblasen-Icon sitzt, findest du weiter unten im Abschnitt „Chat mit deinem kompletten Dokumentenbestand (RAG)“.

Was ist neu an Paperless NGX 3.0?

Die Beta bringt mehrere Änderungen, der für viele aber spannendste Punkt sind die nativen KI-Funktionen:

• Ein neuer Reiter „KI-Einstellungen“ unter Konfiguration
• Wahl zwischen openai-like und ollama-like als LLM-Backend
• Konfiguration von Einbettungsmodell (Vektor-Gedächtnis) und Haupt-LLM (Textverständnis)
• Im geöffneten Dokument: Button „Vorschlagen“ — KI generiert Tags, Dokumenttyp, Korrespondent, Titel
• RAG-Chat über deinen kompletten Dokumentenbestand – Antwort plus klickbare Quellverweise auf die zugrundeliegenden Belege

Wichtig vorab: Es ist eine Beta. Vieles, was man sich von Paperless 3.0 wünscht – z. B. das vollautomatische Klassifizieren beim Consumer-Upload – ist (Stand jetzt) noch nicht dabei. Mehr dazu weiter unten.

KI in der Praxis: Der „Vorschlagen“-Button

So weit die Konfiguration. Spannender ist, was am Ende rauskommt. In jedem geöffneten Dokument findest du in der rechten Seitenleiste den Button „Vorschlagen“ (im Video gut zu sehen). Ein Klick darauf, ein paar Sekunden warten – und Paperless präsentiert dir eine Liste an Vorschlägen, die du einzeln per Klick übernehmen kannst:

• Tags: im Test waren 9 Vorschläge dabei, darunter „Tickets“ und „Event“ – passend und brauchbar.
• Dokumenttyp: wird sauber erkannt (z. B. „Ticket“).
• Korrespondent: wird vorgeschlagen, sofern aus dem OCR-Text ableitbar.
• Titel: wird – etwas versteckt – ebenfalls von der KI generiert. Das war im Test eine angenehme Überraschung.

Die Qualität der Vorschläge hängt erwartungsgemäß stark vom gewählten LLM ab. gpt-4o-mini und gemini-2.5-flash haben in meinen Tests souverän abgeliefert, kleinere lokale Modelle (llama3.2:1b, qwen2.5:0.5b) liegen vor allem bei Korrespondenten und Titeln deutlich öfter daneben.

Chat mit deinem kompletten Dokumentenbestand (RAG)

Und jetzt das eigentliche Killer-Feature, das ich beim ersten Schreiben dieses Beitrags glatt übersehen hatte: Paperless 3.0 spricht mit dir – über deine Dokumente. Oben rechts im Header sitzt ein neues Sprechblasen-Icon. Ein Klick darauf öffnet ein Chat-Fenster mit dem schlichten Prompt „Eine Frage zu einem Dokument stellen…“ – gemeint sind aber alle Dokumente, nicht nur das gerade geöffnete.

Im Hintergrund läuft klassisches RAG (Retrieval Augmented Generation): Paperless durchsucht dein Vektor-Gedächtnis nach den thematisch passendsten Belegen, schickt sie zusammen mit deiner Frage ans LLM und liefert dir nicht nur die Antwort, sondern auch eine Liste der Dokumente, aus denen sie stammt – als klickbare Kacheln direkt unter dem Text.

Drei Beispiele aus meinen eigenen Belegen:

• „Was hat ein Mac Mini 2014 ungefähr gekostet?“ — Antwort: „Ein Mac Mini 2014 kann für etwa 80 Euro erworben werden.“ mit Verlinkung auf den passenden Beleg.
• „Wie schalte ich das Walkie-Talkie ein?“ — präzise Bedienanleitung aus der eingescannten Geräte-Anleitung, inklusive Quell-Dokument.
• „Wie viel zahle ich für Morningfame Plus?“ — „10,84 USD monatlich“ plus Liste der drei zugrundeliegenden Rechnungen (06.25, 10.25, 11.25).

In der Praxis bedeutet das: Du musst nicht mehr durch hundert PDFs scrollen, um nachzuschauen, was du im März bei welchem Anbieter gezahlt hast oder welcher Geräte-Code in welcher Anleitung steht. Du fragst – Paperless antwortet und zeigt dir die Originalbelege dazu. Genau diese Funktion wünschen sich viele Leute seit Jahren von Paperless, und sie ist – auch wenn die Beta drauf steht – schon erstaunlich rund.

Voraussetzung dafür ist allerdings, dass dein Einbettungsmodell sauber durchgelaufen ist: Beim ersten Aktivieren der KI baut Paperless im Hintergrund einen FAISS-Index über deinen kompletten Bestand auf. Bei größeren Archiven darf das gern ein paar Minuten dauern – danach sind die Antworten aber wirklich flott.

Der Pain Point: Was die Beta heute noch nicht kann

So weit die guten Nachrichten. Beim automatischen Klassifizieren neuer Uploads zeigt die Beta dann aber ihre Kanten: Es bleibt viel manuelle Klickarbeit. Konkret:

• Beim Upload neuer Dokumente (Consumer / Drag&Drop / API) werden keine KI-Vorschläge automatisch erzeugt. Frisch hochgeladene Dokumente liegen ohne Tag, ohne Typ, ohne Korrespondent da.
• Es gibt keinen Schalter im UI, der „bei Upload automatisch klassifizieren“ aktiviert.
• Die KI ändert nichts selbstständig – jeder einzelne Vorschlag muss per Hand übernommen werden.

In der Praxis heißt das: Für Bestandsdokumente (klick-für-klick durchgehen, KI-Vorschläge prüfen, übernehmen) ist die Beta jetzt schon ein riesiger Komfortgewinn. Für den klassischen Stapel-Workflow – Belege scannen, in den Consumer-Ordner werfen, der Rest erledigt sich von selbst – brauchst du heute weiterhin externe Tools.

Paperless 3.0 native KI vs. Paperless GPT / Paperless AI

Damit ergibt sich eine klare Einordnung gegenüber den etablierten Drittanbieter-Tools:

Für wen lohnt sich der Wechsel auf die 3.0-Beta heute schon?

• Du arbeitest viele Bestandsdokumente händisch auf und willst die KI nur als „Vorschlag-Assistent“ – sehr empfehlenswert.
• Du willst dein Archiv durchfragen statt es zu durchsuchen („Was habe ich letztes Jahr für Strom gezahlt?“, „In welcher Anleitung stand nochmal Schritt X?“) – sehr empfehlenswert, der RAG-Chat ist genau dafür gebaut.
• Du möchtest ohne zusätzlichen Container auskommen und ein cleanes Setup bauen – empfehlenswert, sofern du mit der Klick-Arbeit beim Upload leben kannst.
• Du brauchst vollautomatische Verarbeitung beim Consumer-Upload (z. B. der ScanSnap-Import landet fertig getaggt in der Inbox) – dann bleib vorerst bei Paperless GPT oder Paperless AI.

Fazit zu Paperless 3.0

Dass Paperless die KI-Funktionen jetzt selbst mitbringt, war überfällig. Bisher musste sich jeder seine eigene Lösung aus Paperless GPT, Paperless AI und etwas Geduld zusammenstricken — in Paperless NGX 3.0 sind das ein paar Felder in den Einstellungen. Und mit dem RAG-Chat über den kompletten Dokumentenbestand liegt obendrauf noch ein Feature, das viele Drittanbieter-Tools in dieser Form gar nicht haben – das hatte ich beim ersten Test glatt übersehen und musste meinen eigenen Beitrag deswegen nachträglich nochmal aufmachen.

Was zum vollständig produktiv tauglichen Release noch fehlt, ist die automatische Klassifizierung beim Upload: dass die KI von allein anspringt, wenn ein neues Dokument im Consumer-Ordner landet. Auch ein Bulk-Modus für ganze Stapel und ein bisschen UX-Liebe an der Vorschlagsmaske würden nicht schaden.

Mein Fazit hat sich im Laufe dieses Beitrags deshalb verschoben: Wer sein Archiv vor allem durchfragen oder Bestandsdokumente händisch sauber bekommen will, kann mit der 3.0 Beta in einer Test-Instanz schon jetzt richtig viel anfangen. Für rein neue Belege im Daily Driver bleibt Paperless GPT / Paperless AI vorerst die runderere Wahl – aber der Abstand schrumpft. Wenn du Lust auf einen eigenen Test hast, findest du im nächsten Abschnitt das komplette Setup, mit dem du in einer Viertelstunde durchspielen kannst, was oben beschrieben ist.

Du willst die Paperless 3.0 Beta selbst testen? Hier ist das komplette Setup

Wenn du nach dem Realitätscheck oben sagst „interessant genug, ich will’s selbst sehen“ – hier ist alles, was du brauchst: die docker-compose.yaml, die ich für den Test einsetze, plus die beiden funktionierenden KI-Konfigurationen (OpenRouter oder lokales Ollama). Wenn du nur entscheiden wolltest, ob sich der Wechsel lohnt: Du kannst hier aufhören und auf das Stable-Release warten.

Testumgebung mit Docker Compose

Bau dir am besten eine isolierte Test-Instanz auf. Bitte nicht deine produktive Paperless-Installation auf die Beta heben – das Datenbankschema kann sich noch ändern, und beim Wechsel des Einbettungsmodells musst du den Index ohnehin verwerfen (siehe Pro-Tipp unten). Wie du auf einem ZimaOS-Server am einfachsten zwei Paperless-Instanzen parallel betreibst, zeige ich dir Schritt für Schritt in meinem Beitrag „Zwei Paperless NGX Instanzen auf einem ZimaOS Server betreiben“.

Hier ist die docker-compose.yaml, die ich für den Test verwende. Sie nutzt das Tag 3.0.0-beta.rc1 und legt alle Volumes unter /DATA/AppData/paperless ab (passt sehr gut zu ZimaOS, lässt sich aber auch in Portainer oder pur per Docker Compose ausführen):

version: "3.4"
services:

  broker:
    image: redis:latest
    restart: unless-stopped
    volumes:
      - /DATA/AppData/paperless/redis:/data

  db:
    image: mariadb:latest
    restart: unless-stopped
    environment:
      - MARIADB_DATABASE=paperless
      - MARIADB_USER=paperless
      - MARIADB_PASSWORD=paperless
      - MARIADB_ROOT_PASSWORD=paperless
    volumes:
      - /DATA/AppData/paperless/postgres:/var/lib/mysql

  gotenberg:
    image: docker.io/gotenberg/gotenberg:latest
    restart: unless-stopped
    command:
      - gotenberg
      - --chromium-disable-javascript=true
      - --chromium-allow-list=file:///tmp/.*
    ports:
      - "3006:3000"

  tika:
    image: apache/tika:latest
    restart: unless-stopped
    ports:
      - "9998:9998"

  paperless:
    image: ghcr.io/paperless-ngx/paperless-ngx:3.0.0-beta.rc1
    restart: unless-stopped
    depends_on:
      - broker
      - db
    ports:
      - "8006:8000"
    volumes:
      - /DATA/AppData/paperless/ata:/usr/src/paperless/data
      - /DATA/AppData/paperless/media:/usr/src/paperless/media
      - /DATA/AppData/paperless/export:/usr/src/paperless/export
      - /DATA/AppData/paperless/consume:/usr/src/paperless/consume
    environment:
      - PAPERLESS_REDIS=redis://broker:6379
      - PAPERLESS_DBENGINE=mariadb
      - PAPERLESS_DBHOST=db
      - PAPERLESS_DBUSER=paperless
      - PAPERLESS_DBPASS=paperless
      - PAPERLESS_DBPORT=3306
      - PAPERLESS_TIKA_ENABLED=1
      - PAPERLESS_TIKA_ENDPOINT=http://tika:9998
      - PAPERLESS_TIKA_GOTENBERG_ENDPOINT=http://gotenberg:3000
      - PAPERLESS_TIME_ZONE=Europe/Berlin
      - PAPERLESS_ADMIN_USER=paperless
      - PAPERLESS_ADMIN_PASSWORD=paperless
      - PAPERLESS_SECRET_KEY=DeinSehrGeheimerSchluessel123!
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000"]
      interval: 30s
      timeout: 10s
      retries: 5

networks:
  default:
    name: paperless_default

Nach docker compose up -d erreichst du Paperless unter http://<deine-server-ip>:8006. Login mit paperless / paperless. Passwort und PAPERLESS_SECRET_KEY bitte vor dem produktiven Einsatz ändern.

KI-Einstellungen aktivieren

Sobald die Beta läuft, klickst du auf dein Benutzer-Icon, dann auf Konfiguration und schließlich auf den Tab KI-Einstellungen. Hier aktivierst du die KI über den Schalter ganz oben und füllst anschließend zwei Blöcke aus:

1. Sprachmodell (LLM) – das „Gehirn“, das Text liest und Vorschläge generiert.
2. Einbettungsmodell (Embedding) – das Vektor-Gedächtnis, mit dem Paperless ähnliche Dokumente findet.

Wichtig zu wissen: Paperless 3.0 hat in der Beta nur ein zentrales Endpunkt-Feld für LLM und Embedding-Modell. Du kannst also nicht das LLM in der Cloud und das Embedding lokal laufen lassen – du musst dich für einen Weg entscheiden. Hier sind die beiden Konfigurationen, die in der Praxis wirklich funktionieren.

Variante A: OpenRouter via API (schnell, aber die Texte gehen in die Cloud)

Wenn dein Paperless auf einem stromsparenden NAS, einem Mini-PC oder generell ohne dicke Grafikkarte läuft, ist das die Variante, die in der Praxis wirklich funktioniert. Statt deine CPU mit den KI-Berechnungen in den berüchtigten 60-Sekunden-Timeout (Fehler 500) zu treiben, lagert OpenRouter die Arbeit auf fremde Hardware aus. Die Antworten kommen in Millisekunden zurück, dafür landen die Textdaten deiner Dokumente eben in der Cloud.

So sehen die Einstellungen aus:

• LLM-Backend: openai-like
• LLM-Modell: z. B. openai/gpt-4o-mini oder google/gemini-2.5-flash (bei OpenRouter immer das Hersteller-Präfix vor den Modellnamen schreiben!)
• LLM Einbettungs-Backend: openai-like
• LLM-Einbettungsmodell: openai/text-embedding-3-small (extrem günstig und schnell für das Vektor-Gedächtnis)
• LLM-Endpunkt: https://openrouter.ai/api/v1
• LLM API-Schlüssel: dein persönlicher OpenRouter-Key (beginnt mit sk-or-v1-…)

Anschließend in OpenRouter unter Settings > Credits ein paar Euro aufladen – für ein paar hundert Dokumente reichen 1–2 € locker.

Variante B: Lokales Ollama (alles bleibt im Haus, dafür langsamer)

Bei dieser Variante verlassen deine Dokumente niemals dein Heimnetzwerk. Paperless spricht direkt mit deinem lokalen Ollama-Container. Der Haken: Textgenerierung ist rechenintensiv. Lässt du Ollama rein über die CPU laufen, solltest du zwingend auf winzige „Fliegengewicht“-Modelle setzen, sonst bricht Paperless die Anfrage nach exakt 60 Sekunden wegen Zeitüberschreitung ab.

Modelle vorher per ollama pull bereitstellen, z. B.:

ollama pull llama3.2:1b
ollama pull nomic-embed-text

Dann in den KI-Einstellungen:

• LLM-Backend: openai-like (ja, auch hier openai-like wählen – das vermeidet Konflikte mit dem internen Ollama-Backend)
• LLM-Modell: llama3.2:1b oder qwen2.5:0.5b (beides winzige, schnelle Modelle, die auch auf CPUs meist unter der 60-Sekunden-Marke bleiben)
• LLM Einbettungs-Backend: openai-like
• LLM-Einbettungsmodell: nomic-embed-text (Standard-Vektormodell, vorher in Ollama per pull herunterladen)
• LLM-Endpunkt: http://<deine-server-ip>:11434/v1 (extrem wichtig: das /v1 am Ende muss zwingend stehen, damit Ollama die Anfragen von Paperless im OpenAI-Kompatibilitätsmodus versteht)
• LLM API-Schlüssel: ollama (Feld darf nicht leer sein, Inhalt egal – wird nicht geprüft)

Pro-Tipp – Fehler 500 nach Modell- oder Variantenwechsel: Wenn du zuvor schon mit anderen Embedding-Modellen experimentiert hast (oder zwischen Variante A und B umschaltest) und beim Klick auf den KI-Zauberstab plötzlich einen hartnäckigen HTTP 500 kassierst, liegt das fast immer an einem Dimensions-Konflikt in der FAISS-Datenbank. Unterschiedliche Einbettungsmodelle nutzen unterschiedlich große Vektoren (z. B. 768 vs. 1536 Zahlen). Den alten Index restlos löschen:

docker exec -it <paperless-container> rm -rf /usr/src/paperless/data/llm_index
docker restart <paperless-container>

Nach dem Neustart baut Paperless den Index im Hintergrund sauber und passend zum neuen Modell neu auf.

FAQ zu Paperless NGX 3.0 und den KI-Funktionen

Kann ich in Paperless NGX 3.0 mit meinen Dokumenten chatten?

Ja. Über das Sprechblasen-Icon oben rechts im Header öffnest du einen RAG-Chat über deinen kompletten Bestand. Paperless sucht intern per Vektor-Index die thematisch passendsten Belege heraus, schickt sie ans LLM und liefert dir die Antwort inklusive verlinkter Quelldokumente. Voraussetzung sind aktivierte KI-Einstellungen mit Sprach- und Einbettungsmodell – beim ersten Mal baut Paperless dafür im Hintergrund einen FAISS-Index über alle Dokumente auf.

Verarbeitet Paperless NGX 3.0 hochgeladene Dokumente automatisch mit KI?

Nein. In der aktuellen Beta erzeugt Paperless keine automatischen KI-Vorschläge beim Upload. Du musst jedes Dokument öffnen und manuell auf „Vorschlagen“ klicken. Auto-Klassifizierung beim Consumer-Upload ist (Stand jetzt) nicht enthalten.

Welche Modelle kann ich in den KI-Einstellungen verwenden?

Du wählst ein Sprachmodell (LLM) und ein Einbettungsmodell. Beide laufen in der aktuellen Beta zwingend über denselben Endpunkt – ein Hybrid aus Cloud-LLM und lokalem Embedding ist also nicht möglich. Du entscheidest dich daher entweder für OpenRouter (schnell, Cloud, z. B. openai/gpt-4o-mini + openai/text-embedding-3-small) oder ein lokales Ollama (Datenschutz, z. B. llama3.2:1b + nomic-embed-text). In beiden Fällen wählst du openai-like als Backend; bei Ollama muss am Endpunkt zwingend /v1 angehängt werden.

Ist Paperless NGX 3.0 stabil genug für den produktiven Einsatz?

Nein, 3.0 ist eine Beta. Datenbankschema und KI-Konfiguration können sich noch ändern. Setze die Beta in einer separaten Test-Instanz mit eigener docker-compose.yaml auf (siehe oben), bevor du sie auf produktive Daten loslässt. Für Produktiv-Setups bleibt die jeweils stabile 2.x-Linie aktuell die richtige Wahl.