fix: downgrade to PaddleOCR 2.x — 3.x uses too much RAM on CPU

PaddlePaddle 3.x + PP-OCRv5 requires >6GB RAM and has oneDNN
compatibility issues on CPU. PaddleOCR 2.x with PP-OCRv4 works
reliably with ~2-3GB RAM and has no MKLDNN issues.

- Pin paddlepaddle<3.0.0 and paddleocr<3.0.0
- Simplify main.py — single init strategy, direct 2.x result format
- Re-enable warmup (fits in memory with 2.x)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.claude/CLAUDE.md

@@ -2,28 +2,53 @@
 
 ## Entwicklungsumgebung (WICHTIG - IMMER ZUERST LESEN)
 
-### Zwei-Rechner-Setup
+### Zwei-Rechner-Setup + Coolify
 
 | Geraet | Rolle | Aufgaben |
 |--------|-------|----------|
 | **MacBook** | Entwicklung | Claude Terminal, Code-Entwicklung, Browser (Frontend-Tests) |
-| **Mac Mini** | Server | Docker, alle Services, Tests, Builds, Deployment |
+| **Mac Mini** | Lokaler Server | Docker fuer lokale Dev/Tests (NICHT fuer Production!) |
+| **Coolify** | Production | Automatisches Build + Deploy bei Push auf gitea |
 
-**WICHTIG:** Code wird direkt auf dem MacBook in diesem Repo bearbeitet. Docker und Services laufen auf dem Mac Mini.
+**WICHTIG:** Code wird direkt auf dem MacBook in diesem Repo bearbeitet. Production-Deployment laeuft automatisch ueber Coolify.
 
-### Entwicklungsworkflow
+### Entwicklungsworkflow (CI/CD — Coolify)
 
 ```bash
 # 1. Code auf MacBook bearbeiten (dieses Verzeichnis)
-# 2. Committen und pushen:
+# 2. Committen und zu BEIDEN Remotes pushen:
 git push origin main && git push gitea main
 
-# 3. Auf Mac Mini pullen und Container neu bauen:
+# 3. FERTIG! Push auf gitea triggert automatisch:
+#    - Gitea Actions: Tests
+#    - Coolify: Build → Deploy
+```
+
+**NIEMALS** manuell in Coolify auf "Redeploy" klicken — Gitea Actions triggert Coolify automatisch.
+**IMMER auf `main` pushen** — sowohl origin als auch gitea.
+
+### Post-Push Deploy-Monitoring (PFLICHT nach jedem Push auf gitea)
+
+**IMMER wenn Claude auf gitea pusht, MUSS danach automatisch das Deploy-Monitoring laufen:**
+
+1. Dem User sofort mitteilen: "Deploy gestartet, ich ueberwache den Status..."
+2. Im Hintergrund Health-Checks pollen (alle 20 Sekunden, max 5 Minuten):
+   ```bash
+   curl -sf https://api-dev.breakpilot.ai/health    # Compliance Backend
+   curl -sf https://sdk-dev.breakpilot.ai/health     # AI SDK
+   ```
+3. Sobald ALLE Endpoints healthy sind, dem User im Chat melden:
+   **"Deploy abgeschlossen! Du kannst jetzt testen."**
+4. Falls nach 5 Minuten noch nicht healthy → Fehlermeldung mit Hinweis auf Coolify-Logs.
+
+### Lokale Entwicklung (Mac Mini — optional, nur Dev/Tests)
+
+```bash
 ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-core && git pull --no-rebase origin main"
 ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-core && /usr/local/bin/docker compose build --no-cache <service> && /usr/local/bin/docker compose up -d <service>"
 ```
 
-### SSH-Verbindung (fuer Docker/Tests)
+### SSH-Verbindung (fuer lokale Docker/Tests)
 
 ```bash
 ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-core && <cmd>"
@@ -51,6 +76,14 @@ networks:
     name: breakpilot-network   # Fixer Name, kein Auto-Prefix!
 ```
 
+### Deployment-Modell
+
+| Repo | Deployment | Trigger |
+|------|-----------|---------|
+| **breakpilot-core** | Coolify (automatisch) | Push auf gitea main |
+| **breakpilot-compliance** | Coolify (automatisch) | Push auf gitea main |
+| **breakpilot-lehrer** | Mac Mini (lokal) | Manuell docker compose |
+
 ---
 
 ## Haupt-URLs (via Nginx Reverse Proxy)
@@ -161,7 +194,7 @@ networks:
 | `compliance` | Compliance | compliance_*, dsr, gdpr, sdk_tenants, consent_admin |
 
 ```bash
-# DB-Zugang
+# DB-Zugang (lokal)
 ssh macmini "docker exec bp-core-postgres psql -U breakpilot -d breakpilot_db"
 ```
 
@@ -193,7 +226,14 @@ breakpilot-core/
 
 ## Haeufige Befehle
 
-### Docker
+### Deployment (CI/CD — Standardweg)
+
+```bash
+# Committen und pushen → Coolify deployt automatisch:
+git push origin main && git push gitea main
+```
+
+### Lokale Docker-Befehle (Mac Mini — nur Dev/Tests)
 
 ```bash
 # Alle Core-Services starten
@@ -211,31 +251,15 @@ ssh macmini "/usr/local/bin/docker ps --filter name=bp-core"
 
 **WICHTIG:** Docker-Pfad auf Mac Mini ist `/usr/local/bin/docker` (nicht im Standard-SSH-PATH).
 
-### Alle 3 Projekte starten
-
-```bash
-# 1. Core (MUSS zuerst!)
-ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-core && /usr/local/bin/docker compose up -d"
-# Warten auf Health:
-ssh macmini "curl -sf http://127.0.0.1:8099/health"
-
-# 2. Lehrer
-ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-lehrer && /usr/local/bin/docker compose up -d"
-
-# 3. Compliance
-ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-compliance && /usr/local/bin/docker compose up -d"
-```
-
 ### Git
 
 ```bash
 # Zu BEIDEN Remotes pushen (PFLICHT!):
-ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-core && git push all main"
+git push origin main && git push gitea main
 
 # Remotes:
 # origin: lokale Gitea (macmini:3003)
 # gitea:  gitea.meghsakha.com
-# all:    beide gleichzeitig
 ```
 
 ---

.gitea/workflows/ci.yaml

@@ -140,117 +140,20 @@ jobs:
           python -m pytest tests/bqas/ -v --tb=short || true
 
   # ========================================
-  # Build & Deploy auf Hetzner (nur main, kein PR)
+  # Deploy via Coolify (nur main, kein PR)
   # ========================================
 
-  deploy-hetzner:
+  deploy-coolify:
+    name: Deploy
     runs-on: docker
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     needs:
       - test-go-consent
-    container: docker:27-cli
+    container:
+      image: alpine:latest
     steps:
-      - name: Deploy
+      - name: Trigger Coolify deploy
         run: |
-          set -euo pipefail
+          apk add --no-cache curl
-          DEPLOY_DIR="/opt/breakpilot-core"
+          curl -sf "${{ secrets.COOLIFY_WEBHOOK }}" \
-          COMPOSE_FILES="-f docker-compose.yml -f docker-compose.hetzner.yml"
+            -H "Authorization: Bearer ${{ secrets.COOLIFY_TOKEN }}"
-          COMMIT_SHA="${GITHUB_SHA:-unknown}"
-          SHORT_SHA="${COMMIT_SHA:0:8}"
-          REPO_URL="${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git"
-
-          # Services die deployed werden
-          SERVICES="postgres valkey qdrant minio ollama mailpit embedding-service rag-service backend-core consent-service health-aggregator"
-
-          echo "=== BreakPilot Core Deploy ==="
-          echo "Commit: ${SHORT_SHA}"
-          echo "Deploy Dir: ${DEPLOY_DIR}"
-          echo "Services: ${SERVICES}"
-          echo ""
-
-          # 1. Repo auf dem Host erstellen/aktualisieren via Helper-Container
-          echo "=== Updating code on host ==="
-          docker run --rm \
-            -v "${DEPLOY_DIR}:${DEPLOY_DIR}" \
-            --entrypoint sh \
-            alpine/git:latest \
-            -c "
-              if [ ! -d '${DEPLOY_DIR}/.git' ]; then
-                echo 'Erstmaliges Klonen nach ${DEPLOY_DIR}...'
-                git clone '${REPO_URL}' '${DEPLOY_DIR}'
-              else
-                cd '${DEPLOY_DIR}'
-                git fetch origin main
-                git reset --hard origin/main
-              fi
-            "
-          echo "Code aktualisiert auf ${SHORT_SHA}"
-
-          # 2. .env sicherstellen
-          docker run --rm -v "${DEPLOY_DIR}:${DEPLOY_DIR}" alpine \
-            sh -c "
-              if [ ! -f '${DEPLOY_DIR}/.env' ]; then
-                echo 'WARNUNG: ${DEPLOY_DIR}/.env fehlt!'
-                echo 'Erstelle .env aus .env.example mit Defaults...'
-                if [ -f '${DEPLOY_DIR}/.env.example' ]; then
-                  cp '${DEPLOY_DIR}/.env.example' '${DEPLOY_DIR}/.env'
-                  echo '.env aus .env.example erstellt'
-                else
-                  echo 'Kein .env.example gefunden — Services starten mit Defaults'
-                fi
-              else
-                echo '.env vorhanden'
-              fi
-            "
-
-          # 3. Shared Network erstellen (falls noch nicht vorhanden)
-          docker network create breakpilot-network 2>/dev/null || true
-
-          # 4. Build + Deploy via Helper-Container
-          echo ""
-          echo "=== Building + Deploying ==="
-          docker run --rm \
-            -v /var/run/docker.sock:/var/run/docker.sock \
-            -v "${DEPLOY_DIR}:${DEPLOY_DIR}" \
-            -w "${DEPLOY_DIR}" \
-            docker:27-cli \
-            sh -c "
-              set -e
-              COMPOSE_FILES='-f docker-compose.yml -f docker-compose.hetzner.yml'
-
-              echo '=== Building Docker Images ==='
-              docker compose \${COMPOSE_FILES} build --parallel \
-                backend-core consent-service rag-service embedding-service health-aggregator
-
-              echo ''
-              echo '=== Starting infrastructure ==='
-              docker compose \${COMPOSE_FILES} up -d postgres valkey qdrant minio mailpit
-
-              echo 'Warte auf DB + Cache...'
-              sleep 10
-
-              echo ''
-              echo '=== Starting Ollama + pulling bge-m3 ==='
-              docker compose \${COMPOSE_FILES} up -d ollama
-              sleep 5
-
-              # bge-m3 Modell pullen (nur beim ersten Mal ~670MB)
-              echo 'Pulling bge-m3 model (falls noch nicht vorhanden)...'
-              docker exec bp-core-ollama ollama pull bge-m3 2>&1 || echo 'WARNUNG: bge-m3 pull fehlgeschlagen (wird spaeter nachgeholt)'
-
-              echo ''
-              echo '=== Starting application services ==='
-              docker compose \${COMPOSE_FILES} up -d \
-                embedding-service rag-service backend-core consent-service health-aggregator
-
-              echo ''
-              echo '=== Health Checks ==='
-              sleep 15
-              for svc in bp-core-postgres bp-core-valkey bp-core-qdrant bp-core-ollama bp-core-embedding-service bp-core-rag-service bp-core-backend bp-core-consent-service bp-core-health; do
-                STATUS=\$(docker inspect --format='{{.State.Status}}' \"\${svc}\" 2>/dev/null || echo 'not found')
-                echo \"\${svc}: \${STATUS}\"
-              done
-            "
-
-          echo ""
-          echo "=== Deploy abgeschlossen: ${SHORT_SHA} ==="

docker-compose.coolify.yml

@@ -15,6 +15,7 @@ networks:
 volumes:
   valkey_data:
   embedding_models:
+  paddleocr_models:
 
 services:
 
@@ -141,6 +142,37 @@ services:
     networks:
       - breakpilot-network
 
+  # =========================================================
+  # OCR SERVICE (PaddleOCR PP-OCRv5)
+  # =========================================================
+  paddleocr-service:
+    build:
+      context: ./paddleocr-service
+      dockerfile: Dockerfile
+    container_name: bp-core-paddleocr
+    expose:
+      - "8095"
+    environment:
+      PADDLEOCR_API_KEY: ${PADDLEOCR_API_KEY:-}
+      FLAGS_use_mkldnn: "0"
+    volumes:
+      - paddleocr_models:/root/.paddleocr
+    labels:
+      - "traefik.http.services.paddleocr.loadbalancer.server.port=8095"
+    deploy:
+      resources:
+        limits:
+          memory: 6G
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://127.0.0.1:8095/health"]
+      interval: 30s
+      timeout: 10s
+      start_period: 300s
+      retries: 5
+    restart: unless-stopped
+    networks:
+      - breakpilot-network
+
   # =========================================================
   # HEALTH AGGREGATOR
   # =========================================================
@@ -153,7 +185,7 @@ services:
       - "8099"
     environment:
       PORT: 8099
-      CHECK_SERVICES: "valkey:6379,consent-service:8081,rag-service:8097,embedding-service:8087"
+      CHECK_SERVICES: "valkey:6379,consent-service:8081,rag-service:8097,embedding-service:8087,paddleocr-service:8095"
     healthcheck:
       test: ["CMD", "curl", "-f", "http://127.0.0.1:8099/health"]
       interval: 30s

docs-src/architecture/environments.md

@@ -1,194 +1,77 @@
 # Umgebungs-Architektur
 
-## Übersicht
+## Uebersicht
 
-BreakPilot verwendet eine 3-Umgebungs-Strategie für sichere Entwicklung und Deployment:
+BreakPilot verwendet zwei Umgebungen:
 
 ```
-┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
+┌─────────────────┐                    ┌─────────────────┐
-│   Development   │────▶│     Staging     │────▶│   Production    │
+│   Development   │───── git push ────▶│   Production    │
-│   (develop)     │     │    (staging)    │     │     (main)      │
+│   (Mac Mini)    │                    │   (Coolify)     │
-└─────────────────┘     └─────────────────┘     └─────────────────┘
+└─────────────────┘                    └─────────────────┘
-     Tägliche            Getesteter Code         Produktionsreif
+     Lokale                             Automatisch
-     Entwicklung
+     Entwicklung                        via Coolify
 ```
 
 ## Umgebungen
 
-### Development (Dev)
+### Development (Lokal — Mac Mini)
 
-**Zweck:** Tägliche Entwicklungsarbeit
+**Zweck:** Lokale Entwicklung und Tests
 
 | Eigenschaft | Wert |
 |-------------|------|
-| Git Branch | `develop` |
+| Git Branch | `main` |
-| Compose File | `docker-compose.yml` + `docker-compose.override.yml` (auto) |
+| Compose File | `docker-compose.yml` |
-| Env File | `.env.dev` |
+| Database | Lokale PostgreSQL |
-| Database | `breakpilot_dev` |
 | Debug | Aktiviert |
 | Hot-Reload | Aktiviert |
 
 **Start:**
 ```bash
-./scripts/start.sh dev
+ssh macmini "cd ~/Projekte/breakpilot-core && /usr/local/bin/docker compose up -d"
-# oder einfach:
-docker compose up -d
 ```
 
-### Staging
+### Production (Coolify)
 
-**Zweck:** Getesteter, freigegebener Code vor Produktion
+**Zweck:** Live-System
-
-| Eigenschaft | Wert |
-|-------------|------|
-| Git Branch | `staging` |
-| Compose File | `docker-compose.yml` + `docker-compose.staging.yml` |
-| Env File | `.env.staging` |
-| Database | `breakpilot_staging` (separates Volume) |
-| Debug | Deaktiviert |
-| Hot-Reload | Deaktiviert |
-
-**Start:**
-```bash
-./scripts/start.sh staging
-# oder:
-docker compose -f docker-compose.yml -f docker-compose.staging.yml up -d
-```
-
-### Production (Prod)
-
-**Zweck:** Live-System für Endbenutzer (ab Launch)
 
 | Eigenschaft | Wert |
 |-------------|------|
 | Git Branch | `main` |
-| Compose File | `docker-compose.yml` + `docker-compose.prod.yml` |
+| Deployment | Coolify (automatisch bei Push auf gitea) |
-| Env File | `.env.prod` (NICHT im Repository!) |
+| Database | Externe PostgreSQL (TLS) |
-| Database | `breakpilot_prod` (separates Volume) |
 | Debug | Deaktiviert |
-| Vault | Pflicht (keine Env-Fallbacks) |
-
-## Datenbank-Trennung
-
-Jede Umgebung verwendet separate Docker Volumes für vollständige Datenisolierung:
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    PostgreSQL Volumes                        │
-├─────────────────────────────────────────────────────────────┤
-│  breakpilot-dev_postgres_data      │ Development Database   │
-│  breakpilot_staging_postgres       │ Staging Database       │
-│  breakpilot_prod_postgres          │ Production Database    │
-└─────────────────────────────────────────────────────────────┘
-```
-
-## Port-Mapping
-
-Um mehrere Umgebungen gleichzeitig laufen zu lassen, verwenden sie unterschiedliche Ports:
-
-| Service | Dev Port | Staging Port | Prod Port |
-|---------|----------|--------------|-----------|
-| Backend | 8000 | 8001 | 8000 |
-| PostgreSQL | 5432 | 5433 | - (intern) |
-| MinIO | 9000/9001 | 9002/9003 | - (intern) |
-| Qdrant | 6333/6334 | 6335/6336 | - (intern) |
-| Mailpit | 8025/1025 | 8026/1026 | - (deaktiviert) |
-
-## Git Branching Strategie
-
-```
-main (Prod)     ← Nur Release-Merges, geschützt
-    │
-    ▼
-staging         ← Getesteter Code, Review erforderlich
-    │
-    ▼
-develop (Dev)   ← Tägliche Arbeit, Default-Branch
-    │
-    ▼
-feature/*       ← Feature-Branches (optional)
-```
-
-### Workflow
-
-1. **Entwicklung:** Arbeite auf `develop`
-2. **Code-Review:** Erstelle PR von Feature-Branch → `develop`
-3. **Staging:** Promote `develop` → `staging` mit Tests
-4. **Release:** Promote `staging` → `main` nach Freigabe
-
-### Promotion-Befehle
 
+**Deploy:**
 ```bash
-# develop → staging
+git push origin main && git push gitea main
-./scripts/promote.sh dev-to-staging
+# Coolify baut und deployt automatisch
-
-# staging → main (Production)
-./scripts/promote.sh staging-to-prod
 ```
 
-## Secrets Management
-
-### Development
-- `.env.dev` enthält Entwicklungs-Credentials
-- Vault optional (Dev-Token)
-- Mailpit für E-Mail-Tests
-
-### Staging
-- `.env.staging` enthält Test-Credentials
-- Vault empfohlen
-- Mailpit für E-Mail-Sicherheit
-
-### Production
-- `.env.prod` NICHT im Repository
-- Vault PFLICHT
-- Echte SMTP-Konfiguration
-
-Siehe auch: [Secrets Management](./secrets-management.md)
-
 ## Docker Compose Architektur
 
 ```
-docker-compose.yml              ← Basis-Konfiguration
+docker-compose.yml              ← Basis-Konfiguration (lokal, arm64)
         │
-        ├── docker-compose.override.yml  ← Dev (auto-geladen)
+        └── docker-compose.coolify.yml   ← Production Override (amd64)
-        │
-        ├── docker-compose.staging.yml   ← Staging (explizit)
-        │
-        └── docker-compose.prod.yml      ← Production (explizit)
 ```
 
-### Automatisches Laden
+Coolify verwendet automatisch beide Compose-Files fuer den Production-Build.
 
-Docker Compose lädt automatisch:
+## Secrets Management
-1. `docker-compose.yml`
-2. `docker-compose.override.yml` (falls vorhanden)
 
-Daher startet `docker compose up` automatisch die Dev-Umgebung.
+### Development
+- `.env` enthält Entwicklungs-Credentials
+- Vault optional (Dev-Token)
+- Mailpit für E-Mail-Tests
 
-## Helper Scripts
+### Production
+- `.env` auf dem Server (nicht im Repository)
+- Vault PFLICHT
+- Echte SMTP-Konfiguration
 
-| Script | Beschreibung |
+Siehe auch: [Secrets Management](./secrets-management.md)
-|--------|--------------|
-| `scripts/env-switch.sh` | Wechselt zwischen Umgebungen |
-| `scripts/start.sh` | Startet Services für Umgebung |
-| `scripts/stop.sh` | Stoppt Services |
-| `scripts/promote.sh` | Promotet Code zwischen Branches |
-| `scripts/status.sh` | Zeigt aktuellen Status |
-
-## Verifikation
-
-Nach Setup prüfen:
-
-```bash
-# Status anzeigen
-./scripts/status.sh
-
-# Branches prüfen
-git branch -v
-
-# Volumes prüfen
-docker volume ls | grep breakpilot
-```
 
 ## Verwandte Dokumentation
 

docs-src/development/ci-cd-pipeline.md

@@ -1,15 +1,14 @@
 # CI/CD Pipeline
 
-Übersicht über den Deployment-Prozess für Breakpilot.
+Uebersicht ueber den Deployment-Prozess fuer BreakPilot.
 
-## Übersicht
+## Uebersicht
 
-| Komponente | Build-Tool | Deployment |
+| Repo | Deployment | Trigger | Compose File |
-|------------|------------|------------|
+|------|-----------|---------|--------------|
-| Frontend (Next.js) | Docker | Mac Mini |
+| **breakpilot-core** | Coolify (automatisch) | Push auf `coolify` Branch | `docker-compose.coolify.yml` |
-| Backend (FastAPI) | Docker | Mac Mini |
+| **breakpilot-compliance** | Coolify (automatisch) | Push auf `main` Branch | `docker-compose.yml` + `docker-compose.coolify.yml` |
-| Go Services | Docker (Multi-stage) | Mac Mini |
+| **breakpilot-lehrer** | Mac Mini (lokal) | Manuell `docker compose` | `docker-compose.yml` |
-| Documentation | MkDocs | Docker (Nginx) |
 
 ## Deployment-Architektur
 
@@ -17,287 +16,146 @@
 ┌─────────────────────────────────────────────────────────────────┐
 │                      Entwickler-MacBook                          │
 │                                                                   │
-│   breakpilot-core/                                               │
+│   breakpilot-core/         → git push gitea coolify              │
-│   ├── admin-core/         (Next.js Admin, Port 3008)            │
+│   breakpilot-compliance/   → git push gitea main                 │
-│   ├── backend-core/       (Python FastAPI, Port 8000)           │
+│   breakpilot-lehrer/       → git push + ssh macmini docker ...   │
-│   ├── consent-service/    (Go Service, Port 8081)               │
-│   ├── billing-service/    (Go Service, Port 8083)               │
-│   └── docs-src/           (MkDocs)                              │
 │                                                                   │
-│   git push → Gitea Actions (automatisch)                        │
-│   oder manuell: git push && ssh macmini docker compose build    │
 └───────────────────────────────┬─────────────────────────────────┘
                                 │
-                                │ git push origin main
+                    ┌───────────┴───────────┐
-                                │
+                    │                       │
-                                ▼
+                    ▼                       ▼
-┌─────────────────────────────────────────────────────────────────┐
+┌───────────────────────────┐  ┌───────────────────────────┐
-│                         Mac Mini Server (bp-core-*)              │
+│   Coolify (Production)    │  │   Mac Mini (Lokal/Dev)    │
-│                                                                   │
+│                           │  │                           │
-│   Docker Compose                                                 │
+│   Gitea Actions           │  │   breakpilot-lehrer       │
-│   ├── admin-core (Port 3008)                                    │
+│   ├── Tests               │  │   ├── studio-v2           │
-│   ├── backend-core (Port 8000)                                  │
+│   └── Coolify API Deploy  │  │   ├── klausur-service     │
-│   ├── consent-service (Port 8081)                               │
+│                           │  │   ├── backend-lehrer      │
-│   ├── billing-service (Port 8083)                               │
+│   Core Services:          │  │   └── voice-service       │
-│   ├── gitea (Port 3003) + gitea-runner (Gitea Actions)         │
+│   ├── consent-service     │  │                           │
-│   ├── docs (Port 8011)                                          │
+│   ├── rag-service         │  │   Core Services (lokal):  │
-│   ├── postgres, valkey, qdrant, minio                           │
+│   ├── embedding-service   │  │   ├── postgres            │
-│   └── vault, nginx, night-scheduler, health                     │
+│   ├── paddleocr-service   │  │   ├── valkey, vault       │
-│                                                                   │
+│   └── health-aggregator   │  │   ├── nginx, gitea        │
-└─────────────────────────────────────────────────────────────────┘
+│                           │  │   └── ...                  │
+│   Compliance Services:    │  │                           │
+│   ├── admin-compliance    │  │                           │
+│   ├── backend-compliance  │  │                           │
+│   ├── ai-compliance-sdk   │  │                           │
+│   └── developer-portal    │  │                           │
+└───────────────────────────┘  └───────────────────────────┘
 ```
 
-## Sync & Deploy Workflow
+## breakpilot-core → Coolify
 
-### 1. Dateien synchronisieren
+### Pipeline
-
-```bash
-# Sync aller relevanten Verzeichnisse zum Mac Mini
-rsync -avz --delete \
-  --exclude 'node_modules' \
-  --exclude '.next' \
-  --exclude '.git' \
-  --exclude '__pycache__' \
-  --exclude 'venv' \
-  --exclude '.pytest_cache' \
-  /Users/benjaminadmin/Projekte/breakpilot-core/ \
-  macmini:/Users/benjaminadmin/Projekte/breakpilot-core/
-```
-
-### 2. Container bauen
-
-```bash
-# Einzelnen Service bauen
-ssh macmini "/usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  build --no-cache <service-name>"
-
-# Beispiele:
-# studio-v2, admin-v2, website, backend, klausur-service, docs
-```
-
-### 3. Container deployen
-
-```bash
-# Container neu starten
-ssh macmini "/usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  up -d <service-name>"
-```
-
-### 4. Logs prüfen
-
-```bash
-# Container-Logs anzeigen
-ssh macmini "/usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  logs -f <service-name>"
-```
-
-## Service-spezifische Deployments
-
-### Next.js Frontend (studio-v2, admin-v2, website)
-
-```bash
-# 1. Sync
-rsync -avz --delete \
-  --exclude 'node_modules' --exclude '.next' --exclude '.git' \
-  /Users/benjaminadmin/Projekte/breakpilot-core/studio-v2/ \
-  macmini:/Users/benjaminadmin/Projekte/breakpilot-core/studio-v2/
-
-# 2. Build & Deploy
-ssh macmini "/usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  build --no-cache studio-v2 && \
-  /usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  up -d studio-v2"
-```
-
-### Python Services (backend, klausur-service, voice-service)
-
-```bash
-# Build mit requirements.txt
-ssh macmini "/usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  build klausur-service && \
-  /usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  up -d klausur-service"
-```
-
-### Go Services (consent-service, ai-compliance-sdk)
-
-```bash
-# Multi-stage Build (Go → Alpine)
-ssh macmini "/usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  build --no-cache consent-service && \
-  /usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  up -d consent-service"
-```
-
-### MkDocs Dokumentation
-
-```bash
-# Build & Deploy
-ssh macmini "/usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  build --no-cache docs && \
-  /usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  up -d docs"
-
-# Verfügbar unter: http://macmini:8009
-```
-
-## Health Checks
-
-### Service-Status prüfen
-
-```bash
-# Alle Container-Status
-ssh macmini "docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'"
-
-# Health-Endpoints prüfen
-curl -s http://macmini:8000/health
-curl -s http://macmini:8081/health
-curl -s http://macmini:8086/health
-curl -s http://macmini:8090/health
-```
-
-### Logs analysieren
-
-```bash
-# Letzte 100 Zeilen
-ssh macmini "docker logs --tail 100 breakpilot-core-backend-1"
-
-# Live-Logs folgen
-ssh macmini "docker logs -f breakpilot-core-backend-1"
-```
-
-## Rollback
-
-### Container auf vorherige Version zurücksetzen
-
-```bash
-# 1. Aktuelles Image taggen
-ssh macmini "docker tag breakpilot-core-backend:latest breakpilot-core-backend:backup"
-
-# 2. Altes Image deployen
-ssh macmini "/usr/local/bin/docker compose \
-  -f /Users/benjaminadmin/Projekte/breakpilot-core/docker-compose.yml \
-  up -d backend"
-
-# 3. Bei Problemen: Backup wiederherstellen
-ssh macmini "docker tag breakpilot-core-backend:backup breakpilot-core-backend:latest"
-```
-
-## Troubleshooting
-
-### Container startet nicht
-
-```bash
-# 1. Logs prüfen
-ssh macmini "docker logs breakpilot-core-<service>-1"
-
-# 2. Container manuell starten für Debug-Output
-ssh macmini "docker compose -f .../docker-compose.yml run --rm <service>"
-
-# 3. In Container einloggen
-ssh macmini "docker exec -it breakpilot-core-<service>-1 /bin/sh"
-```
-
-### Port bereits belegt
-
-```bash
-# Port-Belegung prüfen
-ssh macmini "lsof -i :8000"
-
-# Container mit dem Port finden
-ssh macmini "docker ps --filter publish=8000"
-```
-
-### Build-Fehler
-
-```bash
-# Cache komplett leeren
-ssh macmini "docker builder prune -a"
-
-# Ohne Cache bauen
-ssh macmini "docker compose build --no-cache <service>"
-```
-
-## Monitoring
-
-### Resource-Nutzung
-
-```bash
-# CPU/Memory aller Container
-ssh macmini "docker stats --no-stream"
-
-# Disk-Nutzung
-ssh macmini "docker system df"
-```
-
-### Cleanup
-
-```bash
-# Ungenutzte Images/Container entfernen
-ssh macmini "docker system prune -a --volumes"
-
-# Nur dangling Images
-ssh macmini "docker image prune"
-```
-
-## Umgebungsvariablen
-
-Umgebungsvariablen werden über `.env` Dateien und docker-compose.yml verwaltet:
 
 ```yaml
-# docker-compose.yml
+# .gitea/workflows/deploy-coolify.yml
-services:
+on:
-  backend:
+  push:
-    environment:
+    branches: [coolify]
-      - DATABASE_URL=postgresql://...
+
-      - REDIS_URL=redis://valkey:6379
+jobs:
-      - SECRET_KEY=${SECRET_KEY}
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy via Coolify API
+        # Triggert Coolify Build + Deploy ueber API
+        # Secrets: COOLIFY_API_TOKEN, COOLIFY_RESOURCE_UUID, COOLIFY_BASE_URL
 ```
 
-**Wichtig**: Sensible Werte niemals in Git committen. Stattdessen:
+### Workflow
-- `.env` Datei auf dem Server pflegen
+
-- Secrets über HashiCorp Vault (siehe unten)
+```bash
+# 1. Code auf MacBook bearbeiten
+# 2. Committen und pushen:
+git push origin main && git push gitea main
+
+# 3. Fuer Production-Deploy:
+git push gitea coolify
+
+# 4. Status pruefen:
+# https://gitea.meghsakha.com/Benjamin_Boenisch/breakpilot-core/actions
+```
+
+### Coolify-deployed Services
+
+| Service | Container | Beschreibung |
+|---------|-----------|--------------|
+| valkey | bp-core-valkey | Session-Cache |
+| consent-service | bp-core-consent-service | Consent-Management (Go) |
+| rag-service | bp-core-rag-service | Semantische Suche |
+| embedding-service | bp-core-embedding-service | Text-Embeddings |
+| paddleocr-service | bp-core-paddleocr | OCR Engine (x86_64) |
+| health-aggregator | bp-core-health | Health-Check Aggregator |
+
+## breakpilot-compliance → Coolify
+
+### Pipeline
+
+```yaml
+# .gitea/workflows/ci.yaml
+on:
+  push:
+    branches: [main, develop]
+
+jobs:
+  # Lint (nur PRs)
+  # Tests (Go, Python, Node.js)
+  # Validate Canonical Controls
+  # Deploy (nur main, nach allen Tests)
+```
+
+### Workflow
+
+```bash
+# Committen und pushen → Coolify deployt automatisch:
+git push origin main && git push gitea main
+
+# CI-Status pruefen:
+# https://gitea.meghsakha.com/Benjamin_Boenisch/breakpilot-compliance/actions
+
+# Health Checks:
+curl -sf https://api-dev.breakpilot.ai/health
+curl -sf https://sdk-dev.breakpilot.ai/health
+```
+
+## breakpilot-lehrer → Mac Mini (lokal)
+
+### Workflow
+
+```bash
+# 1. Code auf MacBook bearbeiten
+# 2. Committen und pushen:
+git push origin main && git push gitea main
+
+# 3. Auf Mac Mini pullen und Container neu bauen:
+ssh macmini "git -C /Users/benjaminadmin/Projekte/breakpilot-lehrer pull --no-rebase origin main"
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml build --no-cache <service>"
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml up -d <service>"
+```
 
 ## Gitea Actions
 
-### Überblick
+### Ueberblick
 
-BreakPilot Core nutzt **Gitea Actions** (GitHub Actions-kompatibel) als CI/CD-System. Der `act_runner` läuft als Container auf dem Mac Mini und führt Pipelines direkt bei Code-Push aus.
+BreakPilot nutzt **Gitea Actions** (GitHub Actions-kompatibel) als CI/CD-System. Der `act_runner` laeuft als Container auf dem Mac Mini und fuehrt Pipelines aus.
 
 | Komponente | Container | Beschreibung |
 |------------|-----------|--------------|
 | Gitea | `bp-core-gitea` (Port 3003) | Git-Server + Actions-Trigger |
-| Gitea Runner | `bp-core-gitea-runner` | Führt Actions-Workflows aus |
+| Gitea Runner | `bp-core-gitea-runner` | Fuehrt Actions-Workflows aus |
 
 ### Pipeline-Konfiguration
 
-Workflows liegen im Repo unter `.gitea/workflows/`:
+Workflows liegen in jedem Repo unter `.gitea/workflows/`:
 
-```yaml
+| Repo | Workflow | Branch | Aktion |
-# .gitea/workflows/main.yml
+|------|----------|--------|--------|
-on:
+| breakpilot-core | `deploy-coolify.yml` | `coolify` | Coolify API Deploy |
-  push:
+| breakpilot-compliance | `ci.yaml` | `main` | Tests + Coolify Deploy |
-    branches: [main]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build & Test
-        run: docker compose build
-```
 
 ### Runner-Token erneuern
 
@@ -314,12 +172,79 @@ ssh macmini "/usr/local/bin/docker compose \
   up -d --force-recreate gitea-runner"
 ```
 
-### Pipeline-Status prüfen
+### Pipeline-Status pruefen
 
 ```bash
 # Runner-Logs
 ssh macmini "/usr/local/bin/docker logs -f bp-core-gitea-runner"
-
+```
-# Laufende Jobs
+
-ssh macmini "/usr/local/bin/docker exec bp-core-gitea-runner act_runner list"
+## Health Checks
+
+### Production (Coolify)
+
+```bash
+# Core PaddleOCR
+curl -sf https://ocr.breakpilot.com/health
+
+# Compliance
+curl -sf https://api-dev.breakpilot.ai/health
+curl -sf https://sdk-dev.breakpilot.ai/health
+```
+
+### Lokal (Mac Mini)
+
+```bash
+# Core Health Aggregator
+curl -sf http://macmini:8099/health
+
+# Lehrer Backend
+curl -sf https://macmini:8001/health
+
+# Klausur-Service
+curl -sf https://macmini:8086/health
+```
+
+## Troubleshooting
+
+### Container startet nicht
+
+```bash
+# Logs pruefen (lokal)
+ssh macmini "/usr/local/bin/docker logs bp-core-<service>"
+
+# In Container einloggen
+ssh macmini "/usr/local/bin/docker exec -it bp-core-<service> /bin/sh"
+```
+
+### Build-Fehler
+
+```bash
+# Cache komplett leeren
+ssh macmini "docker builder prune -a"
+
+# Ohne Cache bauen
+ssh macmini "docker compose build --no-cache <service>"
+```
+
+## Rollback
+
+### Coolify
+
+Ein Redeploy mit einem aelteren Commit kann durch Zuruecksetzen des Branches ausgeloest werden:
+
+```bash
+# Branch auf vorherigen Commit zuruecksetzen und pushen
+git reset --hard <previous-commit>
+git push gitea coolify --force
+```
+
+### Lokal (Mac Mini)
+
+```bash
+# Image taggen als Backup
+ssh macmini "docker tag breakpilot-lehrer-klausur-service:latest breakpilot-lehrer-klausur-service:backup"
+
+# Bei Problemen: Backup wiederherstellen
+ssh macmini "docker tag breakpilot-lehrer-klausur-service:backup breakpilot-lehrer-klausur-service:latest"
 ```

docs-src/index.md

@@ -12,6 +12,14 @@ BreakPilot besteht aus drei unabhaengigen Projekten:
 | **breakpilot-lehrer** | Bildungs-Stack (Team A) | `bp-lehrer-*` | Blau |
 | **breakpilot-compliance** | DSGVO/Compliance-Stack (Team B) | `bp-compliance-*` | Lila |
 
+### Deployment-Modell
+
+| Repo | Deployment | Trigger |
+|------|-----------|---------|
+| **breakpilot-core** | Coolify (automatisch) | Push auf gitea main |
+| **breakpilot-compliance** | Coolify (automatisch) | Push auf gitea main |
+| **breakpilot-lehrer** | Mac Mini (lokal) | Manuell docker compose |
+
 ## Core Services
 
 | Service | Container | Port | Beschreibung |
@@ -30,32 +38,11 @@ BreakPilot besteht aus drei unabhaengigen Projekten:
 | Admin Core | bp-core-admin | 3008 | Admin-Dashboard (Next.js) |
 | Health Aggregator | bp-core-health | 8099 | Service-Health Monitoring |
 | Night Scheduler | bp-core-night-scheduler | 8096 | Nachtabschaltung |
-| Pitch Deck | bp-core-pitch-deck | 3012 | Investor-Praesentation |
 | Mailpit | bp-core-mailpit | 8025 | E-Mail (Entwicklung) |
 | Gitea | bp-core-gitea | 3003 | Git-Server |
 | Gitea Runner | bp-core-gitea-runner | - | CI/CD (Gitea Actions) |
 | Jitsi (5 Container) | bp-core-jitsi-* | 8443 | Videokonferenzen |
 
-## Nginx Routing-Tabelle
-
-| Port | Upstream | Projekt |
-|------|----------|---------|
-| 443 | bp-lehrer-studio-v2:3001 | Lehrer |
-| 3000 | bp-lehrer-website:3000 | Lehrer |
-| 3002 | bp-lehrer-admin:3000 | Lehrer |
-| 3006 | bp-compliance-developer-portal:3000 | Compliance |
-| 3007 | bp-compliance-admin:3000 | Compliance |
-| 3008 | bp-core-admin:3000 | Core |
-| 8000 | bp-core-backend:8000 | Core |
-| 8001 | bp-lehrer-backend:8001 | Lehrer |
-| 8002 | bp-compliance-backend:8002 | Compliance |
-| 8086 | bp-lehrer-klausur-service:8086 | Lehrer |
-| 8087 | bp-core-embedding-service:8087 | Core |
-| 8091 | bp-lehrer-voice-service:8091 | Lehrer |
-| 8093 | bp-compliance-ai-sdk:8090 | Compliance |
-| 8097 | bp-core-rag-service:8097 | Core |
-| 8443 | bp-core-jitsi-web:80 | Core |
-
 ## Architektur
 
 - [System-Architektur](architecture/system-architecture.md)

paddleocr-service/Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.11-slim
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 libglib2.0-0 libgomp1 curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8095
+HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=3 \
+    CMD curl -f http://127.0.0.1:8095/health || exit 1
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8095"]

paddleocr-service/main.py

@@ -0,0 +1,110 @@
+"""PaddleOCR Remote Service — PP-OCRv4 on x86_64 (CPU)."""
+
+import io
+import logging
+import os
+import threading
+
+import numpy as np
+from fastapi import FastAPI, File, Header, HTTPException, UploadFile
+from PIL import Image
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="PaddleOCR Service")
+
+_engine = None
+_ready = False
+_loading = False
+API_KEY = os.environ.get("PADDLEOCR_API_KEY", "")
+
+
+def _load_model():
+    """Load PaddleOCR model in background thread."""
+    global _engine, _ready
+    try:
+        logger.info("Importing paddleocr...")
+        from paddleocr import PaddleOCR
+
+        logger.info("Loading PaddleOCR model (PP-OCRv4, lang=en)...")
+        _engine = PaddleOCR(
+            lang="en",
+            use_angle_cls=True,
+            show_log=False,
+            enable_mkldnn=False,
+            use_gpu=False,
+        )
+        logger.info("PaddleOCR model loaded — running warmup...")
+        # Warmup with tiny image to trigger any lazy init
+        dummy = np.ones((30, 100, 3), dtype=np.uint8) * 255
+        _engine.ocr(dummy)
+        _ready = True
+        logger.info("PaddleOCR ready to serve")
+    except Exception as e:
+        logger.error(f"Failed to load PaddleOCR: {e}", exc_info=True)
+
+
+@app.on_event("startup")
+def startup_load_model():
+    """Start model loading in background so health check passes immediately."""
+    global _loading
+    _loading = True
+    threading.Thread(target=_load_model, daemon=True).start()
+    logger.info("Model loading started in background thread")
+
+
+@app.get("/health")
+def health():
+    if _ready:
+        return {"status": "ok", "model": "PP-OCRv4"}
+    if _loading:
+        return {"status": "loading"}
+    return {"status": "error"}
+
+
+@app.post("/ocr")
+async def ocr(
+    file: UploadFile = File(...),
+    x_api_key: str = Header(default=""),
+):
+    if API_KEY and x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    if not _ready:
+        raise HTTPException(status_code=503, detail="Model still loading")
+
+    img_bytes = await file.read()
+    img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+    img_np = np.array(img)
+
+    try:
+        result = _engine.ocr(img_np)
+    except Exception as e:
+        logger.error(f"OCR failed: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"OCR failed: {e}")
+
+    if not result or not result[0]:
+        return {"words": [], "image_width": img_np.shape[1], "image_height": img_np.shape[0]}
+
+    words = []
+    for line in result[0]:
+        box, (text, conf) = line[0], line[1]
+        x_min = min(p[0] for p in box)
+        y_min = min(p[1] for p in box)
+        x_max = max(p[0] for p in box)
+        y_max = max(p[1] for p in box)
+        words.append({
+            "text": str(text).strip(),
+            "left": int(x_min),
+            "top": int(y_min),
+            "width": int(x_max - x_min),
+            "height": int(y_max - y_min),
+            "conf": round(float(conf) * 100, 1),
+        })
+
+    return {
+        "words": words,
+        "image_width": img_np.shape[1],
+        "image_height": img_np.shape[0],
+    }

paddleocr-service/requirements.txt

@@ -0,0 +1,7 @@
+paddlepaddle>=2.6.0,<3.0.0
+paddleocr>=2.7.0,<3.0.0
+fastapi>=0.110.0
+uvicorn>=0.25.0
+python-multipart>=0.0.6
+Pillow>=10.0.0
+numpy>=1.24.0