docs: update MkDocs for 3-project architecture (core/lehrer/compliance)

- Rewrite system-architecture.md with new 3-project diagram
- Update index.md with Core services table and nginx routing
- Replace service docs that moved to lehrer/compliance with redirects
  (klausur-service, voice-service, agent-core, ki-daten-pipeline -> lehrer)
  (ai-compliance-sdk -> compliance)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Benjamin Boenisch
2026-02-14 19:51:09 +01:00
parent f2a24d7341
commit fdfe38b61a
7 changed files with 260 additions and 1414 deletions

View File

@@ -1,254 +1,163 @@
# BreakPilot PWA - System-Architektur # BreakPilot - System-Architektur
## Übersicht ## Uebersicht
BreakPilot ist eine modulare Bildungsplattform für Lehrkräfte mit folgenden Hauptkomponenten: BreakPilot ist eine modulare Bildungs- und Compliance-Plattform, aufgeteilt in drei unabhaengige Docker Compose Projekte:
``` ```
┌─────────────────────────────────────────────────────────────────────┐ ┌────────────────────────────────────────────────────────────────────────────
│ Browser │ │ Browser │
│ ┌───────────────────────────────────────────────────────────────┐ │ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Frontend (Studio UI) │ │ │ │ Studio v2 │ Admin Lehrer │ │ Admin Compl. │ │ Dev Portal │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │ │ │ │ (443) │ │ (3002) │ │ (3007) │ │ (3006) │ │
│ │Dashboard │ │Worksheets│ │Correction│ │Letters/Companion │ │ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘
│ │ └──────────┘ └──────────┘ └──────────┘ └──────────────────┘ │ │ └─────────┼──────────────────┼──────────────────┼──────────────────┼─────────┘
│ └───────────────────────────────────────────────────────────────┘ │ │ │
└───────────────────────────┬─────────────────────────────────────────┘ ▼ ▼ ▼ ▼
│ HTTP/REST ┌─────────────────────────────────────────────────────────────────────────────┐
bp-core-nginx (Reverse Proxy + TLS) │
┌─────────────────────────────────────────────────────────────────────┐ │ Ports: 80, 443, 3000-3008, 8000-8097 │
│ Python Backend (FastAPI) │ └────────┬──────────────────┬──────────────────┬──────────────────────────────┘
│ Port 8000
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ API Layer │ │
│ │ /api/worksheets /api/corrections /api/letters /api/state │ │
│ │ /api/school /api/certificates /api/messenger /api/jitsi │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ Service Layer │ │
│ │ FileProcessor │ PDFService │ ContentGenerators │ StateEngine │ │
│ └────────────────────────────────────────────────────────────────┘ │
└───────────────────────────┬─────────────────────────────────────────┘
┌─────────────┼─────────────┐
▼ ▼ ▼ ▼ ▼ ▼
┌─────────────────┐ ┌───────────────┐ ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
Go Consent │ │ PostgreSQL │ │ LLM Gateway │ │ HashiCorp breakpilot-core │ │breakpilot-lehrer│ │breakpilot-compl.
Service │ │ Database │ │ (optional) │ │ Vault (Shared) │ │ (Team A) │ │ (Team B)
Port 8081 │ │ Port 5432 │ │ │ │ Port 8200 │ │ │ │
└─────────────────┘ └───────────────┘ └──────────────┘ └──────────────┘ │ PostgreSQL │ │ Studio v2 │ │ Admin Compliance│
│ Valkey │ │ Admin Lehrer │ │ Developer Portal│
│ Vault │ │ Website │ │ Backend Compl. │
│ Qdrant │ │ Backend Lehrer │ │ AI Compliance │
│ MinIO │ │ Klausur Service │ │ SDK (Go) │
│ Embedding │ │ Voice Service │ │ DSMS (IPFS) │
│ RAG Service │ │ School Service │ │ Document Crawler│
│ Consent (Go) │ │ Geo Service │ │ │
│ Billing (Go) │ │ PaddleOCR │ │ │
│ Backend Core │ │ Agent Core │ │ │
│ Admin Core │ │ Transcription │ │ │
│ Jitsi (5x) │ │ BreakPilot Drive│ │ │
│ Night Scheduler │ │ │ │ │
│ Health Agg. │ │ │ │ │
│ Gitea/Woodpecker│ │ │ │ │
│ ERP (optional) │ │ │ │ │
└─────────────────┘ └─────────────────┘ └─────────────────┘
│ │ │
└──────────────────┴──────────────────┘
breakpilot-network
(gemeinsames Docker-Netzwerk)
``` ```
## Komponenten ---
### 1. Admin Frontend (Next.js Website) ## Drei-Projekt-Architektur
Das **Admin Frontend** ist eine vollständige Next.js 15 Anwendung für Developer und Administratoren: ### breakpilot-core (Shared Infrastructure)
**Technologie:** Next.js 15, React 18, TypeScript, Tailwind CSS Stellt gemeinsam genutzte Infrastruktur bereit. Beide Teams (Lehrer + Compliance) haengen von Core ab.
**Container:** `breakpilot-pwa-website` auf **Port 3000** **Container-Prefix:** `bp-core-*`
**Verzeichnis:** `/website` | Kategorie | Services |
|-----------|----------|
| Datenbank & Cache | PostgreSQL (PostGIS 16), Valkey |
| Security | Vault, Vault-Init, Vault-Agent |
| AI/ML | Embedding Service, RAG Service, Qdrant |
| Storage | MinIO (S3) |
| Business Logic | Consent Service (Go), Billing Service (Go), Backend Core (Python) |
| Frontend | Admin Core (Next.js, Port 3008) |
| Networking | Nginx (Reverse Proxy + TLS) |
| Monitoring | Health Aggregator |
| DevOps | Gitea, Woodpecker CI/CD, Night Scheduler, Mailpit |
| Kommunikation | Jitsi Meet (5 Container), Synapse (Matrix Chat) |
| ERP | ERPNext (optional, 9 Container) |
| Modul | Route | Beschreibung | ### breakpilot-lehrer (Team A: Bildung)
|-------|-------|--------------|
| Dashboard | `/admin` | Übersicht & Statistiken |
| GPU Infrastruktur | `/admin/gpu` | vast.ai GPU Management |
| Consent Verwaltung | `/admin/consent` | Rechtliche Dokumente & Versionen |
| Datenschutzanfragen | `/admin/dsr` | DSGVO Art. 15-21 Anfragen |
| DSMS | `/admin/dsms` | Datenschutz-Management-System |
| Education Search | `/admin/edu-search` | Bildungsquellen & Crawler |
| Personensuche | `/admin/staff-search` | Uni-Mitarbeiter & Publikationen |
| Uni-Crawler | `/admin/uni-crawler` | Universitäts-Crawling Orchestrator |
| LLM Vergleich | `/admin/llm-compare` | KI-Provider Vergleich |
| PCA Platform | `/admin/pca-platform` | Bot-Erkennung & Monetarisierung |
| Production Backlog | `/admin/backlog` | Go-Live Checkliste |
| Developer Docs | `/admin/docs` | API & Architektur Dokumentation |
| Kommunikation | `/admin/communication` | Matrix & Jitsi Monitoring |
| **Security** | `/admin/security` | DevSecOps Dashboard, Scans, Findings |
| **SBOM** | `/admin/sbom` | Software Bill of Materials |
### 2. Lehrer Frontend (Studio UI) Alle Services fuer Lehrkraefte und den Bildungsbereich.
Das **Lehrer Frontend** ist ein Single-Page-Application-ähnliches System für Lehrkräfte, das in Python-Modulen organisiert ist: **Container-Prefix:** `bp-lehrer-*`
| Modul | Datei | Beschreibung | | Service | Container | Port | Beschreibung |
|-------|-------|--------------| |---------|-----------|------|--------------|
| Base | `frontend/modules/base.py` | TopBar, Sidebar, Theme, Login | | Admin Lehrer | bp-lehrer-admin | 3002 | Lehrer-Dashboard (Next.js) |
| Dashboard | `frontend/modules/dashboard.py` | Übersichtsseite | | Studio v2 | bp-lehrer-studio-v2 | 443 | Lehrer-/Schueler-Studio (Next.js) |
| Worksheets | `frontend/modules/worksheets.py` | Lerneinheiten-Generator | | Website | bp-lehrer-website | 3000 | Oeffentliche Website (Next.js) |
| Correction | `frontend/modules/correction.py` | OCR-Klausurkorrektur | | Backend Lehrer | bp-lehrer-backend | 8001 | API Backend (Python/FastAPI) |
| Letters | `frontend/modules/letters.py` | Elternkommunikation | | Klausur Service | bp-lehrer-klausur-service | 8086 | Pruefungen, OCR, RAG (Python) |
| Companion | `frontend/modules/companion.py` | Begleiter-Modus mit State Engine | | School Service | bp-lehrer-school-service | 8084 | Schulverwaltung (Go) |
| School | `frontend/modules/school.py` | Schulverwaltung | | Voice Service | bp-lehrer-voice-service | 8091 | Spracheingabe (Python) |
| Gradebook | `frontend/modules/gradebook.py` | Notenbuch | | Geo Service | bp-lehrer-geo-service | 8088 | Geo-Daten/PostGIS (Python) |
| ContentCreator | `frontend/modules/content_creator.py` | H5P Content Creator | | PaddleOCR | bp-lehrer-paddleocr | - | OCR Engine (Profil: ocr) |
| ContentFeed | `frontend/modules/content_feed.py` | Content Discovery | | BreakPilot Drive | bp-lehrer-breakpilot-drive | - | Lernspiel (Profil: game) |
| Messenger | `frontend/modules/messenger.py` | Matrix Messenger | | Agent Core | bp-lehrer-agent-core | - | Multi-Agent System (Profil: dev) |
| Jitsi | `frontend/modules/jitsi.py` | Videokonferenzen | | Transcription Worker | bp-lehrer-transcription | - | Audio-Transkription (Profil: recording) |
| **KlausurKorrektur** | `frontend/modules/klausur_korrektur.py` | **Abitur-Klausurkorrektur (15-Punkte-System)** |
| **AbiturDocsAdmin** | `frontend/modules/abitur_docs_admin.py` | **Admin für Abitur-Dokumente (NiBiS)** |
Jedes Modul exportiert: ### breakpilot-compliance (Team B: DSGVO/Compliance)
- `get_css()` - CSS-Styles
- `get_html()` - HTML-Template
- `get_js()` - JavaScript-Logik
### 3. Python Backend (FastAPI) Alle Services fuer das Compliance-Produkt (DSGVO, AI Act, BSI).
#### API-Router **Container-Prefix:** `bp-compliance-*`
| Router | Präfix | Beschreibung | | Service | Container | Port | Beschreibung |
|--------|--------|--------------| |---------|-----------|------|--------------|
| `worksheets_api` | `/api/worksheets` | Content-Generatoren (MC, Cloze, Mindmap, Quiz) | | Admin Compliance | bp-compliance-admin | 3007 | Compliance-Dashboard (Next.js) |
| `correction_api` | `/api/corrections` | OCR-Pipeline für Klausurkorrektur | | Developer Portal | bp-compliance-developer-portal | 3006 | API-Dokumentation (Next.js) |
| `letters_api` | `/api/letters` | Elternbriefe mit GFK-Integration | | Backend Compliance | bp-compliance-backend | 8002 | Compliance API (Python/FastAPI) |
| `state_engine_api` | `/api/state` | Begleiter-Modus Phasen & Vorschläge | | AI Compliance SDK | bp-compliance-ai-sdk | 8090/8093 | DSGVO-konforme KI (Go) |
| `school_api` | `/api/school` | Schulverwaltung (Proxy zu school-service) | | DSMS Node | bp-compliance-dsms-node | 4001/5001 | IPFS Node |
| `certificates_api` | `/api/certificates` | Zeugniserstellung | | DSMS Gateway | bp-compliance-dsms-gateway | 8082 | IPFS Gateway (Node.js) |
| `messenger_api` | `/api/messenger` | Matrix Messenger Integration | | Document Crawler | bp-compliance-document-crawler | 8098 | Web-Crawler (Python) |
| `jitsi_api` | `/api/jitsi` | Jitsi Meeting-Einladungen |
| `consent_api` | `/api/consent` | DSGVO Consent-Verwaltung |
| `gdpr_api` | `/api/gdpr` | GDPR-Export |
| **`klausur_korrektur_api`** | `/api/klausur-korrektur` | **Abitur-Klausuren (15-Punkte, Gutachten, Fairness)** |
| **`abitur_docs_api`** | `/api/abitur-docs` | **NiBiS-Dokumentenverwaltung für RAG** |
#### Services ---
| Service | Datei | Beschreibung | ## Netzwerk-Architektur
|---------|-------|--------------|
| FileProcessor | `services/file_processor.py` | OCR mit PaddleOCR |
| PDFService | `services/pdf_service.py` | PDF-Generierung |
| ContentGenerators | `services/content_generators/` | MC, Cloze, Mindmap, Quiz |
| StateEngine | `state_engine/` | Phasen-Management & Antizipation |
### 4. Klausur-Korrektur System (Abitur) ### Gemeinsames Docker-Netzwerk
Das Klausur-Korrektur-System implementiert die vollständige Abitur-Bewertungspipeline: Alle drei Projekte nutzen dasselbe Docker-Netzwerk `breakpilot-network`:
``` ```yaml
┌─────────────────────────────────────────────────────────────────────┐ # In jedem docker-compose.yml:
│ Klausur-Korrektur Modul │ networks:
│ │ breakpilot-network:
│ ┌─────────────┐ ┌──────────────────┐ ┌─────────────────┐ │ external: true
│ │ Modus-Wahl │───►│ Text-Quellen & │───►│ Erwartungs- │ │
│ │ LandesAbi/ │ │ Rights-Gate │ │ horizont │ │
│ │ Vorabitur │ └──────────────────┘ └─────────────────┘ │
│ └─────────────┘ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Schülerarbeiten-Pipeline │ │
│ │ Upload → OCR → KI-Bewertung → Gutachten → 15-Punkte-Note │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────┐ ┌──────────────────────────────────┐ │
│ │ Erst-/Zweitprüfer │───►│ Fairness-Analyse & PDF-Export │ │
│ └────────────────────┘ └──────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
``` ```
#### 15-Punkte-Notensystem Container koennen sich gegenseitig ueber ihre Container-Namen erreichen:
- `bp-lehrer-backend``bp-core-postgres:5432`
- `bp-compliance-ai-sdk``bp-core-qdrant:6333`
- `bp-core-nginx``bp-lehrer-studio-v2:3001`
Das System verwendet den deutschen Abitur-Notenschlüssel: ### Nginx Routing
| Punkte | Prozent | Note | Der zentrale Nginx in Core routet alle Anfragen an die richtigen Container:
|--------|---------|------|
| 15-13 | 95-85% | 1+/1/1- |
| 12-10 | 80-70% | 2+/2/2- |
| 9-7 | 65-55% | 3+/3/3- |
| 6-4 | 50-40% | 4+/4/4- |
| 3-1 | 33-20% | 5+/5/5- |
| 0 | <20% | 6 |
#### Bewertungskriterien | Port | Upstream | Projekt |
|------|----------|---------|
| 443 | bp-lehrer-studio-v2:3001 + Jitsi | Lehrer + Core |
| 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 |
| 8091 | bp-lehrer-voice-service:8091 | Lehrer |
| 8093 | bp-compliance-ai-sdk:8090 | Compliance |
| 8443 | bp-core-jitsi-web:80 | Core |
| Kriterium | Gewicht | Beschreibung | ---
|-----------|---------|--------------|
| Rechtschreibung | 15% | Orthografie |
| Grammatik | 15% | Grammatik & Syntax |
| **Inhalt** | **40%** | Inhaltliche Qualität (höchste Gewichtung) |
| Struktur | 15% | Aufbau & Gliederung |
| Stil | 15% | Ausdruck & Stil |
### 5. Go Consent Service
Verwaltet DSGVO-Einwilligungen:
```
consent-service/
├── cmd/server/ # Main entry point
├── internal/
│ ├── handlers/ # HTTP Handler
│ ├── services/ # Business Logic
│ ├── models/ # Data Models
│ └── middleware/ # Auth Middleware
└── migrations/ # SQL Migrations
```
### 6. LLM Gateway (Optional)
Wenn `LLM_GATEWAY_ENABLED=true`:
```
llm_gateway/
├── routes/
│ ├── chat.py # Chat-Completion API
│ ├── communication.py # GFK-Validierung
│ ├── edu_search_seeds.py # Bildungssuche
│ └── legal_crawler.py # Schulgesetz-Crawler
└── services/
└── communication_service.py
```
## Datenfluss
### Worksheet-Generierung
```
User Input → Frontend (worksheets.py)
POST /api/worksheets/generate/multiple-choice
worksheets_api.py → MCGenerator (services/content_generators/)
Optional: LLM für erweiterte Generierung
Response: WorksheetContent → Frontend rendert Ergebnis
```
### Klausurkorrektur
```
File Upload → Frontend (correction.py)
POST /api/corrections/ (erstellen)
POST /api/corrections/{id}/upload (Datei)
Background Task: OCR via FileProcessor
Poll GET /api/corrections/{id} bis status="ocr_complete"
POST /api/corrections/{id}/analyze
Review Interface → PUT /api/corrections/{id} (Anpassungen)
GET /api/corrections/{id}/export-pdf
```
## Sicherheit ## Sicherheit
### Authentifizierung & Autorisierung ### Authentifizierung & Autorisierung
BreakPilot verwendet einen **Hybrid-Ansatz**:
| Schicht | Komponente | Beschreibung | | Schicht | Komponente | Beschreibung |
|---------|------------|--------------| |---------|------------|--------------|
| **Authentifizierung** | Keycloak (Prod) / Lokales JWT (Dev) | Token-Validierung via JWKS oder HS256 | | **Authentifizierung** | Keycloak (Prod) / Lokales JWT (Dev) | Token-Validierung via JWKS oder HS256 |
| **Autorisierung** | rbac.py (Eigenentwicklung) | Domaenenspezifische Berechtigungen | | **Autorisierung** | RBAC (Eigenentwicklung) | Domaenenspezifische Berechtigungen |
Siehe: [Auth-System](auth-system.md)
### Basis-Rollen ### Basis-Rollen
@@ -259,53 +168,60 @@ Siehe: [Auth-System](auth-system.md)
| `admin` | Administrator | | `admin` | Administrator |
| `data_protection_officer` | Datenschutzbeauftragter | | `data_protection_officer` | Datenschutzbeauftragter |
### Erweiterte Rollen (rbac.py)
15+ domaenenspezifische Rollen fuer Klausurkorrektur und Zeugnisse:
- `erstkorrektor`, `zweitkorrektor`, `drittkorrektor`
- `klassenlehrer`, `fachlehrer`, `fachvorsitz`
- `schulleitung`, `zeugnisbeauftragter`, `sekretariat`
### Sicherheitsfeatures ### Sicherheitsfeatures
- JWT-basierte Authentifizierung (RS256/HS256) - JWT-basierte Authentifizierung (RS256/HS256)
- CORS konfiguriert für Frontend-Zugriff - CORS konfiguriert pro Service
- DSGVO-konformes Consent-Management - DSGVO-konformes Consent-Management (Core)
- **HashiCorp Vault** fuer Secrets-Management (keine hardcodierten Secrets) - **HashiCorp Vault** fuer Secrets-Management
- Bundesland-spezifische Policy-Sets - **DevSecOps Pipeline** mit Trivy, Semgrep, Gitleaks
- **DevSecOps Pipeline** mit automatisierten Security-Scans (SAST, SCA, Secrets Detection)
Siehe: Siehe:
- [Auth-System](auth-system.md)
- [Secrets Management](secrets-management.md) - [Secrets Management](secrets-management.md)
- [DevSecOps](devsecops.md) - [DevSecOps](devsecops.md)
---
## Deployment ## Deployment
```yaml ### Start-Reihenfolge
services:
backend:
build: ./backend
ports: ["8000:8000"]
environment:
- DATABASE_URL=postgresql://...
- LLM_GATEWAY_ENABLED=false
consent-service: ```bash
build: ./consent-service # 1. Core zuerst (Infrastruktur)
ports: ["8081:8081"] docker compose -f breakpilot-core/docker-compose.yml up -d
postgres: # 2. Lehrer-Stack
image: postgres:15 docker compose -f breakpilot-lehrer/docker-compose.yml up -d
volumes:
- pgdata:/var/lib/postgresql/data # 3. Compliance-Stack
docker compose -f breakpilot-compliance/docker-compose.yml up -d
``` ```
### Health-Checks
```bash
# Core Health (alle Infrastruktur-Services)
curl https://macmini:8099/health
# Lehrer Backend
curl https://macmini:8001/health
# Compliance Backend
curl https://macmini:8002/health
# AI SDK
curl https://macmini:8093/health
```
---
## Erweiterung ## Erweiterung
Neues Frontend-Modul hinzufügen: ### Neuen Service zu einem Projekt hinzufuegen
1. Modul erstellen: `frontend/modules/new_module.py` 1. Service-Definition in das jeweilige `docker-compose.yml` hinzufuegen
2. Klasse mit `get_css()`, `get_html()`, `get_js()` implementieren 2. Container-Name mit dem richtigen Prefix versehen (`bp-core-*`, `bp-lehrer-*`, `bp-compliance-*`)
3. In `frontend/modules/__init__.py` importieren und exportieren 3. Netzwerk `breakpilot-network` zuweisen
4. Optional: Zugehörige API in `new_module_api.py` erstellen 4. Falls HTTPS noetig: Nginx-Route in `breakpilot-core/nginx/conf.d/default.conf` hinzufuegen
5. In `main.py` Router registrieren 5. Dokumentation in der jeweiligen MkDocs-Instanz aktualisieren

View File

@@ -1,124 +1,71 @@
# Breakpilot Dokumentation # BreakPilot Core - Dokumentation
Willkommen zur zentralen Dokumentation des Breakpilot-Projekts. Zentrale Infrastruktur-Dokumentation fuer das BreakPilot-Oekosystem.
## Was ist Breakpilot? ## Drei-Projekt-Architektur
Breakpilot ist eine DSGVO-konforme Bildungsplattform fuer Lehrkraefte mit folgenden Kernfunktionen: BreakPilot besteht aus drei unabhaengigen Projekten:
- **Consent-Management** - Datenschutzkonforme Einwilligungsverwaltung | Projekt | Beschreibung | Container-Prefix | Farbe |
- **KI-gestuetzte Klausurkorrektur** - Automatische Bewertungsvorschlaege fuer Abiturklausuren |---------|-------------|-------------------|-------|
- **Zeugnisgenerierung** - Workflow-basierte Zeugniserstellung mit Rollenkonzept | **breakpilot-core** (dieses Projekt) | Shared Infrastructure | `bp-core-*` | Teal |
- **Lernmaterial-Generator** - MC-Tests, Lueckentexte, Mindmaps, Quiz | **breakpilot-lehrer** | Bildungs-Stack (Team A) | `bp-lehrer-*` | Blau |
- **Elternbriefe** - GFK-basierte Kommunikation mit PDF-Export | **breakpilot-compliance** | DSGVO/Compliance-Stack (Team B) | `bp-compliance-*` | Lila |
## Schnellstart ## Core Services
<div class="grid cards" markdown> | Service | Container | Port | Beschreibung |
|---------|-----------|------|--------------|
| Nginx | bp-core-nginx | 80/443 | Reverse Proxy + TLS fuer alle drei Projekte |
| PostgreSQL | bp-core-postgres | 5432 | Zentrale Datenbank (PostGIS 16) |
| Valkey | bp-core-valkey | 6379 | Session Cache (Redis-Fork) |
| Vault | bp-core-vault | 8200 | Secrets Management |
| Qdrant | bp-core-qdrant | 6333 | Vector DB fuer RAG |
| MinIO | bp-core-minio | 9000 | S3-kompatibler Object Storage |
| Embedding Service | bp-core-embedding-service | 8087 | Text-Embeddings |
| RAG Service | bp-core-rag-service | 8097 | Retrieval Augmented Generation |
| Consent Service | bp-core-consent-service | 8081 | DSGVO Consent (Go) |
| Billing Service | bp-core-billing-service | 8083 | Abrechnung (Go) |
| Backend Core | bp-core-backend | 8000 | Shared API (Python) |
| 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 |
| Woodpecker | bp-core-woodpecker-server | 8090 | CI/CD |
| Jitsi (5 Container) | bp-core-jitsi-* | 8443 | Videokonferenzen |
- :material-rocket-launch:{ .lg .middle } **Erste Schritte** ## Nginx Routing-Tabelle
--- | Port | Upstream | Projekt |
|------|----------|---------|
Entwicklungsumgebung einrichten und das Projekt starten. | 443 | bp-lehrer-studio-v2:3001 | Lehrer |
| 3000 | bp-lehrer-website:3000 | Lehrer |
[:octicons-arrow-right-24: Umgebung einrichten](getting-started/environment-setup.md) | 3002 | bp-lehrer-admin:3000 | Lehrer |
| 3006 | bp-compliance-developer-portal:3000 | Compliance |
- :material-server:{ .lg .middle } **Mac Mini Setup** | 3007 | bp-compliance-admin:3000 | Compliance |
| 3008 | bp-core-admin:3000 | Core |
--- | 8000 | bp-core-backend:8000 | Core |
| 8001 | bp-lehrer-backend:8001 | Lehrer |
Headless Server-Konfiguration fuer den Entwicklungsserver. | 8002 | bp-compliance-backend:8002 | Compliance |
| 8086 | bp-lehrer-klausur-service:8086 | Lehrer |
[:octicons-arrow-right-24: Mac Mini Setup](getting-started/mac-mini-setup.md) | 8087 | bp-core-embedding-service:8087 | Core |
| 8091 | bp-lehrer-voice-service:8091 | Lehrer |
</div> | 8093 | bp-compliance-ai-sdk:8090 | Compliance |
| 8097 | bp-core-rag-service:8097 | Core |
| 8443 | bp-core-jitsi-web:80 | Core |
## Architektur ## Architektur
<div class="grid cards" markdown> - [System-Architektur](architecture/system-architecture.md)
- [Auth-System](architecture/auth-system.md)
- :material-sitemap:{ .lg .middle } **System-Architektur** - [Secrets Management](architecture/secrets-management.md)
- [DevSecOps](architecture/devsecops.md)
--- - [Multi-Agent System](architecture/multi-agent.md)
Ueberblick ueber alle Komponenten und deren Zusammenspiel.
[:octicons-arrow-right-24: Architektur](architecture/system-architecture.md)
- :material-shield-lock:{ .lg .middle } **Auth-System**
---
Hybrid-Authentifizierung mit Keycloak und lokalem JWT.
[:octicons-arrow-right-24: Auth-System](architecture/auth-system.md)
- :material-robot:{ .lg .middle } **Multi-Agent System**
---
Verteilte Agent-Architektur fuer KI-Funktionen.
[:octicons-arrow-right-24: Multi-Agent](architecture/multi-agent.md)
- :material-key-chain:{ .lg .middle } **Secrets Management**
---
HashiCorp Vault Integration fuer sichere Credentials.
[:octicons-arrow-right-24: Secrets](architecture/secrets-management.md)
</div>
## Services
| Service | Port | Beschreibung |
|---------|------|--------------|
| [Backend (Python)](api/backend-api.md) | 8000 | FastAPI Backend mit Panel UI |
| [Consent Service (Go)](architecture/auth-system.md) | 8081 | DSGVO-konforme Einwilligungsverwaltung |
| [Klausur Service](services/klausur-service/index.md) | 8086 | KI-gestuetzte Klausurkorrektur |
| [Agent Core](services/agent-core/index.md) | - | Multi-Agent Infrastructure |
| PostgreSQL | 5432 | Relationale Datenbank |
| Qdrant | 6333 | Vektor-Datenbank fuer RAG |
| MinIO | 9000 | Object Storage |
| Vault | 8200 | Secrets Management |
## Entwicklung ## Entwicklung
- [Testing](development/testing.md) - Test-Standards und Ausfuehrung - [Testing](development/testing.md)
- [Dokumentation](development/documentation.md) - Dokumentations-Richtlinien - [Dokumentation](development/documentation.md)
- [DevSecOps](architecture/devsecops.md) - Security Pipeline - [CI/CD Pipeline](development/ci-cd-pipeline.md)
- [Umgebungen](architecture/environments.md) - Dev/Staging/Prod
## Weitere Ressourcen
- **GitHub Repository**: Internes GitLab
- **Issue Tracker**: GitLab Issues
- **API Playground**: [http://macmini:8000/docs](http://macmini:8000/docs)
---
## Projektstruktur
```
breakpilot-pwa/
├── backend/ # Python FastAPI Backend
├── consent-service/ # Go Consent Service
├── klausur-service/ # Klausur-Korrektur Service
├── agent-core/ # Multi-Agent Infrastructure
├── voice-service/ # Voice/Audio Processing
├── website/ # Next.js Frontend
├── studio-v2/ # Admin Dashboard (Next.js)
├── docs-src/ # Diese Dokumentation
└── docker-compose.yml # Container-Orchestrierung
```
## Support
Bei Fragen oder Problemen:
1. Pruefen Sie zuerst die relevante Dokumentation
2. Suchen Sie im Issue Tracker nach aehnlichen Problemen
3. Erstellen Sie ein neues Issue mit detaillierter Beschreibung

View File

@@ -1,420 +1,10 @@
# Breakpilot Agent Core # Agent Core
Multi-Agent Architecture Infrastructure fuer Breakpilot. !!! info "Verschoben nach breakpilot-lehrer"
Agent Core gehoert zum **breakpilot-lehrer** Projekt (Team A).
## Uebersicht Die aktuelle Dokumentation befindet sich in der [Lehrer MkDocs-Instanz](http://macmini:8010/services/agent-core/).
Das `agent-core` Modul stellt die gemeinsame Infrastruktur fuer Breakpilots Multi-Agent-System bereit: **Container:** `bp-lehrer-agent-core`
**Profil:** `dev`
- **Session Management**: Agent-Sessions mit Checkpoints und Recovery **Repo:** `breakpilot-lehrer/agent-core/`
- **Shared Brain**: Langzeit-Gedaechtnis und Kontext-Verwaltung
- **Orchestration**: Message Bus, Supervisor und Task-Routing
## Architektur
```
┌─────────────────────────────────────────────────────────────────┐
│ Breakpilot Services │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │
│ │Voice Service│ │Klausur Svc │ │ Admin-v2 / AlertAgent │ │
│ └──────┬──────┘ └──────┬──────┘ └───────────┬─────────────┘ │
│ │ │ │ │
│ └────────────────┼──────────────────────┘ │
│ │ │
│ ┌───────────────────────▼───────────────────────────────────┐ │
│ │ Agent Core │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌───────────────────┐ │ │
│ │ │ Sessions │ │Shared Brain │ │ Orchestrator │ │ │
│ │ │ - Manager │ │ - Memory │ │ - Message Bus │ │ │
│ │ │ - Heartbeat │ │ - Context │ │ - Supervisor │ │ │
│ │ │ - Checkpoint│ │ - Knowledge │ │ - Task Router │ │ │
│ │ └─────────────┘ └─────────────┘ └───────────────────┘ │ │
│ └───────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────▼───────────────────────────────────┐ │
│ │ Infrastructure │ │
│ │ Valkey (Redis) PostgreSQL Qdrant │ │
│ └───────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
```
## Verzeichnisstruktur
```
agent-core/
├── __init__.py # Modul-Exports
├── README.md # Diese Datei
├── requirements.txt # Python-Abhaengigkeiten
├── pytest.ini # Test-Konfiguration
├── soul/ # Agent SOUL Files (Persoenlichkeiten)
│ ├── tutor-agent.soul.md
│ ├── grader-agent.soul.md
│ ├── quality-judge.soul.md
│ ├── alert-agent.soul.md
│ └── orchestrator.soul.md
├── brain/ # Shared Brain Implementation
│ ├── __init__.py
│ ├── memory_store.py # Langzeit-Gedaechtnis
│ ├── context_manager.py # Konversations-Kontext
│ └── knowledge_graph.py # Entity-Beziehungen
├── sessions/ # Session Management
│ ├── __init__.py
│ ├── session_manager.py # Session-Lifecycle
│ ├── heartbeat.py # Liveness-Monitoring
│ └── checkpoint.py # Recovery-Checkpoints
├── orchestrator/ # Multi-Agent Orchestration
│ ├── __init__.py
│ ├── message_bus.py # Inter-Agent Kommunikation
│ ├── supervisor.py # Agent-Ueberwachung
│ └── task_router.py # Intent-basiertes Routing
└── tests/ # Unit Tests
├── conftest.py
├── test_session_manager.py
├── test_heartbeat.py
├── test_message_bus.py
├── test_memory_store.py
└── test_task_router.py
```
## Komponenten
### 1. Session Management
Verwaltet Agent-Sessions mit State-Machine und Recovery-Faehigkeiten.
```python
from agent_core.sessions import SessionManager, AgentSession
# Session Manager erstellen
manager = SessionManager(
redis_client=redis,
db_pool=pg_pool,
namespace="breakpilot"
)
# Session erstellen
session = await manager.create_session(
agent_type="tutor-agent",
user_id="user-123",
context={"subject": "math"}
)
# Checkpoint setzen
session.checkpoint("task_started", {"task_id": "abc"})
# Session beenden
session.complete({"result": "success"})
```
**Session States:**
- `ACTIVE` - Session laeuft
- `PAUSED` - Session pausiert
- `COMPLETED` - Session erfolgreich beendet
- `FAILED` - Session fehlgeschlagen
### 2. Heartbeat Monitoring
Ueberwacht Agent-Liveness und triggert Recovery bei Timeout.
```python
from agent_core.sessions import HeartbeatMonitor, HeartbeatClient
# Monitor starten
monitor = HeartbeatMonitor(
timeout_seconds=30,
check_interval_seconds=5,
max_missed_beats=3
)
await monitor.start_monitoring()
# Agent registrieren
monitor.register("agent-1", "tutor-agent")
# Heartbeat senden
async with HeartbeatClient("agent-1", monitor) as client:
# Agent-Arbeit...
pass
```
### 3. Memory Store
Langzeit-Gedaechtnis fuer Agents mit TTL und Access-Tracking.
```python
from agent_core.brain import MemoryStore
store = MemoryStore(redis_client=redis, db_pool=pg_pool)
# Erinnerung speichern
await store.remember(
key="evaluation:math:student-1",
value={"score": 85, "feedback": "Gut gemacht!"},
agent_id="grader-agent",
ttl_days=30
)
# Erinnerung abrufen
result = await store.recall("evaluation:math:student-1")
# Nach Pattern suchen
similar = await store.search("evaluation:math:*")
```
### 4. Context Manager
Verwaltet Konversationskontext mit automatischer Komprimierung.
```python
from agent_core.brain import ContextManager, MessageRole
ctx_manager = ContextManager(redis_client=redis)
# Kontext erstellen
context = ctx_manager.create_context(
session_id="session-123",
system_prompt="Du bist ein hilfreicher Tutor...",
max_messages=50
)
# Nachrichten hinzufuegen
context.add_message(MessageRole.USER, "Was ist Photosynthese?")
context.add_message(MessageRole.ASSISTANT, "Photosynthese ist...")
# Fuer LLM API formatieren
messages = context.get_messages_for_llm()
```
### 5. Message Bus
Inter-Agent Kommunikation via Redis Pub/Sub.
```python
from agent_core.orchestrator import MessageBus, AgentMessage, MessagePriority
bus = MessageBus(redis_client=redis)
await bus.start()
# Handler registrieren
async def handle_message(msg):
return {"status": "processed"}
await bus.subscribe("grader-agent", handle_message)
# Nachricht senden
await bus.publish(AgentMessage(
sender="orchestrator",
receiver="grader-agent",
message_type="grade_request",
payload={"exam_id": "exam-1"},
priority=MessagePriority.HIGH
))
# Request-Response Pattern
response = await bus.request(message, timeout=30.0)
```
### 6. Agent Supervisor
Ueberwacht und koordiniert alle Agents.
```python
from agent_core.orchestrator import AgentSupervisor, RestartPolicy
supervisor = AgentSupervisor(message_bus=bus, heartbeat_monitor=monitor)
# Agent registrieren
await supervisor.register_agent(
agent_id="tutor-1",
agent_type="tutor-agent",
restart_policy=RestartPolicy.ON_FAILURE,
max_restarts=3,
capacity=10
)
# Agent starten
await supervisor.start_agent("tutor-1")
# Load Balancing
available = supervisor.get_available_agent("tutor-agent")
```
### 7. Task Router
Intent-basiertes Routing mit Fallback-Ketten.
```python
from agent_core.orchestrator import TaskRouter, RoutingRule, RoutingStrategy
router = TaskRouter(supervisor=supervisor)
# Eigene Regel hinzufuegen
router.add_rule(RoutingRule(
intent_pattern="learning_*",
agent_type="tutor-agent",
priority=10,
fallback_agent="orchestrator"
))
# Task routen
result = await router.route(
intent="learning_math",
context={"grade": 10},
strategy=RoutingStrategy.LEAST_LOADED
)
if result.success:
print(f"Routed to {result.agent_id}")
```
## SOUL Files
SOUL-Dateien definieren die Persoenlichkeit und Verhaltensregeln jedes Agents.
| Agent | SOUL File | Verantwortlichkeit |
|-------|-----------|-------------------|
| TutorAgent | tutor-agent.soul.md | Lernbegleitung, Fragen beantworten |
| GraderAgent | grader-agent.soul.md | Klausur-Korrektur, Bewertung |
| QualityJudge | quality-judge.soul.md | BQAS Qualitaetspruefung |
| AlertAgent | alert-agent.soul.md | Monitoring, Benachrichtigungen |
| Orchestrator | orchestrator.soul.md | Task-Koordination |
## Datenbank-Schema
### agent_sessions
```sql
CREATE TABLE agent_sessions (
id UUID PRIMARY KEY,
agent_type VARCHAR(50) NOT NULL,
user_id UUID REFERENCES users(id),
state VARCHAR(20) NOT NULL DEFAULT 'active',
context JSONB DEFAULT '{}',
checkpoints JSONB DEFAULT '[]',
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW(),
last_heartbeat TIMESTAMPTZ DEFAULT NOW()
);
```
### agent_memory
```sql
CREATE TABLE agent_memory (
id UUID PRIMARY KEY,
namespace VARCHAR(100) NOT NULL,
key VARCHAR(500) NOT NULL,
value JSONB NOT NULL,
agent_id VARCHAR(50) NOT NULL,
access_count INTEGER DEFAULT 0,
created_at TIMESTAMPTZ DEFAULT NOW(),
expires_at TIMESTAMPTZ,
UNIQUE(namespace, key)
);
```
### agent_messages
```sql
CREATE TABLE agent_messages (
id UUID PRIMARY KEY,
sender VARCHAR(50) NOT NULL,
receiver VARCHAR(50) NOT NULL,
message_type VARCHAR(50) NOT NULL,
payload JSONB NOT NULL,
priority INTEGER DEFAULT 1,
correlation_id UUID,
created_at TIMESTAMPTZ DEFAULT NOW()
);
```
## Integration
### Mit Voice-Service
```python
from services.enhanced_task_orchestrator import EnhancedTaskOrchestrator
orchestrator = EnhancedTaskOrchestrator(
redis_client=redis,
db_pool=pg_pool
)
await orchestrator.start()
# Session fuer Voice-Interaktion
session = await orchestrator.create_session(
voice_session_id="voice-123",
user_id="teacher-1"
)
# Task verarbeiten (nutzt Multi-Agent wenn noetig)
await orchestrator.process_task(task)
```
### Mit BQAS
```python
from bqas.quality_judge_agent import QualityJudgeAgent
judge = QualityJudgeAgent(
message_bus=bus,
memory_store=memory
)
await judge.start()
# Direkte Evaluation
result = await judge.evaluate(
response="Der Satz des Pythagoras...",
task_type="learning_math",
context={"user_input": "Was ist Pythagoras?"}
)
if result["verdict"] == "production_ready":
# Response ist OK
pass
```
## Tests
```bash
# In agent-core Verzeichnis
cd agent-core
# Alle Tests ausfuehren
pytest -v
# Mit Coverage
pytest --cov=. --cov-report=html
# Einzelnes Test-Modul
pytest tests/test_session_manager.py -v
# Async-Tests
pytest tests/test_message_bus.py -v
```
## Metriken
Das Agent-Core exportiert folgende Metriken:
| Metrik | Beschreibung |
|--------|--------------|
| `agent_session_duration_seconds` | Dauer von Agent-Sessions |
| `agent_heartbeat_delay_seconds` | Zeit seit letztem Heartbeat |
| `agent_message_latency_ms` | Latenz der Inter-Agent Kommunikation |
| `agent_memory_access_total` | Memory-Zugriffe pro Agent |
| `agent_error_total` | Fehler pro Agent-Typ |
## Naechste Schritte
1. **Migration ausfuehren**: `psql -f backend/migrations/add_agent_core_tables.sql`
2. **Voice-Service erweitern**: Enhanced Orchestrator aktivieren
3. **BQAS integrieren**: Quality Judge Agent starten
4. **Monitoring aufsetzen**: Metriken in Grafana integrieren

View File

@@ -1,97 +1,10 @@
# AI Compliance SDK # AI Compliance SDK
Das AI Compliance SDK ist ein Go-basierter Service zur Compliance-Bewertung von KI-Anwendungsfällen. !!! info "Verschoben nach breakpilot-compliance"
Das AI Compliance SDK gehoert zum **breakpilot-compliance** Projekt (Team B).
## Übersicht Die aktuelle Dokumentation befindet sich in der [Compliance MkDocs-Instanz](http://macmini:8011/services/ai-compliance-sdk/).
| Eigenschaft | Wert | **Container:** `bp-compliance-ai-sdk`
|-------------|------| **Ports:** 8090 (intern), 8093 (via Nginx)
| **Port** | 8090 | **Repo:** `breakpilot-compliance/ai-compliance-sdk/`
| **Framework** | Go (Gin) |
| **Datenbank** | PostgreSQL |
| **Vector DB** | Qdrant (Legal RAG) |
## Kernkomponenten
```
┌─────────────────────────────────────────────────────────────────────────────┐
│ UCCA System │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Frontend │───>│ SDK API │───>│ PostgreSQL │ │
│ │ (Next.js) │ │ (Go) │ │ Database │ │
│ └──────────────┘ └──────┬───────┘ └──────────────┘ │
│ │ │
│ ┌────────────────────┼────────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Policy │ │ Escalation │ │ Legal RAG │ │
│ │ Engine │ │ Workflow │ │ (Qdrant) │ │
│ │ (45 Regeln) │ │ (E0-E3) │ │ 2,274 Chunks │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
```
## Features
- **UCCA (Use-Case Compliance Advisor)**: Deterministische Bewertung von KI-Anwendungsfällen
- **Policy Engine**: 45 regelbasierte Compliance-Prüfungen
- **License Policy Engine**: Standards/Normen-Compliance (DIN, ISO, VDI)
- **Legal RAG**: Semantische Suche in EU-Verordnungen (DSGVO, AI Act, NIS2)
- **Eskalations-Workflow**: E0-E3 Stufen mit Human-in-the-Loop
- **Wizard & Legal Assistant**: Geführte Eingabe mit Rechtsassistent
- **Generic Obligations Framework**: NIS2, DSGVO, AI Act Module
## Kernprinzip
> **"LLM ist NICHT die Quelle der Wahrheit. Wahrheit = Regeln + Evidenz. LLM = Übersetzer + Subsumptionshelfer"**
Das System folgt einem strikten **Human-in-the-Loop** Ansatz:
1. **Deterministische Regeln** treffen alle Compliance-Entscheidungen
2. **LLM** erklärt nur Ergebnisse, überschreibt nie BLOCK-Entscheidungen
3. **Menschen** (DSB, Legal) treffen finale Entscheidungen bei kritischen Fällen
## API-Endpunkte
### Assessment
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| POST | `/sdk/v1/ucca/assess` | Assessment erstellen |
| GET | `/sdk/v1/ucca/assessments` | Assessments auflisten |
| GET | `/sdk/v1/ucca/assessments/:id` | Assessment abrufen |
| POST | `/sdk/v1/ucca/assessments/:id/explain` | LLM-Erklärung generieren |
### Eskalation
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| GET | `/sdk/v1/ucca/escalations` | Eskalationen auflisten |
| POST | `/sdk/v1/ucca/escalations/:id/decide` | Entscheidung treffen |
### Obligations Framework
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| POST | `/sdk/v1/ucca/obligations/assess` | Pflichten-Assessment |
| POST | `/sdk/v1/ucca/obligations/export/memo` | PDF-Export |
## Weiterführende Dokumentation
- [Architektur](./ARCHITECTURE.md) - Detaillierte Systemarchitektur
- [Entwickler-Guide](./DEVELOPER.md) - Entwickler-Dokumentation
- [Auditor-Dokumentation](./AUDITOR_DOCUMENTATION.md) - Dokumentation für externe Auditoren
## Tests
```bash
cd ai-compliance-sdk
go test -v ./...
# Mit Coverage
go test -cover ./...
```

View File

@@ -1,215 +1,8 @@
# KI-Daten-Pipeline # KI-Daten-Pipeline
Die KI-Daten-Pipeline ist ein zusammenhaengendes System aus drei Modulen, das den Datenfluss von der Erfassung bis zur semantischen Suche abbildet. !!! info "Verschoben nach breakpilot-lehrer"
Die KI-Daten-Pipeline gehoert zum **breakpilot-lehrer** Projekt (Team A).
## Uebersicht Die aktuelle Dokumentation befindet sich in der [Lehrer MkDocs-Instanz](http://macmini:8010/services/ki-daten-pipeline/).
```mermaid **Repo:** `breakpilot-lehrer/`
flowchart LR
subgraph OCR["OCR-Labeling"]
A[Klausur-Scans] --> B[OCR Erkennung]
B --> C[Ground Truth Labels]
end
subgraph RAG["RAG Pipeline"]
D[PDF Dokumente] --> E[Text-Extraktion]
E --> F[Chunking]
F --> G[Embedding]
end
subgraph SEARCH["Daten & RAG"]
H[Qdrant Collections]
I[Semantische Suche]
end
C -->|Export| D
G -->|Indexierung| H
H --> I
I -->|Ergebnisse| J[Klausur-Korrektur]
```
## Module
| Modul | Pfad | Funktion | Backend |
|-------|------|----------|---------|
| **OCR-Labeling** | `/ai/ocr-labeling` | Ground Truth fuer Handschrift-OCR | klausur-service:8086 |
| **RAG Pipeline** | `/ai/rag-pipeline` | Dokument-Indexierung | klausur-service:8086 |
| **Daten & RAG** | `/ai/rag` | Vektor-Suche & Collection-Mapping | klausur-service:8086 |
## Datenfluss
### 1. OCR-Labeling (Eingabe)
Das OCR-Labeling-Modul erfasst Ground Truth Daten fuer das Training von Handschrift-Erkennungsmodellen:
- **Upload**: Klausur-Scans (PDF/Bilder) werden hochgeladen
- **OCR-Verarbeitung**: Mehrere OCR-Modelle erkennen den Text
- `llama3.2-vision:11b` - Vision LLM (beste Qualitaet)
- `trocr` - Microsoft Transformer (schnell)
- `paddleocr` - PaddleOCR + LLM (4x schneller)
- `donut` - Document Understanding (strukturiert)
- **Labeling**: Manuelles Pruefen und Korrigieren der OCR-Ergebnisse
- **Export**: Gelabelte Daten koennen exportiert werden fuer:
- TrOCR Fine-Tuning
- Llama Vision Fine-Tuning
- Generic JSON
### 2. RAG Pipeline (Verarbeitung)
Die RAG Pipeline verarbeitet Dokumente und macht sie suchbar:
```mermaid
flowchart TD
A[Datenquellen] --> B[OCR/Text-Extraktion]
B --> C[Chunking]
C --> D[Embedding]
D --> E[Qdrant Indexierung]
subgraph sources["Datenquellen"]
S1[NiBiS PDFs]
S2[Eigene EH]
S3[Rechtskorpus]
S4[Schulordnungen]
end
```
**Verarbeitungsschritte:**
1. **Dokumentenextraktion**: PDFs und Bilder werden per OCR in Text umgewandelt
2. **Chunking**: Lange Texte werden in Abschnitte aufgeteilt
- Chunk-Groesse: 1000 Zeichen
- Ueberlappung: 200 Zeichen
3. **Embedding**: Jeder Chunk wird in einen Vektor umgewandelt
- Modell: `text-embedding-3-small`
- Dimensionen: 1536
4. **Indexierung**: Vektoren werden in Qdrant gespeichert
### 3. Daten & RAG (Ausgabe)
Das Daten & RAG Modul ermoeglicht die Verwaltung und Suche:
- **Collection-Uebersicht**: Status aller Qdrant Collections
- **Semantische Suche**: Fragen werden in Vektoren umgewandelt und aehnliche Dokumente gefunden
- **Regulierungs-Mapping**: Zeigt welche Regulierungen indexiert sind
## Qdrant Collections
| Collection | Inhalt | Status |
|------------|--------|--------|
| `bp_nibis_eh` | Offizielle NiBiS Erwartungshorizonte | Aktiv |
| `bp_eh` | Benutzerdefinierte Erwartungshorizonte | Aktiv |
| `bp_schulordnungen` | Schulordnungen aller Bundeslaender | In Arbeit |
| `bp_legal_corpus` | Rechtskorpus (DSGVO, AI Act, BSI, etc.) | Aktiv |
## Technische Architektur
### Services
```mermaid
graph TB
subgraph Frontend["Admin-v2 (Next.js)"]
F1["/ai/ocr-labeling"]
F2["/ai/rag-pipeline"]
F3["/ai/rag"]
end
subgraph Backend["klausur-service (Python)"]
B1[OCR Endpoints]
B2[Indexierungs-Jobs]
B3[Such-API]
end
subgraph Storage["Datenbanken"]
D1[(PostgreSQL)]
D2[(Qdrant)]
D3[(MinIO)]
end
F1 --> B1
F2 --> B2
F3 --> B3
B1 --> D1
B1 --> D3
B2 --> D2
B3 --> D2
```
### Backend-Endpunkte
#### OCR-Labeling (`/api/v1/ocr-label/`)
| Endpoint | Methode | Beschreibung |
|----------|---------|--------------|
| `/sessions` | GET/POST | Session-Verwaltung |
| `/sessions/{id}/upload` | POST | Bilder hochladen |
| `/queue` | GET | Labeling-Queue |
| `/confirm` | POST | OCR bestaetigen |
| `/correct` | POST | OCR korrigieren |
| `/skip` | POST | Item ueberspringen |
| `/stats` | GET | Statistiken |
| `/export` | POST | Trainingsdaten exportieren |
#### RAG Pipeline (`/api/ai/rag-pipeline`)
| Action | Beschreibung |
|--------|--------------|
| `jobs` | Indexierungs-Jobs auflisten |
| `dataset-stats` | Datensatz-Statistiken |
| `create-job` | Neue Indexierung starten |
| `pause` | Job pausieren |
| `resume` | Job fortsetzen |
| `cancel` | Job abbrechen |
#### Legal Corpus (`/api/legal-corpus/`)
| Endpoint | Beschreibung |
|----------|--------------|
| `/status` | Collection-Status |
| `/search` | Semantische Suche |
| `/ingest` | Dokumente indexieren |
## Integration mit Klausur-Korrektur
Die KI-Daten-Pipeline liefert Erwartungshorizont-Vorschlaege fuer die Klausur-Korrektur:
```mermaid
sequenceDiagram
participant L as Lehrer
participant K as Klausur-Korrektur
participant R as RAG-Suche
participant Q as Qdrant
L->>K: Schueler-Antwort pruefen
K->>R: EH-Vorschlaege laden
R->>Q: Semantische Suche
Q->>R: Top-k Chunks
R->>K: Relevante EH-Passagen
K->>L: Bewertungsvorschlaege
```
## Deployment
Die Module werden als Teil des admin-v2 Containers deployed:
```bash
# 1. Sync
rsync -avz --delete --exclude 'node_modules' --exclude '.next' --exclude '.git' \
/Users/benjaminadmin/Projekte/breakpilot-pwa/admin-v2/ \
macmini:/Users/benjaminadmin/Projekte/breakpilot-pwa/admin-v2/
# 2. Build & Deploy
ssh macmini "/usr/local/bin/docker compose \
-f /Users/benjaminadmin/Projekte/breakpilot-pwa/docker-compose.yml \
build --no-cache admin-v2 && \
/usr/local/bin/docker compose \
-f /Users/benjaminadmin/Projekte/breakpilot-pwa/docker-compose.yml \
up -d admin-v2"
```
## Verwandte Dokumentation
- [OCR Labeling Spezifikation](../klausur-service/OCR-Labeling-Spec.md)
- [RAG Admin Spezifikation](../klausur-service/RAG-Admin-Spec.md)
- [NiBiS Ingestion Pipeline](../klausur-service/NiBiS-Ingestion-Pipeline.md)
- [Multi-Agent Architektur](../../architecture/multi-agent.md)

View File

@@ -1,173 +1,10 @@
# Klausur-Service # Klausur Service
Der Klausur-Service ist ein FastAPI-basierter Microservice fuer KI-gestuetzte Abitur-Klausurkorrektur. !!! info "Verschoben nach breakpilot-lehrer"
Der Klausur Service gehoert zum **breakpilot-lehrer** Projekt (Team A).
## Uebersicht Die aktuelle Dokumentation befindet sich in der [Lehrer MkDocs-Instanz](http://macmini:8010/services/klausur-service/).
| Eigenschaft | Wert | **Container:** `bp-lehrer-klausur-service`
|-------------|------| **Port:** 8086
| **Port** | 8086 | **Repo:** `breakpilot-lehrer/klausur-service/`
| **Framework** | FastAPI (Python) |
| **Datenbank** | PostgreSQL + Qdrant (Vektor-DB) |
| **Speicher** | MinIO (Datei-Storage) |
## Features
- **OCR-Erkennung**: Automatische Texterkennung aus gescannten Klausuren
- **KI-Bewertung**: Automatische Bewertungsvorschlaege basierend auf Erwartungshorizont
- **BYOEH**: Bring-Your-Own-Expectation-Horizon mit Client-seitiger Verschluesselung
- **Fairness-Analyse**: Statistische Analyse der Bewertungskonsistenz
- **PDF-Export**: Gutachten und Notenuebersichten als PDF
- **Zweitkorrektur**: Vollstaendiger Workflow fuer Erst-, Zweit- und Drittkorrektur
## Architektur
```
┌─────────────────────────────────────────────────────────────┐
│ Frontend (Next.js) │
│ /website/app/admin/klausur-korrektur/ │
│ - Klausur-Liste │
│ - Studenten-Liste │
│ - Korrektur-Workspace (2/3-1/3 Layout) │
│ - Fairness-Dashboard │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ klausur-service (FastAPI) │
│ Port 8086 - /klausur-service/backend/main.py │
│ - Klausur CRUD (/api/v1/klausuren) │
│ - Student Work (/api/v1/students) │
│ - Annotations (/api/v1/annotations) │
│ - BYOEH (/api/v1/eh) │
│ - PDF Export │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ Infrastruktur │
│ - Qdrant (Vektor-DB fuer RAG) │
│ - MinIO (Datei-Storage) │
│ - PostgreSQL (Metadaten) │
│ - Embedding-Service (Port 8087) │
└─────────────────────────────────────────────────────────────┘
```
## API Endpoints
### Klausur-Verwaltung
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| GET | `/api/v1/klausuren` | Liste aller Klausuren |
| POST | `/api/v1/klausuren` | Neue Klausur erstellen |
| GET | `/api/v1/klausuren/{id}` | Klausur-Details |
| DELETE | `/api/v1/klausuren/{id}` | Klausur loeschen |
### Studenten-Arbeiten
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| POST | `/api/v1/klausuren/{id}/students` | Arbeit hochladen |
| GET | `/api/v1/klausuren/{id}/students` | Studenten-Liste |
| GET | `/api/v1/students/{id}` | Einzelne Arbeit |
| PUT | `/api/v1/students/{id}/criteria` | Kriterien bewerten |
| PUT | `/api/v1/students/{id}/gutachten` | Gutachten speichern |
### KI-Funktionen
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| POST | `/api/v1/students/{id}/gutachten/generate` | Gutachten generieren |
| GET | `/api/v1/klausuren/{id}/fairness` | Fairness-Analyse |
| POST | `/api/v1/students/{id}/eh-suggestions` | EH-Vorschlaege via RAG |
### PDF-Export
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| GET | `/api/v1/students/{id}/export/gutachten` | Einzelgutachten PDF |
| GET | `/api/v1/students/{id}/export/annotations` | Anmerkungen PDF |
| GET | `/api/v1/klausuren/{id}/export/overview` | Notenuebersicht PDF |
| GET | `/api/v1/klausuren/{id}/export/all-gutachten` | Alle Gutachten PDF |
## Notensystem
Das System verwendet das deutsche 15-Punkte-System fuer Abiturklausuren:
| Punkte | Prozent | Note |
|--------|---------|------|
| 15 | >= 95% | 1+ |
| 14 | >= 90% | 1 |
| 13 | >= 85% | 1- |
| 12 | >= 80% | 2+ |
| 11 | >= 75% | 2 |
| 10 | >= 70% | 2- |
| 9 | >= 65% | 3+ |
| 8 | >= 60% | 3 |
| 7 | >= 55% | 3- |
| 6 | >= 50% | 4+ |
| 5 | >= 45% | 4 |
| 4 | >= 40% | 4- |
| 3 | >= 33% | 5+ |
| 2 | >= 27% | 5 |
| 1 | >= 20% | 5- |
| 0 | < 20% | 6 |
## Bewertungskriterien
| Kriterium | Gewicht | Beschreibung |
|-----------|---------|--------------|
| Rechtschreibung | 15% | Orthografie |
| Grammatik | 15% | Grammatik & Syntax |
| Inhalt | 40% | Inhaltliche Qualitaet |
| Struktur | 15% | Aufbau & Gliederung |
| Stil | 15% | Ausdruck & Stil |
## Verzeichnisstruktur
```
klausur-service/
├── backend/
│ ├── main.py # API Endpoints + Datenmodelle
│ ├── qdrant_service.py # Vektor-Datenbank Operationen
│ ├── eh_pipeline.py # BYOEH Verarbeitung
│ ├── hybrid_search.py # Hybrid Search (BM25 + Semantic)
│ └── requirements.txt # Python Dependencies
├── frontend/
│ └── src/
│ ├── components/ # React Komponenten
│ ├── pages/ # Seiten
│ └── services/ # API Client
└── docs/
├── BYOEH-Architecture.md
└── BYOEH-Developer-Guide.md
```
## Konfiguration
### Umgebungsvariablen
```env
# Klausur-Service
KLAUSUR_SERVICE_PORT=8086
QDRANT_URL=http://qdrant:6333
MINIO_ENDPOINT=minio:9000
MINIO_ACCESS_KEY=...
MINIO_SECRET_KEY=...
# Embedding-Service
EMBEDDING_SERVICE_URL=http://embedding:8087
OPENAI_API_KEY=sk-...
# BYOEH
BYOEH_ENCRYPTION_ENABLED=true
EH_UPLOAD_DIR=/app/eh-uploads
```
## Weiterführende Dokumentation
- [BYOEH Architektur](./BYOEH-Architecture.md) - Client-seitige Verschluesselung
- [OCR Compare](./OCR-Compare.md) - Block Review Feature fuer OCR-Vergleich
- [Zeugnis-System](../../architecture/zeugnis-system.md) - Zeugniserstellung
- [Backend API](../../api/backend-api.md) - Allgemeine API-Dokumentation

View File

@@ -1,160 +1,10 @@
# Voice Service # Voice Service
Der Voice Service ist eine Voice-First Interface für die Breakpilot-Plattform mit DSGVO-konformem Design. !!! info "Verschoben nach breakpilot-lehrer"
Der Voice Service gehoert zum **breakpilot-lehrer** Projekt (Team A).
## Übersicht Die aktuelle Dokumentation befindet sich in der [Lehrer MkDocs-Instanz](http://macmini:8010/services/voice-service/).
| Eigenschaft | Wert | **Container:** `bp-lehrer-voice-service`
|-------------|------| **Port:** 8091
| **Port** | 8082 | **Repo:** `breakpilot-lehrer/voice-service/`
| **Framework** | FastAPI (Python) |
| **Streaming** | WebSocket |
| **DSGVO** | Privacy-by-Design |
## Architektur
```
┌─────────────────────────────────────────────────────────────────┐
│ Voice Service (Port 8082) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Sessions │───>│ Task │───>│ BQAS │ │
│ │ API │ │ Orchestrator │ │ (Quality) │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │ │
│ ┌────────────────────┼────────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ WebSocket │ │ Encryption │ │ Logging │ │
│ │ Streaming │ │ Service │ │ (structlog) │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
```
## Kernkomponenten
### PersonaPlex + TaskOrchestrator
- Voice-first Interface für Breakpilot
- Real-time Voice Processing
- Multi-Agent Integration
### DSGVO-Compliance (Privacy-by-Design)
| Feature | Beschreibung |
|---------|--------------|
| **Keine Audio-Persistenz** | Nur RAM-basiert, keine dauerhafte Speicherung |
| **Namespace-Verschlüsselung** | Schlüssel nur auf Lehrer-Gerät |
| **TTL-basierte Löschung** | Automatische Datenlöschung nach Zeitablauf |
| **Transcript-Verschlüsselung** | Verschlüsselte Transkripte |
## API-Endpunkte
### Sessions
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| POST | `/api/v1/sessions` | Session erstellen |
| GET | `/api/v1/sessions/:id` | Session abrufen |
| DELETE | `/api/v1/sessions/:id` | Session beenden |
### Task Orchestration
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| POST | `/api/v1/tasks` | Task erstellen |
| GET | `/api/v1/tasks/:id` | Task-Status abrufen |
### BQAS (Quality Assessment)
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| POST | `/api/v1/bqas/evaluate` | Qualitätsbewertung |
| GET | `/api/v1/bqas/metrics` | Metriken abrufen |
### WebSocket
| Endpoint | Beschreibung |
|----------|--------------|
| `/ws/voice` | Real-time Voice Streaming |
### Health
| Method | Endpoint | Beschreibung |
|--------|----------|--------------|
| GET | `/health` | Health Check |
| GET | `/ready` | Readiness Check |
## Verzeichnisstruktur
```
voice-service/
├── main.py # FastAPI Application
├── config.py # Konfiguration
├── pyproject.toml # Projekt-Metadaten
├── requirements.txt # Dependencies
├── api/
│ ├── sessions.py # Session-Management
│ ├── streaming.py # WebSocket Voice Streaming
│ ├── tasks.py # Task Orchestration
│ └── bqas.py # Quality Assessment
├── services/
│ ├── task_orchestrator.py # Task-Routing
│ └── encryption.py # Verschlüsselung
├── bqas/
│ ├── judge.py # LLM Judge
│ └── quality_judge_agent.py # Agent-Integration
├── models/ # Datenmodelle
├── scripts/ # Utility-Scripts
└── tests/ # Test-Suite
```
## Konfiguration
```env
# .env
VOICE_SERVICE_PORT=8082
REDIS_URL=redis://localhost:6379
DATABASE_URL=postgresql://...
ENCRYPTION_KEY=...
TTL_MINUTES=60
```
## Entwicklung
```bash
# Dependencies installieren
cd voice-service
pip install -r requirements.txt
# Server starten
uvicorn main:app --reload --port 8082
# Tests ausführen
pytest -v
```
## Docker
Der Service läuft als Teil von docker-compose.yml:
```yaml
voice-service:
build:
context: ./voice-service
ports:
- "8082:8082"
environment:
- REDIS_URL=redis://valkey:6379
depends_on:
- valkey
- postgres
```
## Weiterführende Dokumentation
- [Multi-Agent Architektur](../../architecture/multi-agent.md)
- [BQAS Quality System](../../architecture/bqas.md)