CEREBRO-RED v2 (Forschungsausgabe)

Autonome lokale LLM Red Teaming Suite

Ein forschungstaugliches Framework für automatisierte Schwachstellenerkennung in lokalen LLMs mit Agentic Fuzzing und Adaptive Adversarial Mutation (AAM).

Forschungsziele

• Implementierung des PAIR-Algorithmus (Prompt Automatic Iterative Refinement) von arxiv.org/abs/2310.08419
• LLM-as-a-Judge semantische Bewertung mit Chain-of-Thought Reasoning
• Telemetry-First Architektur für Whitepaper-taugliche Analyse
• Multi-Provider LLM Unterstützung (Ollama, Azure OpenAI, OpenAI)

Architektur

Tech Stack

• Backend: FastAPI (async/await), Pydantic (strict types), Uvicorn
• LLM Gateway: litellm (universal adapter for Ollama/Azure/OpenAI)
• Database: SQLite (experiments) + JSONL (audit logs)
• Frontend: React + Vite + TailwindCSS + ShadcnUI + Recharts
• Container: Docker + Docker Compose

Systemarchitektur mit Hauptkomponenten und Datenfluss

Kernmodule

1. Orchestrator (backend/core/engine.py): Asynchrone Batch-Verarbeitung mit exponentiellem Backoff
2. Mutator (backend/core/mutator.py): PAIR-Algorithmus mit Mutationsstrategien
3. Judge (backend/core/judge.py): LLM-as-a-Judge mit CoT-Bewertung
4. Telemetry (backend/core/telemetry.py): Thread-sicherer JSONL-Audit-Logger

Frontend Dashboard

Das React-basierte Frontend bietet eine umfassende Schnittstelle zur Verwaltung von Experimenten, Überwachung des Fortschritts und Analyse der Ergebnisse.

Hauptdashboard mit Experimentübersicht und Statistiken

Experimentverwaltungsansicht mit Echtzeit-Statusaktualisierungen und Experimentliste

Vollständige Benutzeroberfläche mit allen verfügbaren Funktionen

Experimentergebnisse und Analyse

Ergebnisansicht mit Experimentergebnissen, Schwachstellenfunden und detaillierter Analyse

Einstellungen und Konfigurationsbereich zur Anpassung der Experimentparameter

Echtzeit-Überwachung

Echtzeit-Überwachungsdashboard mit Live-Experimentfortschritt und Statusanzeigen

Telemetrieansicht mit detaillierten Audit-Logs, Systemereignissen und Leistungskennzahlen

Detaillierte Protokollansicht mit Filter- und Suchfunktionen

Leistungskennzahlen und Statistikdashboard

Systemstatusübersicht mit Gesundheitschecks und Komponentenstatus

API-Dokumentation

Interaktive API-Dokumentation mit Endpunkt-Explorer

Ausführliche Architekturdokumentation finden Sie in docs/ARCHITECTURE.md.

Schnellstart

Voraussetzungen

• Docker 24.0+
• Docker Compose 2.20+
• Ollama läuft auf dem Host (oder Azure/OpenAI API-Schlüssel)

Docker-Setup

Falls Docker nicht läuft, starten Sie den Docker-Daemon:```bash

Start Docker daemon

sudo systemctl start docker

Enable Docker to start on boot

sudo systemctl enable docker

Add your user to the docker group (to run Docker without sudo)

sudo usermod -aG docker $USER

Apply group changes (logout/login or use newgrp)

newgrp docker

OR logout and login again for changes to take effect

**Überprüfen, ob Docker läuft**:```bash
docker --version
docker compose version

Installation

1. Repository klonen: ```bash git clone https://github.com/Leviticus-Triage/cerebro-red-v2.git cd cerebro-red-v2

2. Umgebung konfigurieren: ```bash cp .env.example .env

   Edit .env with your LLM provider credentials

3. WICHTIG: Prüfe Port 8000 ```bash

   Falls Port 8000 belegt ist:

   lsof -i :8000 # Finde Prozess

   Oder ändere Port in .env: CEREBRO_PORT=8001

4. Backend starten (WICHTIG - muss laufen!): ```bash

   Option 1: Automatisch (empfohlen)

   ./START_BACKEND.sh

   Option 2: Docker

   docker compose up -d cerebro-backend

   Option 3: Lokal

   cd backend uvicorn main:app --reload --port 9000

5. Prüfe Backend-Status: ```bash curl http://localhost:9000/health

   Sollte {"status": "healthy", ...} zurückgeben

6. Quick Tests ausführen: ```bash ./QUICK_TEST_EXAMPLES.sh

7. Dashboard aufrufen:

   • Backend-API: http://localhost:9000
   • Frontend-UI: http://localhost:3000 (optional: docker compose up -d cerebro-frontend)
   • API-Dokumentation: http://localhost:9000/docs

   

   Frontend-Benutzeroberfläche mit Experimentverwaltung und -überwachung

---

Schnellstart: Lokale vs. Cloud-Bereitstellung

Lokale Bereitstellung (Ollama)

Am besten geeignet für: datenschutzorientierte Tests, keine API-Kosten, Offline-Betrieb.```bash

1. Install and start Ollama

curl -fsSL https://ollama.ai/install.sh | sh ollama pull llama3.2:3b ollama serve

2. Configure .env for local

cat > .env << 'EOF' TARGET_MODEL=ollama/llama3.2:3b ATTACKER_MODEL=ollama/llama3.2:3b JUDGE_MODEL=ollama/llama3.2:3b OLLAMA_BASE_URL=http://host.docker.internal:11434

Relaxed circuit breaker for local (slower responses)

CIRCUIT_BREAKER_FAILURE_THRESHOLD=15 CIRCUIT_BREAKER_TIMEOUT=120 CIRCUIT_BREAKER_JITTER_ENABLED=true EOF

3. Start services

docker compose up -d

4. Verify

curl http://localhost:9000/health | jq

### Cloud-Bereitstellung (OpenAI)

Am besten geeignet für: Schnellere Antworten, Mutationen höherer Qualität, Produktionstests.```bash
# 1. Configure .env for cloud
cat > .env << 'EOF'
TARGET_MODEL=openai/gpt-4o-mini
ATTACKER_MODEL=openai/gpt-4o-mini
JUDGE_MODEL=openai/gpt-4o-mini
OPENAI_API_KEY=sk-your-key-here

# Standard circuit breaker for cloud
CIRCUIT_BREAKER_FAILURE_THRESHOLD=10
CIRCUIT_BREAKER_TIMEOUT=60
CIRCUIT_BREAKER_JITTER_ENABLED=true
EOF

# 2. Start services
docker compose up -d

# 3. Verify
curl http://localhost:9000/health | jq

Hybrid-Bereitstellung (Multi-Provider)