Paperless-ngx mit KI erweitern

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Paperless-ngx mit KI behandelt

• Wie Du Paperless-ngx mit Ollama für KI-Funktionen erweiterst.
• Wie automatische Klassifikation, Tagging und Zusammenfassung funktionieren.
• Wie Du Custom Scripts und Post-Consume-Hooks nutzt.
• Praxisbeispiele für Rechnungen, Verträge und Korrespondenz.
• Best Practices für Genauigkeit, Sicherheit und Performance.

Einleitung: Paperless-ngx mit KI verständlich erklärt

Paperless-ngx ist ein Dokumentenmanagement-System: Du scannst Dokumente, Paperless-ngx macht OCR, indexiert sie und macht sie durchsuchbar. Mit KI geht es weiter: Die KI klassifiziert Dokumente automatisch, vergibt Tags, erstellt Zusammenfassungen und extrahiert Metadaten. Statt manuell zu sortieren, macht das die KI.

Dieser Artikel richtet sich an Anwender, die Paperless-ngx mit KI erweitern wollen. Grundlagen findest Du in Dokumenten-Automatisierung und Ollama.

Warum brauche ich Paperless-ngx mit KI?

Paperless-ngx macht OCR und Volltextsuche, aber die Klassifikation ist regelbasiert. Mit KI versteht das System den Inhalt: „Das ist eine Rechnung von Firma X über 1.234 €, fällig am 15.03.” statt nur „Enthält das Wort Rechnung”. Die KI klassifiziert präziser und extrahiert strukturierte Daten.

Paperless-ngx mit KI kurz erklärt

Paperless-ngx verarbeitet Dokumente (OCR, Indexierung). Ein Post-Consume-Script ruft Ollama auf: Die KI klassifiziert, taggt und fasst das Dokument zusammen. Die Ergebnisse werden in Paperless-ngx gespeichert.

Der Kerngedanke lautet: Paperless-ngx verwaltet, KI versteht.

Für wen ist dieser Artikel gedacht?

• Paperless-ngx-Nutzer, die KI-Funktionen wollen.
• Büroarbeiter, die Dokumente automatisch verarbeiten.
• Self-Hoster, die Dokumentenverwaltung mit KI erweitern.
• Unternehmen, die Rechnungen und Verträge automatisieren.

Vorkenntnisse in Paperless-ngx und Ollama sind hilfreich.

Wichtige Begriffe

• Paperless-ngx - Dokumentenmanagement. Wann nützlich: die Basis.
• Ollama - Lokaler Modellserver. Wann nützlich: das KI-Backend.
• Post-Consume Script - Skript nach Dokument-Import. Wann nützlich: für KI-Verarbeitung.
• OCR - Optical Character Recognition. Wann nützlich: für gescannte Dokumente.
• Tags - Schlagworte. Wann nützlich: für Kategorisierung.
• Custom Fields - Eigene Felder. Wann nützlich: für KI-Metadaten.
• RAG - Retrieval-Augmented Generation. Wann nützlich: für Dokumenten-Q&A.

Setup: Paperless-ngx + Ollama

Docker Compose

version: "3.8"

services:
  paperless:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    container_name: paperless
    restart: unless-stopped
    ports:
      - "8000:8000"
    volumes:
      - paperless_data:/usr/src/paperless/data
      - paperless_media:/usr/src/paperless/media
      - ./scripts:/usr/src/paperless/scripts  # Custom Scripts
    environment:
      - PAPERLESS_OCR_LANGUAGE=deu
      - PAPERLESS_POST_CONSUME_SCRIPT=/usr/src/paperless/scripts/post_consume.py
      - PAPERLESS_OLLAMA_URL=http://ollama:11434
    networks:
      - paperless-network

  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    networks:
      - paperless-network

volumes:
  paperless_data:
  paperless_media:
  ollama_data:

networks:
  paperless-network:
    driver: bridge

Post-Consume Script

#!/usr/bin/env python3
# /usr/src/paperless/scripts/post_consume.py
# Wird nach jedem Dokument-Import aufgerufen

import os
import sys
import json
import requests

OLLAMA_URL = os.environ.get("PAPERLESS_OLLAMA_URL", "http://ollama:11434")

def call_ollama(prompt, model="llama3.1", format=None):
    """Ollama aufrufen"""
    body = {
        "model": model,
        "messages": [{"role": "user", "content": prompt}],
        "stream": False
    }
    if format:
        body["format"] = format

    response = requests.post(
        f"{OLLAMA_URL}/api/chat",
        json=body,
        timeout=120
    )
    return response.json()["message"]["content"]

def main():
    # Paperless-ngx gibt Dokument-Info als Argumente
    doc_id = sys.argv[1] if len(sys.argv) > 1 else None
    doc_file = sys.argv[2] if len(sys.argv) > 2 else None

    # Dokument-Text lesen (bereits OCR-verarbeitet)
    text_file = doc_file.replace(".pdf", ".txt")
    if os.path.exists(text_file):
        with open(text_file) as f:
            text = f.read()
    else:
        text = ""

    if not text:
        return

    # 1. Klassifizieren
    category = call_ollama(f"""Klassifiziere das Dokument:
- rechnung: Rechnung, Invoice
- vertrag: Vertrag, Contract
- bericht: Bericht, Report
- korrespondenz: Brief, E-Mail
- sonstiges: Alles andere

Dokument: {text[:3000]}

Antworte nur mit der Kategorie.""")

    # 2. Tags generieren
    tags = call_ollama(f"""Vergib 3-5 Tags für das Dokument.
Dokument: {text[:2000]}
Antworte als JSON-Array: ["tag1", "tag2", ...]""", format="json")

    # 3. Zusammenfassung
    summary = call_ollama(f"""Fasse das Dokument in 3 Sätzen zusammen.
Dokument: {text[:4000]}""")

    # 4. Metadaten extrahieren
    metadata = call_ollama(f"""Extrahiere:
- datum: Dokumentendatum
- absender: Wer hat es erstellt
- betreff: Worum geht es
- betrag: Falls Rechnung, der Betrag

Dokument: {text[:3000]}
Antworte als JSON.""", format="json")

    # Ausgabe für Paperless-ngx
    result = {
        "category": category.strip().lower(),
        "tags": json.loads(tags),
        "summary": summary,
        "metadata": json.loads(metadata)
    }
    print(json.dumps(result))

if __name__ == "__main__":
    main()

Praxisbeispiel 1: Rechnungen automatisch verarbeiten

def process_invoice(text):
    """Rechnung verarbeiten"""
    # Strukturierte Daten extrahieren
    data = call_ollama(f"""Extrahiere aus der Rechnung:
- rechnungsnummer
- datum
- betrag (nur Zahl)
- waehrung
- absender
- faelligkeitsdatum

Rechnung: {text}
Antworte als JSON.""", format="json")

    invoice = json.loads(data)

    # In Datenbank speichern oder als Custom Fields
    save_invoice_metadata(doc_id, invoice)

    # In Ordner verschieben
    move_to_folder(doc_id, "rechnungen")

    return invoice

Praxisbeispiel 2: Verträge analysieren

def analyze_contract(text):
    """Vertrag analysieren"""
    analysis = call_ollama(f"""Analysiere den Vertrag:
1. Vertragsart (Miete, Kauf, Dienstleistung, ...)
2. Vertragspartner
3. Laufzeit
4. Kündigungsfrist
5. Besondere Klauseln
6. Risiken

Vertrag: {text[:6000]}

Antworte als JSON.""", format="json")

    result = json.loads(analysis)

    # Risiken als Kommentar hinzufügen
    if result.get("risiken"):
        add_comment(doc_id, f"Risiken: {result['risiken']}")

    return result

Praxisbeispiel 3: Korrespondenz zusammenfassen

def summarize_correspondence(text):
    """Korrespondenz zusammenfassen"""
    summary = call_ollama(f"""Fasse die Korrespondenz zusammen:
- Wer schreibt an wen?
- Worum geht es?
- Was wird gefordert/angeboten?
- Fristen?

Text: {text[:4000]}""")

    # Als Custom Field speichern
    set_custom_field(doc_id, "zusammenfassung", summary)

    return summary

Workflow: Vollständige Pipeline

Dokument eingescannt/hochgeladen
    │
    ▼
Paperless-ngx OCR
    │
    ▼
Post-Consume Script
    │
    ├─► Ollama: Klassifizieren
    ├─► Ollama: Tags generieren
    ├─► Ollama: Zusammenfassung
    ├─► Ollama: Metadaten extrahieren
    │
    ▼
Paperless-ngx speichert:
  - Tags
  - Custom Fields
  - Kommentare
    │
    ▼
Optional: In Ordner verschieben
Optional: Alert bei kritischen Dokumenten

RAG für Dokumente

def setup_rag(documents):
    """Alle Dokumente für semantische Suche indexieren"""
    for doc in documents:
        # Text in Chunks
        chunks = split_into_chunks(doc.text, 500)

        for i, chunk in enumerate(chunks):
            # Embedding erstellen
            embedding = get_embedding(chunk)

            # In Qdrant speichern
            qdrant.upsert(
                collection="dokumente",
                points=[{
                    "id": f"{doc.id}_{i}",
                    "vector": embedding,
                    "payload": {
                        "doc_id": doc.id,
                        "text": chunk,
                        "title": doc.title
                    }
                }]
            )

Damit kannst Du Fragen an Deine Dokumente stellen:

• „Was steht im Mietvertrag über Kündigung?”
• „Welche Rechnungen sind über 1000 €?”

Siehe Lokales RAG.

Sicherheitshinweise

• Vertrauliche Dokumente: Dokumente können sensible Daten enthalten. Nutze lokale KI, nicht Cloud. Siehe Datenschutz.
• Prompt Injection: Dokumente können Injections enthalten. Siehe Prompt Injection.
• Zugriffskontrolle: Paperless-ngx hat Benutzer- und Gruppenrechte. Nutze sie.
• Audit Logging: Protokolliere alle KI-Verarbeitungen. Siehe Audit Logging.
• Backup: Dokumente und Datenbank regelmäßig sichern. Siehe Backup.

Typische Stolpersteine

• OCR-Fehler: Gescannte Dokumente haben OCR-Fehler. KI-Ergebnisse können dadurch falsch sein.
• Kontextlänge: Große Dokumente müssen chunked werden. Siehe Kontextlänge.
• Falsche Klassifikation: KI kann falsch klassifizieren. Nutze Confidence-Scores oder menschliche Prüfung.
• Performance: Große Dokumente + viele KI-Aufrufe = langsam. Asynchron verarbeiten.
• Script-Fehler: Wenn das Post-Consume-Script fehlschlägt, wird das Dokument nicht verarbeitet. Logging einbauen.

Weiterführende Links

• Dokumenten-Automatisierung - Dokumente mit KI.
• Lokales RAG - Dokumente durchsuchbar machen.
• Ollama - Modellserver.
• PDF und OCR - Dokumente vorbereiten.
• Backup - Datensicherung.
• Prompt Injection - Sicherheit.

Key Takeaways:

• Paperless-ngx + Ollama: OCR + KI-Verständnis.
• Post-Consume Script für automatische Klassifikation, Tagging, Zusammenfassung.
• Strukturierte Datenextraktion für Rechnungen, Verträge, Korrespondenz.
• RAG für semantische Dokumentensuche.
• Sicherheit: Validierung, Zugriffskontrolle, lokale Verarbeitung.

FAQ

Quellen und weiterführende Literatur

• Paperless-ngx - Dokumentation.
• Paperless-ngx Scripts - Post-Consume Scripts.
• Ollama - Lokaler Modellserver.
• Tesseract OCR - OCR-Engine.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert