Paperless NGX Docker Setup 2025: Vom Papier zur KI

# Paperless-Verzeichnis erstellen
mkdir -p paperless/{data,media,export,consume}
cd paperless

# Docker Compose Datei erstellen
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  paperless-db:
    image: postgres:15
    restart: unless-stopped
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: paperless_password_2025

  paperless-redis:
    image: redis:7-alpine
    restart: unless-stopped

  paperless-webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      - paperless-db
      - paperless-redis
    ports:
      - "8000:8000"
    volumes:
      - ./data:/usr/src/paperless/data
      - ./media:/usr/src/paperless/media
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    environment:
      PAPERLESS_REDIS: redis://paperless-redis:6379
      PAPERLESS_DBHOST: paperless-db
      PAPERLESS_DBNAME: paperless
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS: paperless_password_2025
      PAPERLESS_SECRET_KEY: change-me-to-random-string
      PAPERLESS_OCR_LANGUAGE: deu+eng
      PAPERLESS_ADMIN_USER: admin
      PAPERLESS_ADMIN_PASSWORD: admin_password_2025
      PAPERLESS_TIME_ZONE: Europe/Berlin
EOF

# Container starten
docker compose up -d

# Logs verfolgen
docker compose logs -f paperless-webserver

# Status prüfen
docker compose ps

# Web-Interface öffnen
echo "Paperless läuft auf: http://localhost:8000"
echo "Login: admin / admin_password_2025"

# Test-PDF in consume-Ordner kopieren
cp /path/to/your/document.pdf ./consume/

# Oder via Web-Interface hochladen:
# 1. Paperless öffnen (http://localhost:8000)
# 2. Auf "+" klicken
# 3. "Upload" wählen
# 4. PDF-Datei auswählen
# 5. Warten bis OCR abgeschlossen

# Verarbeitung überwachen
docker compose logs -f paperless-webserver | grep "Consuming"

# OCR-Test mit verschiedenen Dokumenttypen
mkdir test-documents
cd test-documents

# Test 1: Hochauflösende Rechnung
# Test 2: Handschriftliche Notizen (schwierig)
# Test 3: Fax-Qualität (sehr schwierig)
# Test 4: Screenshot von PDF (optimal)

# OCR-Logs überwachen
docker compose logs -f paperless-webserver | grep -E "(OCR|tesseract)"

# Erkennungsqualität prüfen im Web-Interface:
# 1. Dokument öffnen
# 2. "Details" Tab
# 3. "OCR-Text" anzeigen
# 4. Mit Original vergleichen

# Beispiel-Regeln für automatisches Tagging:

# Regel 1: Rechnungen erkennen
# Bedingung: Text enthält "Rechnung" ODER "Invoice" ODER "Betrag"
# Aktion: Tag "Rechnung" hinzufügen

# Regel 2: Bankauszüge
# Bedingung: Korrespondent = "Sparkasse" UND Text enthält "Kontoauszug"
# Aktion: Tags "Bank" + "Kontoauszug" hinzufügen

# Regel 3: Versicherung
# Bedingung: Text enthält "Police" ODER "Versicherung" ODER "Schaden"
# Aktion: Tag "Versicherung" hinzufügen

# Regel 4: Steuern
# Bedingung: Korrespondent = "Finanzamt" ODER Text enthält "Steuernummer"
# Aktion: Tags "Steuern" + "Behörde" hinzufügen

# Workflow-Beispiele mit Paperless API

# 1. Backup-Workflow (täglich um 2 Uhr)
0 2 * * * docker exec paperless-webserver python manage.py document_exporter /backup/

# 2. Steuerberatung-Export (monatlich)
0 0 1 * * curl -X GET "http://localhost:8000/api/documents/?tags__name=Steuern" 

# 3. Rechnung-Benachrichtigung
# Webhook bei neuen Rechnungen über 1000€
curl -X POST "http://localhost:8000/api/webhooks/" \
  -H "Content-Type: application/json" \
       -d '{
    "url": "https://hooks.slack.com/your-webhook",
    "conditions": [
      {"field": "tags", "value": "Rechnung"},
      {"field": "content", "contains": "€"}
    ]
  }'

# 4. DATEV-Integration
# Export für Buchhaltungssoftware
python export_datev.py --from=2024-01-01 --to=2024-12-31

# Paperless NGX REST API Beispiele

# 1. Alle Dokumente abrufen
curl -H "Authorization: Token YOUR_API_TOKEN" \
     http://localhost:8000/api/documents/

# 2. Dokument hochladen
curl -X POST \
     -H "Authorization: Token YOUR_API_TOKEN" \
     -F "document=@/path/to/file.pdf" \
     -F "title=Neue Rechnung" \
     -F "tags=Rechnung,Amazon" \
     http://localhost:8000/api/documents/post_document/

# 3. Suche nach Dokumenten
curl -H "Authorization: Token YOUR_API_TOKEN" \
     "http://localhost:8000/api/documents/?query=Amazon&ordering=-created"

# 4. Tags verwalten
curl -X POST \
     -H "Authorization: Token YOUR_API_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"name": "Neue Kategorie", "color": "#ff0000"}' \
     http://localhost:8000/api/tags/

# 5. Bulk-Export
curl -H "Authorization: Token YOUR_API_TOKEN" \
     "http://localhost:8000/api/documents/?format=zip" \
     -o documents_export.zip

# Vollständiges Backup-Skript
#!/bin/bash

BACKUP_DIR="/backup/paperless/$(date +%Y-%m-%d)"
mkdir -p $BACKUP_DIR

# 1. Container stoppen
docker compose stop

# 2. Datenbank-Dump
docker compose exec paperless-db pg_dump -U paperless paperless > $BACKUP_DIR/database.sql

# 3. Dateien sichern
cp -r ./data $BACKUP_DIR/
cp -r ./media $BACKUP_DIR/
cp -r ./export $BACKUP_DIR/
cp docker-compose.yml $BACKUP_DIR/

# 4. Container starten
docker compose start

# 5. Backup komprimieren
tar -czf $BACKUP_DIR.tar.gz $BACKUP_DIR
rm -rf $BACKUP_DIR

# 6. Alte Backups löschen (älter als 30 Tage)
find /backup/paperless/ -name "*.tar.gz" -mtime +30 -delete

echo "Backup erstellt: $BACKUP_DIR.tar.gz"