[email protected]

Paperless-ngx 3 mit KI einrichten: native KI (v3.3) lokal mit Ollama

Paperless-ngx 3 mit KI einrichten: native KI (v3.3) lokal mit Ollama

Hinweis zum Inhalt: Die Informationen in diesem Artikel wurden nach bestem Wissen zum Zeitpunkt der Veröffentlichung zusammengestellt. Technische Details, Preise, Versionen, Lizenzmodelle und externe Inhalte können sich ändern. Bitte prüfen Sie die genannten Angaben eigenständig, insbesondere vor geschäftskritischen oder sicherheitsrelevanten Entscheidungen. Dieser Artikel ersetzt keine individuelle Fach-, Rechts- oder Steuerberatung.

Paperless-ngx mit KI einsetzen? WZ-IT richtet die native KI in Paperless-ngx ein, bindet lokale Modelle an und betreibt die Instanz auf Wunsch dauerhaft, siehe Paperless-ngx bei WZ-IT. Termin vereinbaren

Wer Paperless-ngx mit KI nutzen wollte, brauchte bisher ein Zusatzprojekt wie Paperless-AI. Seit Version 3.0.0 vom 22. Juli 2026 bringt Paperless-ngx die KI selbst mit: Vorschläge für Titel, Tags, Korrespondent und Dokumenttyp, einen Chat über einzelne Dokumente oder das ganze Archiv und einen Vektor-Index für ähnliche Dokumente. Mit Version 3.1.0 kam eine Workflow-Aktion dazu, die diese Vorschläge automatisch anwendet.

Gleichzeitig steht im Repository von Paperless-AI seit März 2026 der Hinweis "This repo is currently not maintained" (clusterzx/paperless-ai). Für neue Installationen ist die native Integration damit der naheliegende Weg, für bestehende Paperless-AI-Setups stellt sich die Frage nach dem Umstieg.

Dieser Beitrag zeigt die Einrichtung mit einem lokalen Ollama-Server per Docker Compose, alle KI-Variablen mit Standardwerten, die Modellwahl für deutsche Dokumente, die automatische Verschlagwortung per Workflow, den Datenfluss und den Umstieg von Paperless-AI. Alle Angaben beziehen sich auf Paperless-ngx 3.3.0 vom 6. Oktober 2026 (Stand Oktober 2026).

Inhaltsverzeichnis

  1. Das Wichtigste in Kürze
  2. Was die native KI in Paperless-ngx kann
  3. Was sich seit Version 3 geändert hat
  4. Voraussetzungen und Hardware
  5. Schritt für Schritt: Paperless-ngx mit Ollama per Docker Compose
  6. Alle KI-Variablen im Überblick
  7. Modellwahl für Generierung und Embeddings
  8. Automatisch verschlagworten mit der Workflow-Aktion
  9. Datenschutz: welche Daten das System verlassen
  10. Native KI vs. Paperless-AI im Vergleich
  11. Umstieg von Paperless-AI
  12. Grenzen im Stand Oktober 2026
  13. Unser Vorgehen bei WZ-IT
  14. Weiterführende Guides

Das Wichtigste in Kürze

Frage Antwort (Paperless-ngx 3.3.0)
Ab welcher Version? 3.0.0 (22.07.2026); Workflow-Aktion ab 3.1.0 (27.08.2026)
Standardmäßig aktiv? nein, PAPERLESS_AI_ENABLED ist false
Backends für das Sprachmodell ollama, openai-like
Backends für Embeddings ollama, huggingface, openai-like
Funktionen KI-Vorschläge, Dokument-Chat, ähnliche Dokumente, Workflow-Aktion "Apply AI Suggestions"
Klassischer Klassifikator bleibt aktiv, KI-Vorschläge kommen hinzu
Konfiguration Umgebungsvariablen PAPERLESS_AI_* oder Oberfläche; der Wert in der Datenbank hat Vorrang
Vektor-Index lokal im Datenverzeichnis (data/llm_index), SQLite mit sqlite-vec
Datenfluss Dokumentinhalt geht an das konfigurierte Modell; lokal bleibt er nur mit lokalem Backend

Quellen: Konfiguration, Abschnitt AI, Advanced Usage, AI features, Release-Übersicht, Quellcode vector_store.py.

Was die native KI in Paperless-ngx kann

Die Dokumentation beschreibt drei Funktionen, die alle optional sind und die bestehende Zuordnung ohne LLM nicht ersetzen (Advanced Usage):

Funktion Was sie tut Voraussetzung
KI-Vorschläge Schlägt Titel, Tags, Korrespondent, Dokumenttyp, Speicherpfad und Datum vor; erscheint im Menü des Vorschlagen-Buttons neben den klassischen Vorschlägen KI aktiviert, LLM-Backend gesetzt
Ähnliche Dokumente und RAG Vektor-Index über Text und Metadaten; Vorschläge stützen sich damit auf ähnliche bestehende Dokumente zusätzlich Embedding-Backend gesetzt
Dokument-Chat Fragen an ein einzelnes Dokument oder an alle sichtbaren Dokumente, mit Links auf die Quelldokumente LLM-Index aktiv
Workflow-Aktion "Apply AI Suggestions" wendet die Vorschläge automatisch und im Hintergrund an ab 3.1.0, KI aktiviert

Zwei Details sind für den Betrieb wichtig:

  • ML, KI oder beides. Seit 3.3.0 legen Nutzer unter Einstellungen > Dokumente fest, welche Vorschläge standardmäßig abgefragt werden: die klassischen ML-Vorschläge des Klassifikators, die KI-Vorschläge oder beide. Bei beiden führt Paperless-ngx die Ergebnisse zusammen; die jeweils andere Art lässt sich über das Menü am Vorschlagen-Button manuell nachfordern (Advanced Usage, AI-assisted suggestions, PR #14258).
  • Vorschläge beim Öffnen. Für Dokumente mit Posteingangs-Tag werden Vorschläge automatisch angefragt, sobald das Dokument geöffnet wird. Seit 3.2.0 lässt sich das unter Einstellungen > Dokumente abschalten (Usage, Document Suggestions). Mit lokalem Modell bedeutet jedes Öffnen eine Anfrage an die GPU.
  • Berechtigungen. Der Chat sucht nur in Dokumenten, die der angemeldete Nutzer sehen darf. Der Quellcode filtert die Vektorsuche auf die erlaubten Dokument-IDs (chat.py). Vorschläge setzen seit 3.0.0 Änderungsrechte am Dokument voraus (Release 3.0.0).

Was sich seit Version 3 geändert hat

Version Datum Relevante KI-Änderungen
3.0.0 22.07.2026 Paperless AI (Vorschläge, Chat, LLM-Index), Ollama-Embeddings, Timeout, Chunk- und Kontextgröße einstellbar, Ausgabesprache, Remote OCR über Azure AI
3.0.5 01.08.2026 Vorschlags-Cache nach Modell und Endpunkt getrennt, leere Felder besser behandelt
3.1.0 27.08.2026 Workflow-Aktion "Apply AI Suggestions"; Vorschläge bevorzugen vorhandene Tags, Typen, Korrespondenten und Speicherpfade; Remote OCR nur für ausgewählte Dokumente möglich
3.1.3 04.09.2026 Workflow-Aktion läuft zuverlässig nach dem Anlegen des Dokuments; Endpunkt für Remote OCR wird validiert
3.2.0 19.09.2026 automatische Vorschläge für Posteingangsdokumente abschaltbar; Dokumente ohne Text werden in der Workflow-Aktion übersprungen; bessere Fehlermeldungen des LLM
3.2.1 20.09.2026 Fehlerbehebungen ohne KI-Bezug (Mailabruf, OCR, Suchindex)
3.3.0 06.10.2026 eigener API-Schlüssel für Embeddings (PAPERLESS_AI_LLM_EMBEDDING_API_KEY); zusätzliche LLM-Parameter per PAPERLESS_AI_LLM_EXTRA_PARAMS; Wahl zwischen ML-, KI- oder kombinierten Vorschlägen; Django-Admin mit Zwei-Faktor-Authentifizierung; Barcode-Inhalte werden gespeichert und sind durchsuchbar

Wer von 2.x kommt, sollte vor dem Update die Breaking Changes von 3.0.0 lesen. Dazu gehören unter anderem der Wegfall der Dokumentverschlüsselung, der API-Version 1 und der Unterstützung für Python 3.10 (Release 3.0.0). Für Docker-Installationen gilt wie immer: erst sichern, dann das Image aktualisieren.

Voraussetzungen und Hardware

  • Paperless-ngx ab 3.1.0, besser die aktuelle 3.3.0, wenn die Workflow-Aktion genutzt werden soll. Wie eine Installation mit Docker und Caddy aufgesetzt wird, zeigt der Guide Paperless-ngx auf Ubuntu mit Caddy.
  • Ollama als Container auf demselben Host oder als eigener Server im internen Netz (Ollama, Docker). Auf einem anderen Server sollte der Ollama-Port nur aus dem Paperless-Netz erreichbar sein. Warum ein offen erreichbares Ollama ein Risiko ist, zeigt der Beitrag zu Bleeding Llama.
  • GPU für brauchbare Antwortzeiten. Ollama läuft auch auf der CPU, Vorschläge dauern dann aber deutlich länger. Für NVIDIA-GPUs im Container ist das NVIDIA Container Toolkit nötig.

Zur Größenordnung: Das Modell muss samt Kontext in den GPU-Speicher passen. Die Downloadgrößen aus der Ollama-Bibliothek geben die Untergrenze an:

Modell (Ollama) Zweck Download Kontextfenster
gemma3:4b Generierung, klein 3,3 GB 128K
gemma3:12b Generierung, mittel 8,1 GB 128K
qwen3:8b Generierung, mittel 5,2 GB 40K
llama3.1:8b Standard von Paperless-ngx für Ollama 4,9 GB 128K
bge-m3 Embeddings, mehrsprachig 1,2 GB 8K
embeddinggemma Standard-Embedding von Paperless-ngx für Ollama 622 MB 2K

Paperless-ngx sendet standardmäßig einen Kontext von 8.192 Token an Ollama (PAPERLESS_AI_LLM_CONTEXT_SIZE, für Ollama als num_ctx). Der Speicherbedarf liegt daher über der Downloadgröße. Wie sich GPU-Speicher für Modelle und Kontext berechnen lässt, erklärt der Artikel GPU-VRAM für LLMs dimensionieren.

Schritt für Schritt: Paperless-ngx mit Ollama per Docker Compose

Grundlage ist die offizielle docker-compose.postgres.yml. Ergänzt werden ein Ollama-Dienst und die KI-Variablen im Dienst webserver.

1. Compose-Datei erweitern

services:
  broker:
    image: docker.io/valkey/valkey:9-alpine
    restart: unless-stopped
    volumes:
      - redisdata:/data

  db:
    image: docker.io/library/postgres:18
    restart: unless-stopped
    volumes:
      - pgdata:/var/lib/postgresql
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: paperless   # in Produktion ändern

  ollama:
    image: docker.io/ollama/ollama:latest
    restart: unless-stopped
    volumes:
      - ollama:/root/.ollama
    # kein "ports:" nötig, Paperless erreicht Ollama über das Compose-Netz
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest   # in Produktion auf eine Version festlegen
    restart: unless-stopped
    depends_on:
      - db
      - broker
      - ollama
    ports:
      - "8000:8000"
    volumes:
      - data:/usr/src/paperless/data
      - media:/usr/src/paperless/media
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    env_file: docker-compose.env
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db
      PAPERLESS_DBENGINE: postgresql
      # KI
      PAPERLESS_AI_ENABLED: "true"
      PAPERLESS_AI_LLM_BACKEND: ollama
      PAPERLESS_AI_LLM_ENDPOINT: http://ollama:11434
      PAPERLESS_AI_LLM_MODEL: gemma3:12b
      PAPERLESS_AI_LLM_EMBEDDING_BACKEND: ollama
      PAPERLESS_AI_LLM_EMBEDDING_MODEL: bge-m3
      PAPERLESS_AI_LLM_REQUEST_TIMEOUT: "300"

volumes:
  data:
  media:
  pgdata:
  redisdata:
  ollama:

Der Block deploy.resources.reservations.devices reserviert die NVIDIA-GPU für den Ollama-Container (Docker, GPU-Unterstützung in Compose). Ohne GPU wird er entfernt. Läuft Ollama auf einem anderen Server, entfällt der Dienst ollama, und PAPERLESS_AI_LLM_ENDPOINT zeigt auf dessen interne Adresse.

2. Starten und Modelle laden

docker compose pull
docker compose up -d
docker compose exec ollama ollama pull gemma3:12b
docker compose exec ollama ollama pull bge-m3

3. LLM-Index aufbauen

Der Index wird beim ersten Aktivieren und nach jedem Wechsel des Embedding-Modells komplett neu aufgebaut (Administration, LLM-Index):

docker compose exec webserver document_llmindex rebuild

Danach hält ein geplanter Task den Index aktuell, standardmäßig täglich um 02:10 Uhr (PAPERLESS_LLM_INDEX_TASK_CRON, Standard 10 2 * * *). Bei großen Archiven dauert der erste Aufbau entsprechend lange; die Embeddings laufen über dieselbe GPU wie die Vorschläge.

4. In der Oberfläche prüfen

  • Ein Dokument öffnen und das Menü neben dem Vorschlagen-Button aufklappen. Die KI-Vorschläge erscheinen dort zusätzlich zu den klassischen Vorschlägen.
  • Den Chat in der oberen Leiste öffnen. In der Detailansicht bezieht er sich auf das geöffnete Dokument, in Listen auf alle sichtbaren Dokumente.

Die KI-Einstellungen lassen sich auch unter Einstellungen > Anwendungskonfiguration setzen. Werte in der Datenbank haben Vorrang vor den Umgebungsvariablen (Advanced Usage). Wer die Konfiguration in Compose pflegt, sollte die Felder in der Oberfläche leer lassen, sonst wirkt eine Änderung in der Compose-Datei nicht.

5. Bei Updates

Seit Version 3 gehört die Migration des LLM-Index zum Update-Ablauf. Im Docker-Image läuft document_llmindex migrate beim Start des Containers automatisch (Init-Skript init-llmindex-migrate). Bei Bare-Metal-Installationen ist der Befehl ein eigener Schritt nach der Datenbankmigration (Administration, Updating).

Der Index liegt im Volume data unter llm_index und gehört damit in die bestehende Sicherung.

Alle KI-Variablen im Überblick

Variable Standard Bedeutung
PAPERLESS_AI_ENABLED false Hauptschalter für alle KI-Funktionen
PAPERLESS_AI_LLM_BACKEND keiner ollama oder openai-like; ohne diesen Wert keine KI
PAPERLESS_AI_LLM_MODEL keiner; intern llama3.1 (Ollama) bzw. gpt-3.5-turbo (openai-like) Modell für Vorschläge und Chat; immer explizit setzen (siehe unten)
PAPERLESS_AI_LLM_ENDPOINT keiner URL des Backends; für Ollama Pflicht
PAPERLESS_AI_LLM_API_KEY keiner API-Schlüssel, in der Regel nur für openai-like
PAPERLESS_AI_LLM_EMBEDDING_BACKEND keiner ollama, huggingface oder openai-like; aktiviert den LLM-Index
PAPERLESS_AI_LLM_EMBEDDING_MODEL keiner; intern embeddinggemma (Ollama), sentence-transformers/all-MiniLM-L6-v2 (Hugging Face), text-embedding-3-small (openai-like) Embedding-Modell
PAPERLESS_AI_LLM_EMBEDDING_API_KEY Wert von PAPERLESS_AI_LLM_API_KEY eigener API-Schlüssel für Embeddings (ab 3.3.0)
PAPERLESS_AI_LLM_EMBEDDING_ENDPOINT Wert von PAPERLESS_AI_LLM_ENDPOINT eigener Endpunkt für Embeddings
PAPERLESS_AI_LLM_EMBEDDING_CHUNK_SIZE 1024 Größe der Textabschnitte für Embeddings
PAPERLESS_AI_LLM_CONTEXT_SIZE 8192 Kontextgröße für Prompts und RAG; bei Ollama als num_ctx gesendet
PAPERLESS_AI_LLM_REQUEST_TIMEOUT 120 Zeitlimit in Sekunden je Anfrage
PAPERLESS_AI_LLM_OUTPUT_LANGUAGE keiner (Sprache der Oberfläche) Sprache der Vorschläge
PAPERLESS_AI_LLM_ALLOW_INTERNAL_ENDPOINTS true false blockiert Endpunkte mit internen Adressen
PAPERLESS_AI_LLM_EXTRA_PARAMS leer JSON-Objekt mit zusätzlichen Parametern für jede LLM-Anfrage, ungeprüft durchgereicht (ab 3.3.0)
PAPERLESS_LLM_INDEX_TASK_CRON 10 2 * * * Zeitplan für die Aktualisierung des Index

Quelle: Paperless-ngx Konfiguration, Abschnitt AI, Stand Version 3.3.0.

Modell immer setzen. Ohne PAPERLESS_AI_LLM_MODEL fällt Paperless-ngx bei openai-like auf gpt-3.5-turbo zurück. OpenAI schaltet gpt-3.5-turbo und gpt-4 am 23. Oktober 2026 ab (OpenAI, Deprecations). Danach schlagen KI-Anfragen ohne explizites Modell fehl. Das gilt auch für OpenAI-kompatible Gateways, die den Modellnamen an OpenAI weiterreichen.

Zu PAPERLESS_AI_LLM_EXTRA_PARAMS: Der Wert überschreibt die von Paperless-ngx selbst gesetzten Parameter und wird ohne Prüfung an das Backend übergeben. Die Dokumentation nennt als Beispiel {"reasoning_effort": "none"} für Reasoning-Modelle von OpenAI (Konfiguration).

Zu PAPERLESS_AI_LLM_ALLOW_INTERNAL_ENDPOINTS: Für ein lokales Ollama muss der Wert auf true bleiben, sonst blockiert Paperless-ngx Adressen wie http://ollama:11434. Auf false gehört er nur, wenn ausschließlich ein externer Anbieter genutzt wird und Anfragen ins interne Netz ausgeschlossen sein sollen.

Modellwahl für Generierung und Embeddings

Paperless-ngx nutzt zwei getrennte Modelle. Das Wiki des Projekts gibt dazu Hinweise, aber ausdrücklich keine Benchmarks (AI Model Recommendations):

  • Generierungsmodell (PAPERLESS_AI_LLM_MODEL): ein Instruktions- oder Chatmodell, das strukturierte Ausgaben zuverlässig liefert. Mit einem kleinen Modell beginnen und nur dann größer werden, wenn die Qualität nicht reicht.
  • Embedding-Modell (PAPERLESS_AI_LLM_EMBEDDING_MODEL): Das Standardmodell für Hugging Face, all-MiniLM-L6-v2, ist für überwiegend englische Archive gedacht. Für mehrsprachige Archive nennt das Wiki intfloat/multilingual-e5-small, intfloat/multilingual-e5-base und BAAI/bge-m3.

Für ein deutschsprachiges Archiv folgt daraus:

Entscheidung Empfehlung
Embeddings über Ollama bge-m3 (mehrsprachig, 8K Kontext) statt des Standards embeddinggemma mit 2K Kontext
Embeddings ohne Ollama huggingface mit intfloat/multilingual-e5-small; läuft im Paperless-Container und lädt das Modell beim ersten Start herunter
Generierung, Einstieg ein mehrsprachiges Modell mittlerer Größe wie gemma3:12b oder qwen3:8b, an eigenen Dokumenten testen
Neuere Kandidaten gemma4 und qwen3.8 sind in der Ollama-Bibliothek verfügbar; vor dem Einsatz an einer Stichprobe prüfen
Zeitüberschreitungen laut Wiki zuerst ein kleineres Modell testen, dann PAPERLESS_AI_LLM_REQUEST_TIMEOUT erhöhen
Wechsel des Embedding-Modells Index mit document_llmindex rebuild neu aufbauen

Getestet wird am besten mit einer Stichprobe typischer Dokumente: Rechnungen, Verträge, Behördenpost, Scans schlechter Qualität. Wie sich Modelle für den Selbstbetrieb einordnen lassen, beschreibt der Artikel Welches LLM selbst hosten?. Ist bereits die Texterkennung das Problem, hilft der Vergleich Vision-Language-Modelle für OCR.

Automatisch verschlagworten mit der Workflow-Aktion

Die Vorschläge allein ändern nichts am Dokument. Für eine automatische Zuordnung gibt es seit 3.1.0 die Workflow-Aktion "Apply AI Suggestions" (Usage, Workflows). Sie fragt dieselben Vorschläge ab wie die Dokumentansicht und wendet sie an.

Option Verhalten
Felder Titel, Tags, Korrespondent, Dokumenttyp, Speicherpfad und Erstellungsdatum einzeln wählbar; nicht gewählte Vorschläge werden verworfen
Fehlende Elemente anlegen standardmäßig aus: nur vorhandene Tags, Korrespondenten und Dokumenttypen werden zugewiesen; Speicherpfade werden nie angelegt
Bestehende Werte überschreiben standardmäßig aus: nur leere Felder werden befüllt; Titel und Datum sind fast immer gesetzt, für diese Felder muss Überschreiben aktiv sein
Tags werden immer ergänzt, nie ersetzt
Trigger alle außer "Consumption Started", weil der Text erst nach der Verarbeitung vorliegt
Ausführung im Hintergrund als eigene Aufgabe; Dokumente ohne Text werden übersprungen

Ein bewährter Aufbau für den Einstieg:

  1. Trigger "Document Added", gefiltert auf den Posteingangs-Tag oder einen Eingangsordner.
  2. Aktion "Apply AI Suggestions" mit Korrespondent, Dokumenttyp und Tags, "Fehlende Elemente anlegen" aus.
  3. Zweite Aktion (Zuweisung): ein Tag wie ki-vorschlag, damit sich KI-bearbeitete Dokumente gezielt prüfen lassen.
  4. Nach einigen Wochen Stichproben auswerten und erst dann Titel und Datum mit Überschreiben hinzunehmen.

Die Dokumentation weist darauf hin, dass jedes passende Dokument eine Anfrage an das Modell auslöst. Ein Workflow über das gesamte Archiv kann die Aufgabenwarteschlange lange belegen und die Verarbeitung neuer Dokumente verzögern. Für Altbestände deshalb in kleinen Tranchen arbeiten.

Datenschutz: welche Daten das System verlassen

Paperless-ngx sendet für Vorschläge, Chat und Embeddings den Dokumentinhalt und Metadaten an das konfigurierte Backend (Usage, AI Features). Wohin die Daten gehen, hängt allein von der Konfiguration ab:

Konfiguration Datenfluss Einordnung
ollama auf demselben Host oder im internen Netz bleibt im eigenen Netz geeignet für vertrauliche Dokumente
huggingface für Embeddings lokal im Paperless-Container; nur der erste Modelldownload braucht Internet lokal
openai-like mit selbst betriebenem Server (vLLM, LiteLLM vor eigener Inferenz) bleibt im eigenen Netz lokal, sofern das Gateway keine Cloud-Modelle anbindet
openai-like mit Cloud-Anbieter Dokumentinhalte gehen an den Anbieter Auftragsverarbeitung, Drittlandtransfer und Kosten prüfen
Remote OCR (PAPERLESS_REMOTE_OCR_ENGINE=azureai) die Dokumentdateien gehen an Microsoft Azure AI Document Intelligence eigene Prüfung nötig, unabhängig von der LLM-Wahl

Remote OCR ist eine eigene Funktion aus Version 3.0.0 und standardmäßig aus (Usage, Remote OCR). Ist sie aktiv, werden im Modus always alle unterstützten Dokumente an Azure gesendet. Seit 3.1.0 lässt sich mit PAPERLESS_REMOTE_OCR_MODE=workflow_only auf einzelne Dokumente per Workflow beschränken. Wer lokale KI wegen des Datenschutzes wählt, sollte Remote OCR nicht nebenbei aktivieren.

Die Dokumentation behandelt Dokumentinhalte gegenüber dem Modell als nicht vertrauenswürdige Daten. Ein Dokument kann Text enthalten, der wie eine Anweisung an das Modell formuliert ist. Bei automatischen Workflows ist das ein Argument, "Fehlende Elemente anlegen" und "Überschreiben" zurückhaltend zu nutzen. Hintergrund dazu im Artikel Prompt Injection: Schutz für KI-Anwendungen.

Native KI vs. Paperless-AI im Vergleich

Merkmal Native KI in Paperless-ngx 3.3.0 Paperless-AI 3.0.9
Wartung Teil des Hauptprojekts, regelmäßige Releases laut Repository nicht in Wartung (Hinweis seit 31.03.2026), letztes Release 04.11.2025
Installation Umgebungsvariablen im bestehenden Container eigener Container mit API-Token und eigener Weboberfläche
Backends ollama, openai-like Ollama, OpenAI und OpenAI-kompatible Anbieter
Vorschläge in der Paperless-Oberfläche ja, im Vorschlagen-Menü nein, eigene Oberfläche (/manual)
Automatische Verarbeitung Workflow-Aktion mit Paperless-Triggern und -Filtern eigene Abfrage per Zeitplan (Standard alle 30 Minuten) mit Tag-Filter
Felder Titel, Tags, Korrespondent, Dokumenttyp, Speicherpfad, Datum Titel, Tags, Korrespondent, Dokumenttyp, Datum, benutzerdefinierte Felder
Vorschlagsart ML, KI oder beides wählbar (ab 3.3.0) nur KI
Eigener Prompt keine dokumentierte Einstellung frei anpassbarer System-Prompt
Chat in der Paperless-Oberfläche, mit Links auf die Quelldokumente eigene Chat-Oberfläche mit RAG
Berechtigungen Chat und Vorschläge folgen den Rechten des angemeldeten Nutzers alle Dokumente, die der Nutzer des API-Tokens sieht
Vektor-Index im Paperless-Datenverzeichnis, Teil der normalen Sicherung eigener Datenbestand im Paperless-AI-Container

Quellen: Paperless-ngx Advanced Usage, Paperless-AI README, Paperless-AI Beispielkonfiguration, Paperless-AI Releases.

Paperless-AI hatte nur dort einen Vorteil, wo ein eigener System-Prompt oder das Befüllen benutzerdefinierter Felder gebraucht wird. Dem steht ein Projekt ohne Sicherheitsupdates gegenüber, das mit einem API-Token weitreichenden Zugriff auf das Archiv hat.

Für diese beiden Anforderungen gibt es eine gepflegte Alternative: paperless-gpt (MIT-Lizenz, aktuell v0.30.0 vom 12. Oktober 2026). Es bietet über die Weboberfläche anpassbare Prompts, seit v0.30.0 KI-Workflows mit eigenen Prompts je Dokumentart, das Befüllen benutzerdefinierter Felder, das Verknüpfen zusammengehöriger Dokumente über Dokumentlink-Felder und durchsuchbare PDFs, die mit Paperless-ngx 3.x als neue Version desselben Dokuments abgelegt werden (README, Releases). Wie Paperless-AI läuft es als eigener Container mit API-Token.

Umstieg von Paperless-AI

Der Umstieg lässt sich ohne Datenverlust in sechs Schritten durchführen. Paperless-AI schreibt seine Ergebnisse direkt in Paperless-ngx; Tags, Korrespondenten und Titel bleiben also erhalten.

  1. Sichern und aktualisieren. Paperless-ngx sichern, Breaking Changes von 3.0.0 prüfen und auf 3.3.0 aktualisieren.
  2. Konfiguration festhalten. Aus der Paperless-AI-Konfiguration notieren: Modell und Endpunkt (OLLAMA_API_URL, OLLAMA_MODEL bzw. CUSTOM_BASE_URL), den Filter-Tag (TAGS), den Verarbeitet-Tag (AI_PROCESSED_TAG_NAME) und eigene Anpassungen am SYSTEM_PROMPT.
  3. Paperless-AI stoppen. Den Container anhalten, aber noch nicht löschen. So laufen nicht zwei Systeme parallel auf denselben Dokumenten.
  4. Native KI aktivieren. Den bisherigen Ollama-Endpunkt als PAPERLESS_AI_LLM_ENDPOINT eintragen, Embedding-Backend setzen und document_llmindex rebuild ausführen.
  5. Workflow nachbauen. Den bisherigen Filter-Tag als Workflow-Filter verwenden, "Apply AI Suggestions" mit den bisher genutzten Feldern anlegen und den Verarbeitet-Tag über eine Zuweisungsaktion setzen.
  6. Prüfen und abbauen. Eine Stichprobe von neuen Dokumenten vergleichen. Danach den Paperless-AI-Container und seine Daten entfernen und den API-Token in Paperless-ngx widerrufen.

Was sich nicht in die native KI übertragen lässt: ein angepasster System-Prompt und die Befüllung benutzerdefinierter Felder. Wer darauf angewiesen ist, prüft paperless-gpt als gepflegte Alternative und klärt das vor dem Umstieg mit den Fachbereichen. Die bisherigen Anleitungen zu Paperless-AI und zum Paperless-AI-Installer bleiben für bestehende Installationen verfügbar.

Grenzen im Stand Oktober 2026

Einige Einschränkungen aus der Zeit von Version 3.0 bestehen in 3.3.0 weiter. Sie sind im Quellcode nachvollziehbar:

Punkt Stand in 3.3.0 Beleg
Quellenangaben im Chat höchstens drei referenzierte Dokumente je Antwort; die Suche greift auf fünf Textabschnitte zurück MAX_CHAT_REFERENCES = 3, CHAT_RETRIEVER_TOP_K = 5 in chat.py
Gesprächsverlauf jede Frage wird einzeln gesendet; der Verlauf liegt nur im Browser und ist nach dem Neuladen weg Anfrage enthält nur Dokument-ID und Frage, chat.service.ts
Formatierung Antworten werden als reiner Text angezeigt, ohne Markdown-Darstellung chat.component.html
Backends nur ollama und openai-like; andere Anbieter über einen OpenAI-kompatiblen Endpunkt Konfiguration
Prompts keine dokumentierte Einstellung für eigene Prompts; PAPERLESS_AI_LLM_EXTRA_PARAMS ändert nur Anfrageparameter Konfiguration
Benutzerdefinierte Felder nicht Teil der KI-Vorschläge Usage, Workflows

Für die Praxis heißt das: Vorschläge und die Workflow-Aktion sind mit Prüfschritt für den produktiven Einsatz geeignet. Der Chat taugt als Suchhilfe für Fragen wie "Wann endet der Mietvertrag?", ersetzt aber keine Recherche über viele Dokumente mit vollständiger Quellenliste. Wer das braucht, setzt auf eine eigene RAG-Anwendung, wie im Artikel Dokumente mit KI verarbeiten beschrieben.

Unser Vorgehen bei WZ-IT

WZ-IT betreibt Paperless-ngx für Unternehmen und richtet die KI-Anbindung ein. Bei einer Einführung der nativen KI gehen wir in fünf Schritten vor:

  1. Bestand aufnehmen. Version, Dokumentenmenge, Sprachen, vorhandene Regeln und eine eventuell laufende Paperless-AI-Installation erfassen.
  2. Modellstandort festlegen. Je nach Vertraulichkeit Ollama auf vorhandener Hardware, einem GPU-Server oder einem AI Cube im eigenen Haus; Cloud-APIs nur nach ausdrücklicher Entscheidung.
  3. Einrichten und testen. Update auf 3.3.0, KI-Variablen setzen, Index aufbauen und Vorschläge an einer Stichprobe mit den Fachbereichen bewerten.
  4. Workflows aufbauen. Automatische Zuordnung mit Prüf-Tag, Altbestand in Tranchen, Paperless-AI kontrolliert abbauen.
  5. Betreiben. Updates inklusive Index-Migration, Sicherung von Dokumenten und Index, Monitoring der Aufgabenwarteschlange.

Managed Open Source wie Paperless-ngx kostet bei WZ-IT ab 99,90 € netto je Workload und Monat (Managed Open Source). Für lokale Modelle mit sensiblen Dokumenten steht der AI Cube für 9.999 € netto einmalig plus AI Cube Care ab 349,90 € netto im Monat zur Verfügung. Support, Beratung und Implementierung durch WZ-IT.

Weiterführende Guides

Paperless-ngx mit lokaler KI einführen? Wir richten die native KI ein, übertragen eine bestehende Paperless-AI-Konfiguration in Workflows und betreiben die Instanz auf Wunsch dauerhaft. Termin vereinbaren

Quellen

Timo Wevelsiep

Geschrieben von

Timo Wevelsiep

Co-Founder & CEO

Co-Founder von WZ-IT. Spezialisiert auf Cloud-Infrastruktur, Open-Source-Plattformen und Managed Services für KMUs und Enterprise-Kunden weltweit.

Häufig gestellte Fragen

Antworten auf wichtige Fragen zu diesem Thema

Kunden aus Mittelstand, Industrie und öffentlicher Hand, in Deutschland und international

  • Stadtwerke Brühl
  • DGHO e.V.
  • solarwerkstatt berlin
  • Krüger Dirndl
  • ABCO Water Systems
  • Golem.de
  • EVADXB
  • nextGYM
  • AInergy
  • ml&s
  • Odiseo Solutions
  • Annota
  • ARGE
  • SweetConnect GmbH
  • Aphy AG
  • CORGOS
  • Rekorder
  • SolidProof
  • Yonju
  • Keymate
  • Paritel
  • Mr. Clipart
  • Millenium
  • Negosh
  • Führerscheinmacher
  • BTI
  • Deutsche Gesellschaft für Datenschutz
Kundenstimmen ansehen

Anfrage

KI in Paperless-ngx einrichten oder betreiben lassen

Wir aktivieren die native KI in Ihrer Paperless-ngx-Instanz, binden ein lokales Modell an, richten Workflows für die automatische Verschlagwortung ein und übernehmen auf Wunsch den laufenden Betrieb.

  • Sie sprechen direkt mit Timo und Robin, den technisch Verantwortlichen
  • Fachliche Einschätzung Ihrer Situation
  • Konkrete nächste Schritte für Infrastruktur, Software oder KI

Das Gespräch ist kostenfrei und unverbindlich.

Die Beratung von WZ-IT zu unserer Azure-Migration war schon im Erstgespräch fachlich sehr fundiert und völlig unverbindlich - wir haben eine Menge mitgenommen.
Jakob ÖschlbergerInno7 GmbH
Timo und Robin, Gründer von WZ-IT

Wo stehen Sie mit Paperless-ngx?

Die Beratung von WZ-IT zu unserer Azure-Migration war schon im Erstgespräch fachlich sehr fundiert und völlig unverbindlich - wir haben eine Menge mitgenommen.
Jakob ÖschlbergerInno7 GmbH