Open Source · Apache 2.0 · Air-Gap Ready · Föderiertes Wissen · Veröffentlicht: 13. April 2026

Souveräne KI-Infrastruktur.
Self-Hosted. Deterministisch. Graph-akkumulierend.

MoE Sovereign ist ein template-basierter Multi-Model Orchestrator, der vollständig auf eigener Hardware läuft. Anfragen werden klassifiziert, an spezialisierte LLM-Experten geroutet, durch einen Wissensgraphen und Echtzeit-Websuche angereichert und von einem Judge-Modell synthetisiert — ohne Daten an externe APIs zu senden. Community-Wissens-Bundles ermöglichen ein Federated Knowledge Sync, bei dem jedes Deployment die kollektive Intelligenz bereichert.

GitHub ↗ Dokumentation ↗ Demo-Portal ↗
curl -sSL https://raw.githubusercontent.com/h3rb3rn/moe-sovereign/main/install.sh | bash

Install-Script: Debian 11–13 & Ubuntu 22.04–26.04 — Deployment via Docker / Podman Compose auf jeder Linux-Distribution

15 Fachexperten
51 MCP Precision Tools
9,3× Akkumulations-Speedup
46,7 % GAIA Score (Level 1 · n=30 · GPT-4o Mini 44,8 %)
0 Pflicht-Cloud-Calls
1 Mio.+ Effektive Context-Tokens (Tier-2 Memory)

Ressourcen

Projekt-Ressourcen

Dokumentation, Quellcode und Community-Tools für den Einstieg in Ihr eigenes MoE Sovereign Deployment. Dienste bereit. Sie veranschaulicht, wie eine produktionsreife MoE-Sovereign-Infrastruktur aussehen kann.

docs.moe-sovereign.org ↗

Vollständige Dokumentation: Architektur, API-Referenz, Integrationsanleitungen und Administrationshandbuch.

portal.moe-sovereign.org ↗

Benutzer-Selbstverwaltung: API-Keys erstellen, CC-Profile konfigurieren, Expert-Templates zuweisen, Token-Verbrauch einsehen.

api.moe-sovereign.org ↗

OpenAI-kompatibler und Anthropic-Messages-API-Endpunkt. Nutzer-Token-Limits werden serverseitig durchgesetzt.

moe-libris.org ↗

Föderierter Wissensaustausch: Wissensgraph-Einträge zwischen souveränen MoE-Instanzen teilen und importieren.

moe-codex.org ↗

EU-souveräne Compliance-Dateplattform: Catalog, Approval-Workflows, Lineage, Versionierung und Drift-Detection für regulierte Deployments.

moe-admin.de

Diese Seite – die deutsche Version mit vollständiger Projektbeschreibung.

Das Konzept

Was ist MoE Sovereign?

Statt eines einzelnen riesigen Modells auf einer teuren GPU werden viele spezialisierte Modelle koordiniert – jedes auf der Hardware, auf der es am besten läuft.

Das Problem

Moderne Large Language Models (LLMs) wie GPT-4 oder Claude erfordern für den Eigenbetrieb erhebliche Investitionen in GPU-Hardware – und erzeugen bei Cloud-Nutzung eine dauerhafte Abhängigkeit mit entsprechenden Datenschutzrisiken. Für Unternehmen, Forschungseinrichtungen und datenbewusste Anwender sind beide Wege oft keine optimale Option.

Die Lösung: Multi-Model Orchestrator + Flexibles Backend

MoE Sovereign verteilt die Inferenz auf ein Cluster von Knoten. Jede Anfrage wird von einem intelligenten Planer analysiert, auf die passenden Fachexperten verteilt und die Ergebnisse von einem Merger-Modell synthetisiert. Das Ergebnis: Bei strukturierten Wissens- und Rechercheaufgaben auf Augenhöhe mit kleineren Cloud-Modellen — bei vollständiger Datenkontrolle als Option und einem Bruchteil der laufenden Kosten.

Privacy by Design ist eine Architektur-Option, keine Einschränkung: Die Inferenz-Backends können Ollama-Instanzen auf eigener Hardware sein, aber genauso gut Claude-API-Endpunkte, eigene Enterprise-AI-Hubs oder Cloud-Inferenz-Dienste. Das MoE-System ist das Routing-Layer – es ist von der Hardware entkoppelt.

Die API ist vollständig OpenAI-kompatibel und implementiert den Anthropic Third-Party-Inference-Gateway-Standard, sodass bestehende Tools wie Open WebUI, Claude Desktop, Claude Cowork, Claude Code oder jede OpenAI-SDK-Integration ohne Änderung funktionieren.

Föderiertes Wissens-Ökosystem

Knowledge-Bundles ermöglichen den strukturierten Austausch domänenspezifischer Wissensgraphen zwischen unabhängigen Deployments. Jede Instanz bleibt autonom und offline-fähig; geteilte Bundles reichern den lokalen Graphen an, ohne Quelldaten oder proprietäre Informationen zu übertragen.

Privacy by Design

Als Option: alle Daten bleiben auf eigener Infrastruktur. Kein einziger API-Call verlässt das eigene Netz – wenn gewünscht.

Cloud-Flexibilität

Genauso gut als Routing-Layer vor Cloud-Diensten nutzbar: Claude, Gemini, Azure OpenAI oder eigene Enterprise-AI-Hubs.

Legacy-Hardware

Tesla K80 bis RTX 3060: ausrangierte Enterprise-Hardware und günstige Consumer-GPUs reichen für verteilte Inferenz.

Open Source

Vollständig unter Apache 2.0. Keine Vendor-Lock-ins, keine versteckten Kosten, kein proprietärer Stack.

Token-Kosten

Bis zu 75 % weniger API-Kosten

Nicht jede Frage braucht ein 100-Milliarden-Parameter-Modell. MoE Sovereign klassifiziert Anfragen heuristisch und leitet sie an das günstigste Modell weiter, das die Aufgabe lösen kann — ohne LLM-Overhead für die Klassifikation selbst.

~75 % API-Kostensenkung vs. alle Anfragen direkt an Cloud-LLM
0 € Grenzkosten Self-Hosted pro Anfrage auf lokaler Hardware
70–85 % auf Self-Hosted geroutet triviale & moderate Anfragen
~1.600 Token gespart pro Cache-Hit Planner-Cache (Redis L2)

Intelligentes Routing nach Aufwand

Das heuristische Complexity-Routing klassifiziert jede Anfrage ohne LLM-Call in drei Stufen — und lädt nur bei echter Komplexität teure Modelle.

~55 % Trivial Self-Hosted T1
qwen3.5:32b, phi4:14b
0 € / Anfrage
~30 % Moderate Self-Hosted T2
qwen3.5:72b, mistral-large
0 € / Anfrage
~15 % Complex Optional: Cloud-API
Claude, GPT-4 oder
Self-Hosted 120B+

Internes Benchmark-Ergebnis (Referenz-Setup): Im AIHUB H200-Benchmark (proprietäres, internes Evaluierungs-Framework) erzielte das M10-Gremium-Template (8 Experten auf Legacy-Hardware mit gpt-oss:120b + qwen-3.5:122b) 9/9 Punkte (100 %) — vollständig Self-Hosted, 0 Cloud-API-Calls. Im Demo-Referenz-Deployment delegiert Claude Code mit dem moe-orchestrator-agent-orchestrated-Profil über 80 % der Subtasks an Self-Hosted-Experten.

📈 Anfragen-Verteilung nach Komplexität

💰 Kosteneinsparung vs. reiner Cloud-Betrieb

Funktionen

Alles aus einer Hand

MoE Sovereign bringt alle Komponenten mit, die für eine produktionsreife KI-Infrastruktur benötigt werden.

OpenAI & Anthropic API

Drop-in-Ersatz für OpenAI-Endpunkte und Anthropic Messages API. Jedes kompatible Tool funktioniert ohne Codeänderung.

Claude Desktop & Cowork

Vollständige Anthropic Third-Party-Inference-Gateway-Kompatibilität. Claude Desktop und Claude Cowork leiten alle Anfragen direkt durch das MoE-Sovereign-Cluster — kein Prompt verlässt die eigene Infrastruktur. Setup per scripts/setup-claude-desktop.sh in unter einer Minute.

15 Fachexperten

Spezialisierte LLMs für Recht, Medizin, Code, Mathematik, Übersetzung, Wissenschaft und mehr – koordiniert durch einen Judge.

51 MCP Precision Tools

Deterministische Berechnungen: Mathematik, Datumsarithmetik, Einheitenumrechnung, Kryptographie, Netzwerk-Tools, deutsches Recht.

GraphRAG & Wissensgraph

Neo4j-basiertes Knowledge-Graph-System mit 2-Hop-Traversal, automatischem Ingest via Kafka und Feedback-Integration. Corrective RAG Gate (Yan et al. 2024): Relevanz-Score filtert tangentiale Graph-Treffer vor der Injektion. CAG Compliance Layer (Chan et al. 2024): BAIT/VAIT/DORA/KRITIS-Texte werden deterministisch vorab injiziert — kein Retrieval, kein Fehler.

4-schichtiges Caching

ChromaDB Semantik-Cache, Redis Plan-Cache, GraphRAG-Cache und Performance-Scores reduzieren Latenz und GPU-Last.

Private Web-Suche

SearXNG Meta-Suchmaschine ohne Tracking für Research-Anfragen – vollständig selbst gehostet, keine externen Suchanfragen.

User-Management

API-Keys, Token-Budgets, CC-Profile und Expert-Templates pro Nutzer konfigurierbar – via Admin-UI oder REST-API.

Monitoring & Observability

Prometheus-Metriken, 5 vorgefertigte Grafana-Dashboards, Echtzeit-Pipeline-Logs via WebSocket im Admin-UI.

Starfleet — Ambient Intelligence

LCARS-Statusdashboard mit proaktivem Watchdog-Alert-Loop, Live-Node-Health (15 s-Polling), E‑Mail-Eskalation mit Cooldown, projektübergreifendem Missions-Kontext und per-Template aktivierbarer Systemprompt-Injektion. Alle Schwellwerte ohne Neustart konfigurierbar.

Deterministisches Complexity Routing

Regelbasierte Anfragen-Klassifikation (trivial/moderate/complex) ohne LLM-Call — bewusst nicht lernend, dafür vollständig transparent, reproduzierbar und ohne Black-Box-Entscheidungen. Spart bis zu 80 % der Pipeline-Kosten für einfache Anfragen.

Self-Correction Loop

Feedback (Rating 1–5) fließt in Expert-Performance-Scores und Few-Shot-Beispiele ein – das System lernt aus Fehlern automatisch.

Vision & Multimodal

Bild-, Screenshot- und Dokumentenanalyse via Base64-Input durch multimodale Tier-2-Experten-Modelle.

Kafka Event-Streaming

Asynchrone Hintergrundverarbeitung: GraphRAG-Ingest, Anfragen-Audit-Log und Feedback-Verarbeitung entkoppelt vom HTTP-Pfad.

Thompson Sampling (RL)

Stochastische Expert-Bewertung via Beta-Verteilung statt statischer Laplace-Scores. Natürliche Exploration neuer Experten ohne Cold-Start-Problem.

Correction Memory

Vergangene Korrekturen werden als Neo4j-Knoten gespeichert und bei ähnlichen Anfragen automatisch als Context in den Expert-Prompt injiziert.

Context Window Abstraction

Automatische Budget-Berechnung pro Modell-Context-Window. Per-Template konfigurierbare History-Compression mit GraphRAG als Langzeitgedächtnis.

1 Mio.-Token-Kontextfenster

Tier-2 Semantic Memory via ChromaDB: Gesprächsrunden werden als Vektoren gespeichert und per direktem Numpy-Cosine-Ranking on-demand abgerufen (kein HNSW-Approximationsfehler). Das effektive Kontextfenster überschreitet damit jedes native LLM-Limit — unabhängig vom eingesetzten Modell und ohne Token-Mehrkosten zur Laufzeit.

Agentic Re-Planning Loop

Nach jeder Synthese prüft ein Gap-Detektor die Vollständigkeit. Bei offenen Fragen startet automatisch eine fokussierte Folge-Runde – ohne Nutzerinteraktion, bis zu 3 agentische Iterationen.

PowerPoint-Generierung (MCP)

Das MCP-Tool generate_pptx erzeugt vollständig formatierte Präsentationen direkt aus dem Chat und liefert einen signierten Download-Link – kein Export, kein manuelles Erstellen.

Selektiver Template-Export

Im Admin-UI können einzelne Expert-Templates und CC-Profile per Checkbox ausgewählt und gezielt exportiert werden – kein Vollexport mehr nötig.

Security Hardening

SSRF-Schutz für ausgehende URL-Anfragen, Rate Limiting auf API-Ebene, Container Hardening (Read-Only Filesystem, No-New-Privileges, eingeschränkte Capabilities). Schutz gegen gängige Angriffsvektoren auch in Self-Hosted-Deployments.

Lineage & Datenkatalog

OpenLineage-Events fließen in einen eingebetteten Marquez-Server; die Admin-UI /catalog aggregiert Marquez-Datasets, Neo4j-Wissens­domänen und lakeFS-Repositories in einer durchsuchbaren, quellenfilterbaren Tabelle — Foundry-inspiriertes Cross-Source-Browsing ohne die Admin-UI zu verlassen.

Datenversionierung & Branch-basierte Freigabe

Jeder externe Wissens-Bundle wird auf einem lakeFS-Branch pending/<tag>-<ts> gestaged statt direkt in Neo4j geschrieben. Admins prüfen offene Imports auf /approval und entscheiden mit einem Klick über Approve (Neo4j-Import + Merge nach main) oder Reject (Branch-Löschung). Expliziter Gate vor jedem Schreibzugriff auf den Live-Graphen.

NiFi ETL-Fan-Out

Apache NiFi mit ListenHTTP-Prozessor empfängt Bundle-Submissions und fächert sie als OpenLineage-Runs ans Cluster aus. Der ETL-Layer ist Nachvollziehbar auf /enterprise, jeder Lauf erscheint mit seinen Eingaben, Ausgaben und Statusfeldern in der Lineage-Übersicht.

Data Health & Drift Detection

Jeder erfolgreiche Wissens-Import wird in einen Stats-Snapshot eingerahmt; compute_drift() markiert entity_dedup_suppressed, zero_entities_added, entity_count_shrank und Co. Ergebnisse landen mit Severity-Pillen (ok / info / warn / crit) auf dem Enterprise-Dashboard und in einem Redis-Ringpuffer (max. 500 Events). Schwellwert über DATA_HEALTH_DRIFT_THRESHOLD tunable.

Read-only Cypher Explorer

In-Page-Cypher-Editor unter /explorer mit zwei unabhängigen Schreibschutz-Schichten: Regex-Blacklist gegen CREATE/DELETE/SET/MERGE/REMOVE/DROP/ALTER/GRANT/REVOKE/FOREACH plus READ_ACCESS-Treibermodus. Inkl. Preset-Queries und Deep-Link in den Neo4j-Browser — ad-hoc-Analysen ohne Risiko für den Live-Graphen.

JupyterLite-Notebook im Admin-UI

Eingebettetes JupyterLite (Browser-WASM-Python — kein Server-Kernel nötig) unter /notebook samt fünf Copy-Paste-Snippets für die Orchestrator-API (Export, Pending-Import, Search, Cypher, Lineage-Runs). Power-User prototypen direkt am Live-Graphen, ohne Python irgendwo zu installieren. JUPYTERLITE_URL konfigurierbar für Air-Gap-Deployments.

Architektur

Systemarchitektur

LangGraph-gesteuerte Pipeline mit parallelem Expert-Fan-Out, 4-schichtigem Caching und asynchronem Kafka-Backend.

Docker-Services

Laufende Dienste und ihre Ports
Service Image Port Funktion
LangGraph OrchestratorPython/FastAPI8002Hauptservice: API, Pipeline, Streaming
MCP Precision ToolsPython800351 deterministische Berechnungs- und Recherche-Tools (AST-Whitelist)
ChromaDBChromaDB8001Vektor-Datenbank: semantisches Caching (L1) und Tier-2 Semantic Memory (1 Mio.-Token-Kontextfenster)
RedisRedis Stack6379Plan-Cache, Performance-Scores, Checkpoints
Neo4jNeo4j 5 Community7474/7687Wissensgraph für GraphRAG
KafkaApache Kafka KRaft9092Event-Streaming, Audit-Log, Feedback-Loop
PrometheusPrometheus9090Metriken (API, GPU, Container, Host)
GrafanaGrafana30015 vorgefertigte Monitoring-Dashboards
SearXNGSearXNG8888Private Meta-Suchmaschine ohne Tracking
MarquezOpenLineage5000Lineage-Server — Inputs/Outputs jedes Pipeline-Laufs (optional, Enterprise Stack)
lakeFSlakeFS8000Git-Style-Versionierung von Wissens-Bundles auf MinIO (optional, Enterprise Stack)
Apache NiFiNiFi8443ETL-Fan-Out via ListenHTTP-Prozessor (optional, Enterprise Stack)

Zwei-Tier Modell-Architektur

Tier-Eigenschaften und Eskalationskriterien
Tier Parameter VRAM (4-bit) Einsatz Eskalation
T1 ≤ 20 Mrd. 8–16 GB Schnelle Erstmeinung, meiste Anfragen Wenn KONFIDENZ < 0,65
T2 > 20 Mrd. 16–40 GB Komplexe Reasoning-Aufgaben, niedrige Konfidenz Endpunkt

4-schichtiges Caching

L1

Semantisches Cache

ChromaDB Vektorsuche
Kosinus-Distanz < 0,15 → direkter Hit

permanent
L2

Plan-Cache

Redis: Ausgabe des Planner-LLM
spart ~1.600 Tokens pro Treffer

30 Minuten
L3

GraphRAG-Cache

Redis: Neo4j Kontextabfragen
vermeidet redundante Graph-Traversals

1 Stunde
L4

Performance-Scores

Redis: Modell-Bewertungen je Kategorie
Laplace-Smoothing für Routing

permanent

Drei-Tier Gesprächsgedächtnis — effektives 1 Mio.-Token-Kontextfenster

MoE Sovereign überwindet die nativen Kontextfenster-Limitierungen einzelner Modelle durch eine dreistufige Gedächtnisarchitektur. Jede Stufe deckt einen anderen Zeitbereich ab — ohne Token-Mehrkosten zur Laufzeit.

T1

Hot Memory

Die letzten n Gesprächsrunden direkt im LLM-Context. Verbatim, kein Verlust, sofortiger Zugriff.

aktuelle Session
T2

Warm Memory (Semantic)

Verdrängte Runden werden als nomic-embed-text-Vektoren (768 Dim.) in ChromaDB gespeichert. Retrieval: direktes Numpy-Cosine-Ranking → Topic-Overlap-Fallback → Keyword-Metadaten-Filter. Garantierter Recall auch bei 1 Mio.+ gespeicherten Tokens.

konfigurierbares TTL
T3

Cold Memory (GraphRAG + Episodisch)

Neo4j-Wissensgraph: dauerhaft gespeicherte Fakten, Entitäten und Relationen. Wird bei Wissensfragen automatisch per GraphRAG abgefragt. Neu (v2.5): Episodisches Gedächtnis (Tulving 1972, Park et al. 2023) — erfolgreiche Task-Verläufe werden als :Episode-Knoten gespeichert und bei ähnlichen Anfragen als Routing-Hinweis injiziert.

dauerhaft / 90 Tage (Episodisch)

Vergleich: Natives Kontextfenster vs. Tier-2 Semantic Memory

Effektive Kontexttiefe und Datenschutz im Systemvergleich
System Natives Fenster Effektives Fenster Privacy Kosten (Inferenz)
GPT-4o (OpenAI) 128 000 Tokens 128 000 Tokens ☀︎ Cloud per Token
Claude 3.5 Sonnet 200 000 Tokens 200 000 Tokens ☀︎ Cloud per Token
Lokales 7B-Modell (ohne SM) 4 000–32 000 Tokens 4 000–32 000 Tokens 🔒 Lokal 0
MoE Sovereign + Tier-2 SM 4 000–32 000 (Modell) 1 000 000+ Tokens (Infra) 🔒 Lokal 0

MRCR-lite v2 — Benchmark-Ergebnisse (60 Runs, April 2026)

Der MRCR-lite-v2-Benchmark injiziert Fakten ("Nadeln") in eine synthetische Konversation und verdrängt sie gezielt aus dem LLM-Kontext. Die einzige Variable: ChromaDB vorbesetzt (WITH) oder leer (WITHOUT).

Recall nach Needle-Depth — moe-memory-aihub-hybrid, nomic-embed-text 768-dim
Depth (Füll-Turns) WITHOUT Semantic Memory WITH Semantic Memory Status
50,0001,000✓ Benchmark bestätigt
100,0001,000✓ Benchmark bestätigt
200,0001,000✓ Benchmark bestätigt
50–1000,000~1,000Retrieval-Unit-Test ✓ (Rang #1, Dist. 0,34)

60 Runs: 5 Nadeln × 3 Depths × 2 Bedingungen × 2 Repetitionen. Gesamt WITH-Score: 1,000. Retrieval: direktes Numpy-Cosine-Ranking, kein HNSW.

Token-Overhead des MoE-Zyklus

Gemessen: direkter AIHUB-Aufruf vs. volles MoE-Pipeline (Planner + Expert + Judge). Der absolute Prompt-Overhead ist konstant — unabhängig von der Anfrage-Kategorie.

Token-Overhead nach Kategorie (10 Prompts, April 2026)
Kategorie Direkt (Tokens) MoE (Tokens) Overhead-Faktor
Knowledge~4.640~29.4506,35× ← günstig
Coding~1.880~18.95010,36×
Math~1.270~15.40012,48×
Reasoning~1.750~16.00014,76×
Instruction Following~460~18.70042,66×
Gesamt~2.011~19.84417,32×

Prompt-Fixkosten des MoE-Zyklus: konstant ~11.000 Tokens pro Request. Empfehlung: MoE-Pipeline für wissensintensive Anfragen (Knowledge, Coding); nativer Modus (moe_mode: native) für kurze, einfache Fragen.

Kompatibilität & Aktivierung

Tier-2 Semantic Memory ist vollständig OpenAI-API-kompatibel. Kein Client-Code muss geändert werden — Open WebUI, Claude Code, jeder OpenAI-SDK-Client profitiert automatisch. Aktivierung per Template-Flag im Admin-UI: 

{
  "enable_semantic_memory": true,
  "semantic_memory_n_results": 8,
  "semantic_memory_ttl_hours": 168,
  "enable_cross_session_memory": true,
  "cross_session_scopes": ["private", "team"]
}

Praxisbeispiele: Wann lohnt sich Tier-2 Semantic Memory?

💻

Softwareprojekt

Architekturentscheidungen, Bug-Reports und API-Diskussionen aus vergangenen Sessions werden bei Code-Reviews automatisch abgerufen. „Warum haben wir damals PostgreSQL statt MongoDB gewählt?“ — sofort beantwortet.

Overhead: 10,36×
📚

Wissensmanagement

Team-Mitglieder teilen Recherche-Ergebnisse und Erkenntnisse. Was Person A letzte Woche herausgefunden hat, kann Person B heute per Cross-Session abrufen — ohne erneute Suche. Günstigster Overhead-Faktor.

Overhead: 6,35×
🧍

Beratung & Support

Bei Folge-Gesprächen mit demselben Kunden erinnert sich das System an frühere Problemlösungen, Präferenzen und Vereinbarungen. Kein erneutes Erklären des Kontexts bei jeder neuen Session.

Overhead: 6–15×
📋

Forschung & Analyse

Wochenlange Recherchen über komplexe Themen akkumulieren sich. Hypothesen, Quellen und Zwischenergebnisse aus Session 1 sind in Session 20 noch abrufbar — das System denkt mit, wo ein Mensch aufgehört hätte.

Overhead: 6,35–12×

Modus-Vergleich: Stärken & Schwächen

Vier Betriebsmodi — Token-Overhead, Eignung und Grenzen
Modus Overhead Stärken Schwächen Ideal für
native 1× Minimale Latenz, kein Token-Overhead, direkte Antwort Kein Gedächtnis, kein Multi-Expert-Routing, keine Werkzeuge Kurze Fragen, Berechnungen, schnelle Lookups
moe_orchestrated 6–43× (Ø 17×) Multi-Expert-Synthese, MCP-Werkzeuge, GraphRAG, Selbstkorrektur Hoher Token-Overhead; unrentabel für einfache Anfragen Komplexe, fachübergreifende Fragen; Recherche; Code-Review
moe_orchestrated + Semantic Memory 17× + ~50 ms Langzeitgedächtnis über Session-Grenzen; Depth 5–20+ mit 1,0 Recall Embedding-Warmup nötig; ~50 ms Retrieval-Overhead Projektbegleitung, Support, Forschung über mehrere Sessions
moe_orchestrated + Cross-Session 17× + ~50 ms Team-Wissen geteilt; institutionelles Gedächtnis; Scope-Hierarchie Explizites Sharing nötig; Datenschutz-Setup erforderlich Wissensmanagement, gemeinsame Projekträume, Kundensupport-Teams

Alle Modi sind per config_json im Admin-UI pro Template konfigurierbar. Der Modus wird im OpenAI-API-Request transparent durchgereicht — kein Client-Code muss geändert werden.

Experten-System

15 konfigurierbare Fachexperten

Jeder Experte ist auf seinen Bereich optimiert – mit passenden System-Prompts, Modellauswahl und Tier-Strategie.

Experten-Kategorien, Tier-Zuweisung und Einsatzbereich
Kategorie Tier Beispiel-Modelle Einsatzbereich Besonderheit
generalT2Konfigurierbar via Admin UIAllgemeinwissen, Definitionen, Erklärungen–
mathT1+T2Konfigurierbar via Admin UIBerechnungen, Gleichungen, Statistik+ MCP + SymPy
technical_supportT1+T2Konfigurierbar via Admin UIIT, DevOps, Docker, Netzwerk, LinuxMCP-Netz-Tools
code_reviewerT2Konfigurierbar via Admin UICode-Review, Security, RefactoringOWASP-fokussiert
creative_writerT2Konfigurierbar via Admin UITexterstellung, Marketing, Storytelling–
medical_consultT1+T2Konfigurierbar via Admin UIMedizinische Informationen, SymptomeCritic-Node
legal_advisorT2Konfigurierbar via Admin UIDeutsches Recht: BGB, StGB, HGBCritic + MCP Recht
translationT2Konfigurierbar via Admin UIProfessionelle Übersetzungen DE↔EN↔FR↔ES↔IT–
data_analystT1Konfigurierbar via Admin UIStatistik, Pandas, Datenanalyse, SQL+ MCP Stats
scienceT2Konfigurierbar via Admin UIChemie, Biologie, Physik, Wissenschaft–
reasoningT1+T2Konfigurierbar via Admin UIKomplexe Logik, Strategie, AnalyseThinking-Node
visionT2Konfigurierbar via Admin UIBild-, Screenshot-, DokumentenanalyseBase64-Input
agentic_coderT2Konfigurierbar via Admin UIAutonome Code-GenerierungVollständige Dateiausgabe
web_researcherT1Konfigurierbar via Admin UIWeb-Recherche via SearXNGEchtzeit-Suche
tool_expertT1Konfigurierbar via Admin UIMCP-Tool-Orchestrierung51 Tools

Das KONFIDENZ-System

Jeder Experte gibt mit seiner Antwort eine Konfidenzangabe zurück. Diese bestimmt, ob das Ergebnis direkt verwendet oder an ein leistungsstärkeres Tier-2-Modell eskaliert wird:

Ausgabe-Modi

Verfügbare Ausgabe-Modi (model-Feld)
Modell-ID Modus Beschreibung
moe-orchestratorStandardVollständige Antworten mit Erklärungen
moe-orchestrator-codeCodeNur Code-Ausgabe, kein Prosatext
moe-orchestrator-concisePräziseMaximal 120 Wörter, kein Fülltext
moe-orchestrator-researchRechercheTiefe Analyse mit Quellenangaben
moe-orchestrator-reportBerichtStrukturierter Report mit Abschnitten
moe-orchestrator-agentAgentTool-Use optimiert für Agenten
moe-orchestrator-agent-orchestratedAgent MoEClaude Code mit vollem MoE-Fanout
moe-orchestrator-planPlanAufgabenplanung mit Schritt-Liste

MCP Precision Tools

Deterministische Werkzeuge ohne Halluzinationen

LLMs halluzinieren bei Berechnungen, Datumsarithmetik und juristischen Paragraphen. 51 MCP Precision Tools ersetzen diese durch exakte, verifizierbare Berechnungen.

✦ Mathematik

  • calculate – Sichere arithmetische Auswertung
  • solve_equation – SymPy Gleichungslöser
  • prime_factorize – Primfaktorzerlegung
  • gcd_lcm – Größter gemeinsamer Teiler / kgV
  • roman_numeral – Arabisch ↔ Römisch

📅 Datum & Zeit

  • date_diff – Differenz zwischen Daten
  • date_add – Datum addieren/subtrahieren
  • day_of_week – Wochentag berechnen

📏 Einheiten & Statistik

  • unit_convert – km, Meilen, kg, lb, °C, °F, ...
  • statistics_calc – Mittelwert, Median, Stdabw., Perzentile

🔒 Kryptographie & Kodierung

  • hash_text – MD5, SHA-256, SHA-512
  • base64_codec – Base64 encode/decode

🌐 Netzwerk

  • subnet_calc – CIDR-Analyse, Netzmaske, Broadcast

📜 Text & Muster

  • regex_extract – Reguläre Ausdrücke anwenden
  • text_analyze – Wortanzahl, Zeichen, Sätze
  • json_query – JSONPath-Extraktion

⚖ Deutsches Recht

  • legal_search_laws – Gesetze durchsuchen
  • legal_get_law_overview – Gesetz-Übersicht
  • legal_get_paragraph – Paragraphen abrufen
  • legal_fulltext_search – Volltext-Suche (BGB, StGB, ...)

Einstieg

Anforderungen & Deployment

MoE Sovereign läuft auf jeder Hardware mit Docker — von einer einzelnen VM bis zum Multi-Node GPU-Cluster. Der Orchestrator selbst benötigt keine GPU und keinen VRAM; Inferenz erfolgt über externe Backends (z. B. eigene GPU-Nodes oder Cloud-APIs).

1

Solo-Profil

  • ZielEinzelne VM, Proxmox LXC, Raspberry Pi 5, Windows WSL 2
  • RAM8 GB Minimum
  • GPUOptional (API-Modus möglich)
  • Disk40 GB
  • Installdeploy/lxc/setup.sh
~1,5 GiB RAM-Footprint
2

Team-Profil

  • ZielDocker-Host, Homelab-Server
  • RAM16 GB+ empfohlen
  • GPUNicht erforderlich (externe Inferenz-Backends)
  • Disk100 GB+
  • Installdocker compose up -d
~6 GiB RAM-Footprint
3

Enterprise-Profil

  • ZielK3s, Kubernetes, OpenShift (architektonisch vorbereitet – Community-Validierung erbeten)
  • FeaturesHA, HPA, PDB, Multi-Tenant
  • GPUMulti-Node heterogene Cluster
  • StorageExterner Data-Tier (Longhorn, NFS)
  • Installhelm install moe charts/moe-sovereign
Variabel — skaliert mit Workload

Ein OCI-Image, drei Profile: Dasselbe Container-Image läuft auf allen Deployment-Zielen. Nur Umgebungsvariablen und der umgebende Wrapper unterscheiden sich — kein Code-Fork, kein Feature-Verlust. VRAM-bewusstes Scheduling verteilt Modelle automatisch auf heterogene GPU-Knoten basierend auf konfigurierbaren VRAM-Limits pro Node.

curl -sSL https://raw.githubusercontent.com/h3rb3rn/moe-sovereign/main/install.sh | bash

Install-Script: Debian 11–13 & Ubuntu 22.04–26.04 — Deployment via Docker / Podman Compose auf jeder Linux-Distribution

System-Monitoring

Admin UI — System-Monitoring

Das integrierte Monitoring-Dashboard zeigt Echtzeit-Metriken: Anfragen, LLM-Server-Status, Token-Verbrauch pro Modell, Cache-Performance, Expert-Aufrufverteilung und Nutzer-Bewertungen auf einen Blick.

MoE Sovereign Admin UI — System-Monitoring-Dashboard mit LLM-Server-Status, Token-Verbrauch, Cache-Performance und Expert-Aufruf-Statistiken
System-Monitoring nach produktivem Betrieb — alle Gauges, LLM-Server-Karten, Chart.js-Widgets für Token-Verbrauch, Cache, Expert-Kategorien und Latenzen. Dokumentation ›

API & Integration

OpenAI-kompatibler Einstieg

MoE Sovereign verhält sich wie die OpenAI-API und unterstützt zusätzlich die Anthropic Messages API. Jede bestehende Integration funktioniert ohne Codeänderung.

Schnellstart mit cURL

bash POST /v1/chat/completions 
curl -X POST https://api.moe-sovereign.org/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <IHR-API-KEY>" \
  -d '{
    "model": "moe-orchestrator",
    "messages": [
      {"role": "user", "content": "Erkläre mir den Unterschied zwischen TCP und UDP"}
    ],
    "stream": false
  }'

Streaming aktivieren

bash Server-Sent Events 
curl -X POST https://api.moe-sovereign.org/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <IHR-API-KEY>" \
  -d '{
    "model": "moe-orchestrator-code",
    "messages": [{"role": "user", "content": "Schreibe eine Python Fibonacci-Funktion"}],
    "stream": true
  }'

Python mit openai-Bibliothek

python OpenAI-SDK Drop-in 
from openai import OpenAI

client = OpenAI(
    base_url="https://api.moe-sovereign.org/v1",
    api_key="<IHR-API-KEY>"
)

response = client.chat.completions.create(
    model="moe-orchestrator-research",
    messages=[{"role": "user", "content": "Analysiere die Vor- und Nachteile von Kubernetes"}]
)
print(response.choices[0].message.content)

Claude Code Integration (.bashrc)

bash ~/.bashrc oder ~/.zshrc 
# MoE API als Anthropic-Backend für Claude Code
export ANTHROPIC_BASE_URL=https://api.moe-sovereign.org
export ANTHROPIC_API_KEY=<IHR-API-KEY>

Codex CLI Integration

bash OpenAI Responses API (/v1/responses) 
# MoE API als OpenAI-Backend für Codex CLI
export OPENAI_BASE_URL=https://api.moe-sovereign.org
export OPENAI_API_KEY=<IHR-API-KEY>

codex --model moe-reference-30b-balanced

Vollständige API-Referenz, Authentifizierung, Budgetverwaltung und Integrationsanleitungen in der Dokumentation: docs.moe-sovereign.org ↗

Föderation

MoE Libris — Föderierter Wissensaustausch

Was wäre, wenn unabhängige KI-Systeme voneinander lernen könnten, ohne ihre Autonomie aufzugeben? MoE Libris macht das möglich — ein Föderations-Hub inspiriert vom Fediverse (Mastodon, Friendica), über den souveräne MoE-Instanzen freiwillig Wissensgraph-Einträge als JSON-LD-Bundles austauschen. Keine zentrale Autorität, keine erzwungene Synchronisation. Jeder Knoten entscheidet selbst, was er veröffentlicht und was er annimmt.

Wie es funktioniert

MoE Libris folgt einer Hub-and-Spoke-Architektur. Jede MoE-Sovereign-Instanz betreibt einen eigenen Libris-Knoten, der sich über ein bilaterales Handshake-Protokoll mit Föderationspartnern verbindet — beide Seiten müssen explizit zustimmen, bevor Daten fließen. Knoten finden sich über eine öffentliche Git-Registry (Registrierung per Pull Request), was die Entdeckung dezentral und transparent hält.

Der Push/Pull-Zyklus läuft folgendermaßen ab: Ein Knoten kuratiert Wissensgraph-Tripel aus seiner lokalen Neo4j-Datenbank, verpackt sie als JSON-LD-Bundles, leitet sie durch eine Pre-Audit-Pipeline (Syntaxvalidierung + heuristische Prüfung auf PII und Geheimnisse) und sendet sie an Föderationspartner. Auf der Empfangsseite landen eingehende Bundles in einer Admin-Audit-Queue, in der jeder Eintrag explizit freigegeben werden muss, bevor er in den lokalen Wissensgraphen integriert wird.

Das löst konkrete Probleme: Datensilos zwischen isolierten KI-Deployments, Vendor-Lock-in durch proprietäre Wissensspeicher und das Kaltstart-Problem für neue Installationen. Ein frisches MoE-Sovereign-Deployment kann kuratiertes Wissen aus der Föderation importieren und sofort von der kollektiven Erfahrung des Netzwerks profitieren — bei voller Kontrolle darüber, was in den eigenen Wissensgraphen aufgenommen wird.

Vertrauensmodell

Importierte Tripel werden niemals als vollwertiges lokales Wissen behandelt. Sie starten auf einem konfigurierbaren Vertrauens-Minimum und müssen durch lokale Nutzung Bestätigung ansammeln, bevor ihr Trust-Score steigt. Wenn ein importiertes Tripel einem bestehenden lokalen Tripel widerspricht, markiert das System den Widerspruch zur Admin-Prüfung, anstatt stillschweigend zu überschreiben. Das verhindert Wissensvergiftung, während das Netzwerk trotzdem wachsen kann.

Technische Details

Datenformat: Wissenseinträge werden als JSON-LD-Tripel (Subjekt-Prädikat-Objekt) mit Provenienz-Metadaten, Zeitstempeln und Trust-Scores serialisiert. Das Format ist selbstbeschreibend und interoperabel mit Standard-RDF-Werkzeugen.

Pre-Audit-Pipeline: Vor dem Export durchläuft jedes Bundle zwei Stufen: (1) Syntaxvalidierung zur Sicherstellung wohlgeformter JSON-LD- und gültiger Tripelstruktur, und (2) heuristische Prüfung, die potenzielle PII (Namen, E-Mail-Adressen, Postanschriften), API-Keys, Zugangsdaten und sensible Relationstypen erkennt. Markierte Einträge werden zur manuellen Prüfung zurückgehalten.

Missbrauchsprävention: Die Föderation implementiert ein abgestuftes Strike-System. Knoten, die wiederholt qualitativ minderwertigen, markierten oder abgelehnten Inhalt senden, sammeln Strikes. Schwellenwerte lösen Rate-Limiting, temporäre Sperrung und schließlich permanenten Ausschluss aus der Föderation aus — jeweils lokal vom empfangenden Knoten durchgesetzt.

Stack: FastAPI für die Föderations-API, PostgreSQL für Föderationsstatus und Audit-Logs, Neo4j für den globalen Wissensgraphen, Valkey für Caching und Rate-Limiting. Der gesamte Stack läuft in Docker-Containern neben dem MoE-Sovereign-Hauptdeployment.

moe-libris.org ↗

Compliance-Schicht — Open Source

MoE Codex — Souveräne Daten­intelligenz für regulierte Sektoren

Für 95 % der Operator genügt der souveräne LLM-Gateway — das ist MoE Sovereign. Die verbleibenden 5 % in regulierten Sektoren benötigen dokumentierte Risikoeinstufung, Datenabstammung, Freigabe-Workflows und Audit-Trails. Das ist MoE Codex — eine Open-Source-Erweiterungsschicht, die architektonisch an Plattformen wie Palantir Foundry orientiert ist, ohne deren kommerziellen Reifegrad zu beanspruchen.

Was MoE Codex leistet

MoE Codex ist eine opt-in Erweiterungsschicht, die neben einem laufenden MoE-Sovereign-Deployment deployt wird. Sie ergänzt den LLM-Gateway um einen vollständigen Daten-Management-Stack:

  • Data Catalog: Asset-Entdeckung, Schema-Registry, Tagging und Klassifizierung aller Datenquellen.
  • Approval Workflows: Mehrstufige Freigabe-Gates bevor Daten KI-Pipelines erreichen. Rollenbasierte Prüferzuweisung und dokumentierte Entscheidungen.
  • Daten-Lineage (OpenLineage / Marquez): Lückenlose Nachverfolgung von der Rohdatenquelle bis zum Inferenz-Output.
  • Daten-Versionierung (lakeFS): Git-artige Branches und Commits für Datensätze. Reproduzierbare Snapshots für Compliance-Audits.
  • Drift-Detection: Kontinuierliches Monitoring von Wissensgraph-Metriken und statistischer Datendrift.
  • ETL-Automatisierung (Apache NiFi): Visuelle Datenfluss-Gestaltung ohne Code.
  • Objekt-Explorer (Cypher): Read-only Graph-Abfrageinterface für Compliance-Untersuchungen durch Datenschutzbeauftragte.
  • JupyterLab Notebook: Proxied Notebook-Umgebung für reproduzierbare Datenanalyse innerhalb des souveränen Perimeters.
  • Pipeline Builder (Kestra): Workflow-Orchestrierung für datenzentrierte Prozesse als leichtgewichtige NiFi-Alternative.
  • Formulare (JSONForms): Strukturierte Dateneingabe mit Schema-Validierung für Compliance-Formulare und Risikobewertungen.
  • Charts & Analytics: Eingebettete Pivotanalyse und Visualisierung von Catalog- und Lineage-Daten.
  • Link-Analyse (Cytoscape.js): Interaktive Graph-Exploration für Ermittlungen und Beziehungsanalysen.
  • Zeitachse (vis-timeline): Zeitbasierte Darstellung von Ereignisketten über Entitäten und Datenbewegungen.
  • Föderierte Suche (OpenSearch): Mandantenfähige Volltext- und Vektorsuche über Catalog-Bestsände.

Regulatorische Abdeckung

MoE Codex wurde mit den aktuellen EU-Regulatorien im Blick entwickelt: EU AI Act (Reg. 2024/1689) — Hochrisiko-Systeme nach Anhang III benötigen Risikodokumentation und Audit-Trails; MoE Codex liefert beides. NIS2 / NIS2UmsuCG — Risikomanagement und Lieferketten-Transparenz für wesentliche Einrichtungen. DSGVO Art. 35 DSFA — Catalog-Metadaten und Lineage-Einträge dokumentieren Verarbeitungstätigkeiten. BSI-Grundschutz & C5 — Hosting auf BSI-C5-zertifizierten EU-Providern (Hetzner, IONOS, STACKIT, OVHcloud).

Das BVerfG-Urteil 2023 (Hessendata = Palantir Gotham als verfassungswidrig erklärt) hat einen akuten Bedarf für souverän deploybare, technisch prüfbare Datenplattformen in der EU geschaffen. MoE Codex adressiert genau diesen Bedarf als Open-Source-Ansatz: Apache 2.0, Air-Gap-fähig, vollständig prüfbare Codebasis, kein US-Cloud-Abhängigkeit, kein Vendor Lock-in.

Klare Einordnung: MoE Codex ist kein heutiger Ersatz für Palantir Foundry in Bezug auf Produktreife, Enterprise-Support oder Zertifizierungstiefe. Es ist eine architektonisch verwandte, transparente Open-Source-Plattform — mit dem Potenzial, langfristig in regulierten Szenarien eine belastbare Alternative zu werden, in denen Nachvollziehbarkeit und Datensouveränität wichtiger sind als kommerzielle Ausrüstung.

moe-codex.org ↗

Projektstatus

Roadmap & Meilensteine

MoE Sovereign wurde am 13. April 2026 öffentlich veröffentlicht. Alle vier Launch-Phasen sind abgeschlossen. Die Weiterentwicklung erfolgt mit Community-Beiträgen und föderierten Wissens-Features.

✅

Phase 1: Infrastruktur & Deployment

Docker Compose, LXC, Podman und Helm Deployment-Wrapper. VRAM-bewusstes Scheduling auf heterogenen GPU-Clustern. Prometheus, Grafana und Kafka Observability-Stack.

✅

Phase 2: Architektur & Pipeline

LangGraph-Pipeline mit Two-Tier Expert-Eskalation, 51 MCP Precision Tools, Neo4j GraphRAG mit Trust-Score Self-Healing, 4-Schicht-Cache-Hierarchie, Complexity-Routing und Self-Correction Loop.

✅

Phase 3: Expert-Templates & Benchmarks

69-Modell LLM-Eignungsstudie, 15 Fachexperten-Domänen, 6 Claude Code Profile, GAIA L1 Benchmark (60%), 9,3× Akkumulations-Effekt validiert, Adversarial MCP Testing (9/9 blockiert). AIHUB H200 Benchmark: 9/9 bestanden (100%) mit gpt-oss-120B + qwen-3.5-122B. M10-Gremium 8-Experten-Template: 9/9 bestanden auf Legacy-Hardware. GAIA Benchmark: 14/30 = 46,7 % — übertrifft GPT-4o Mini (44,8 %). 5 iterative Runs (2026-04-25): L1 60 %, L2 50 %, L3 40 % (best run). 8 neue deterministische MCP-Tools (wikidata_sparql, pubmed_search, crossref_lookup, openalex_search, web_browser, wayback_fetch). Thompson Sampling (RL Flywheel), Correction Memory, Context Window Abstraction Layer.

✅

Phase 6: Wissenschaftsbasierte RAG-Erweiterungen — Mai 2026 🧐

Drei neue, peer-review-gestützte Funktionen für den GraphRAG-Layer: Corrective RAG Gate (Yan et al., arXiv:2401.15884) — Relevanz-Score filtert Neo4j-Treffer vor Injektion, verhindert Context-Pollution; CAG Compliance Layer (Chan et al., arXiv:2412.15605) — BAIT/VAIT/DORA/KRITIS-Texte werden deterministisch vorab injiziert, kein Retrieval-Fehler möglich, durch Admin-JSON konfigurierbar; Episodisches Gedächtnis (Tulving 1972; Park et al. arXiv:2304.03442; Packer et al. arXiv:2310.08560) — erfolgreiche Task-Verläufe als :Episode-Knoten in Neo4j, Routing-Hints bei ähnlichen Anfragen. Alle drei Erweiterungen sind fire-and-forget, zero-latency-overhead und vollständig opt-out-fähig.

✅

Phase 5: Tier-2 Semantic Memory — April 2026 🧠

Effektives 1-Mio.-Token-Kontextfenster durch Infrastruktur statt Modell-Upgrades: Verdrängte Gesprächsrunden werden als nomic-embed-text-Vektoren (768 Dim.) in ChromaDB gespeichert und per Hybrid-Retrieval (direktes Cosine-Ranking + Keyword-Fallback) on-demand abgerufen. Template-Flag enable_semantic_memory: true aktiviert Tier-2 für beliebige Expert-Templates ohne Token-Mehrkosten zur Laufzeit. Validiert durch MRCR-lite-v2-Benchmark (Needle-Recall-Test mit Depths 5–100) — Gesamt-Score 1,000; vollständige Benchmark-Ergebnisse in der Kontextfenster-Dokumentation.

✅

Phase 7: EuroHPC-LUMI-G-Grant bewilligt — Juni 2026 🏆

Antrag EHPC-DEV-2026D06-XXX bei EuroHPC bewilligt: Award-Bescheid am 5. Juni 2026 erhalten. 4.500 Node-Stunden (entspricht 18.000 GPU-Stunden) auf dem Supercomputer LUMI-G (AMD MI250X, 128 GB HBM2e pro Node, ROCm-Stack, 2 TB Storage), Laufzeit 6 Monate. Die Förderung finanziert ein Distillation-Forschungsprogramm, das zentrale Routing- und Planungs-Komponenten von Cloud-LLMs auf lokal lauffähige Small Language Models überführt — ein weiterer Schritt in Richtung voller digitaler Souveränität ohne Cloud-Abhängigkeit.

🔎

Phase 8 (laufend): SLM-Distillation & Wissensgraph-Föderation

Aktuelle Forschung im Rahmen des LUMI-G-Grants: fünf Distillation-Ziele — der planner_node (Haupthebel, Ziel Qwen2.5-1.5B / SmolLM2-1.7B als GGUF Q4_K_M, ≥90 % der GAIA-Planqualität des 35B-Lehrermodells bei rund 1/20 der Kosten), ein complexity_estimator (DeBERTa-v3-small, ONNX INT8), ein semantischer Router (multilingualer MiniLM-Encoder + FAISS), eine RL-Routing-Policy (Offline-RL, MLP) und ein Node-Ranker (XGBoost, ONNX). Der 6-Monats-Plan umfasst synthetische Datengenerierung, Encoder-/Reward-Model-Training, SFT+DPO für den Planner, Offline-RL und abschließendes RLHF. Parallel wächst der Wissensgraph rapide (×46 Entitäten / ×56 Relationen in 16 Tagen) — nächster Meilenstein ist die erste Multi-Hub-MoE-Libris-Föderation.

Lizenz: Apache 2.0 · Stack: Python + FastAPI + LangGraph · Mindest-Hardware: kein VRAM – Inferenz über externe API-Backends

Screenshots

System in Aktion

Aktuelle Aufnahmen aus dem produktiven Betrieb — Admin UI, Live-Monitoring, Grafana-Dashboards, Container-Logs und Wissensgraph.

MoE Sovereign Admin UI — Gesamtübersicht mit Systemstatus, Expert-Knoten und Konfigurationsmenü
Admin UI — Gesamtübersicht — Systemstatus, registrierte Expert-Knoten, LLM-Konfiguration und Routing-Profile auf einen Blick.
MoE Admin Live-Monitoring — Echtzeit-Pipeline-Status, Token-Verbrauch, Latenzen und Expert-Aufruf-Statistiken
Admin UI — Live-Monitoring — Echtzeit-Pipeline-Status, Token-Verbrauch, Cache-Trefferquote, Expert-Kategorien und Latenzen. Dokumentation ›
Grafana Dashboard — GPU- und Inference-Node-Auslastung in Echtzeit für alle Cluster-Knoten
Grafana — GPU & Inference Nodes — VRAM-Auslastung, GPU-Last und Inference-Throughput aller Cluster-Knoten in Echtzeit.
Grafana Dashboard — Knowledge Base Health mit Ontologie-Metriken, Gap-Queue und Neo4J-Statistiken
Grafana — Knowledge Base Health — Ontologie-Wachstum, Gap-Queue-Tiefe, Korrekturen und Neo4J-Datenbankstatistiken.
Dozzle Docker Log Viewer — Echtzeit-Container-Logs aller MoE-Dienste
Dozzle — Container-Logs — Echtzeit-Log-Streaming aller MoE-Dienste — Orchestrator, Healer, Admin UI und MCP-Server.
Neo4J Browser — Wissensgraph-Visualisierung mit 500 Entity-Knoten und ihren Beziehungen
Neo4J — Wissensgraph — 500 Entity-Knoten mit semantischen Beziehungen — kuratiert durch den LLM-gestützten Ontologie-Healer.

Platform Architecture

The Complete Sovereign AI Stack

MoE Sovereign is the core — a fully self-hosted LLM gateway with expert routing, GraphRAG, and MCP precision tools. Two optional extensions complete the platform: MoE Codex adds enterprise data intelligence, and MoE Libris enables federated knowledge exchange between sovereign deployments.

MoE Sovereign — LLM Core

The centre of the stack. Template-based multi-model orchestrator with 15 specialist experts, 51 deterministic MCP tools, Neo4j GraphRAG, 4-layer caching, Kafka event streaming, and a 1 million-token semantic memory layer. Runs air-gap ready on any Linux host. Zero mandatory cloud calls.

API: OpenAI-compatible + Anthropic Messages API · Port: 8002

MoE Codex — Data Intelligence Extension

Optional add-on for regulated sectors. Extends the core with a full Palantir Foundry-inspired data management stack — all open source, all deployable alongside MoE Sovereign without touching its configuration.

  • Data Catalog & Lineage — Marquez OpenLineage, cross-source catalog browser
  • Data Versioning — lakeFS Git-style branches and approval gates
  • ETL Automation — Apache NiFi visual flow canvas
  • BI & Analytics — Apache Superset dashboards, Trino federated SQL
  • Investigation Tools — link analysis, timeline, dossier, geospatial layers
  • Policy Enforcement — Open Policy Agent ABAC/RBAC
  • Document Intelligence — DocLing OCR & entity extraction
  • Federated Search — OpenSearch across all catalog sources

Coverage: 92 % of Palantir Foundry/Gotham/AIP surface area · Apache 2.0

MoE Libris — Federation Hub

Optional federation layer. Independent sovereign deployments exchange curated knowledge graph bundles via a Fediverse-inspired hub-and-spoke protocol. Bilateral consent handshake, pre-audit PII pipeline, trust-scored imports, and admin approval queue — no central authority, no forced synchronisation.

Protocol: JSON-LD triples with provenance · Anti-poison: conflict detection + strike system

How the Three Layers Work Together

Stack interaction summary
Layer Role Interfaces with Required
MoE Sovereign LLM gateway, expert routing, GraphRAG, MCP tools Clients via OpenAI / Anthropic API, Codex via REST, Libris via bundle import Yes — core platform
MoE Codex Data catalog, lineage, versioning, BI, investigation, compliance Receives OpenLineage events from Sovereign; writes approved bundles back to Neo4j Optional — regulated deployments
MoE Libris Federated knowledge exchange between sovereign instances Sends / receives JSON-LD bundles; imports land in Codex approval queue Optional — multi-cluster deployments

Industry Use Cases

Government & Authorities

Deploy Sovereign for citizen-query routing and legal-advisor expert. Add Codex for EU AI Act audit trails, NIS2 risk documentation, and the OPA policy layer that enforces classification markings. Use lakeFS to snapshot evidence datasets before every decision run.

Healthcare & Pharma

Sovereign handles medical consultation routing and document analysis via DocLing. Codex tracks clinical trial dataset versions in lakeFS, records full provenance in Marquez, and surfaces compliance gaps in Superset dashboards connected to Trino’s federated SQL layer.

Banking & Compliance

Route model-risk and regulatory queries through Sovereign’s expert ensemble. Codex delivers the complete audit trail required under DSGVO Art. 35 and BSI C5: OpenLineage lineage from source to inference output, lakeFS dataset commits, OPA policy decisions, and Superset compliance dashboards. OpenSearch enables cross-system investigations without data movement.

GitHub: moe-sovereign ↗   MoE Codex ↗   MoE Libris ↗