Cortex Prime ist eine lokale KI-Plattform für Teams, die ihre Daten selbst kontrollieren wollen. Kein Cloud-Zwang, kurze Wege und ein Setup, das im Alltag nachvollziehbar bleibt.
Mit dem Installer wird aus einem Ubuntu-Server ein solides KI-System: RAM-Drive für schnelle Antworten, lokale Code-Intelligenz mit DeepWiki und Gitea sowie Monitoring für den Betrieb. So arbeitest du fokussiert, ohne ständig an externe Dienste denken zu müssen.
"Entweder du hast die Kontrolle über deine Daten,
oder du bist das Produkt."
Entweder du hast die Kontrolle über deine Daten,
oder du bist das Produkt.
Quellcode und Dokumente bleiben auf deiner eigenen Infrastruktur. Du entscheidest, was wohin geht - nicht ein externer Anbieter.
Das RAM-Drive entlastet die SSD bei aktiven Datenpfaden. Dadurch reagieren Suche, Modelle und RAG auch unter Last spürbar schneller.
Mit Docling, hybrider Suche und Reranking findet die KI relevanten Kontext in komplexen Projekten - nachvollziehbar und nah an deinem echten Code.
Strikte logische und physische Trennung garantiert Ausfallsicherheit, nahtlose Upgrades und optimalen Schutz sensibler Daten.
Textalternative zum Diagramm: Drei Ebenen von Hardware (GPU, RAM-Drive, SSD) links, Host mit Ollama in der Mitte, Docker-Applikationen rechts; Datenflüsse zwischen den Ebenen.
flowchart LR
subgraph C["Hardware-Ressourcen"]
direction TB
GPU["NVIDIA GPU\n(direkt)"]
RAM["RAM-Drive\n(latenzfrei)"]
SSD["SSD\n(Persistenz)"]
end
subgraph B["Host (Bare-Metal)"]
direction TB
OLL["Ollama\n(host, RAM-Modelle)"]
SYN["cortex-sync /\nRestore"]
end
subgraph A["Applikationsschicht (Docker)"]
direction TB
WEBUI["Open WebUI"]
PIPE["Pipelines"]
DOC["Docling"]
QD["Qdrant"]
DW["DeepWiki"]
GT["Gitea"]
end
GPU --> OLL
RAM --> OLL
SSD -.-> SYN
OLL --> WEBUI
OLL --> DW
WEBUI --> PIPE
WEBUI --> QD
PIPE --> DOC
DW --> GT
QD -.-> RAM
classDef app fill:#FFFFFF,stroke:#E2E8F0,stroke-width:1.5px,color:#1A2C3E,rx:12,ry:12;
classDef host fill:#F8FAFE,stroke:#2A7FE1,stroke-width:1.5px,color:#1A2C3E,rx:12,ry:12;
classDef hw fill:#F1F5F9,stroke:#94A3B8,stroke-width:1.5px,stroke-dasharray: 4 4,color:#475569,rx:12,ry:12;
class WEBUI,PIPE,DOC,QD,DW,GT app;
class OLL,SYN host;
class GPU,RAM,SSD hw;
Entspricht cortex-jon.sh: Ollama auf dem Host; Docker-Services im Netz cortex-net. Ein Compose-Stack verbindet Open WebUI mit Pipelines, Docling und Qdrant; DeepWiki und Gitea sind eigene Stacks (Git intern oft http://gitea:3000/...). Optionales externes LLM für Open WebUI über EXTERNAL_PROVIDER_*, siehe README. Qdrant-Speicher liegt auf dem RAM-Drive (/mnt/ramdrive/...).
Jeder Service im Cortex Prime Ökosystem hat eine exakt definierte Aufgabe. Aktuell umfasst der Stack Open WebUI, Pipelines, Docling, Qdrant, DeepWiki, Gitea, Homepage, Dockge, Uptime Kuma, Gotify, Logdy (Host-Logs) und Dozzle (Docker-Logs). Ollama bleibt auf dem Host; ein externes OpenAI-kompatibles LLM kann über EXTERNAL_PROVIDER_* angebunden werden — siehe README.
Empfohlen für einheitliche Links: DASHBOARD_HOST=cortex.local. Der DNS-Alias muss auf die Cortex-Server-IP zeigen.
Hinweis: Ollama bleibt absichtlich nativ auf dem Host; Web-IDE (code-server), RackPeek, Cockpit und ein zweiter Docker-llama-agent sind nicht mehr Teil des Installers — bei Bedarf selbst ergänzen.
Betrieb: cortex-jon.sh startet ohne Parameter mit einem interaktiven Menü (g = GPU live / --gpu-watch). Punkt 6 öffnet Schnell-Status 6.1–6.9: u. a. Container, GPU, Ollama, 6.4 Tools-Untermenü (nvtop, llmfit, hyperfine, Benchmarks, Ollama-/api/tags, Log-tail), Storage, Sync-Status, kompletter --quick-status, 6.8 GPU live, 6.9 RAM→SSD (--sync-now).
Das Cockpit
Modernes Frontend für Chat, Projekte und Wissensräume. Es steuert den Nutzerfluss und verbindet die Kernservices zu einem klaren Arbeitsablauf.
Das Gehirn
Ollama läuft bewusst nativ auf dem Host statt im Container. So bleibt der GPU-Zugriff direkt und die Inferenz stabil bei hoher Last.
Der Vektor-Tresor
Vektor-Datenbank für semantische Suche und Wissenskontext. Im Betrieb liegt sie im RAM-Drive und liefert schnelle Treffer für RAG-Anfragen.
Die Dokumenten-Analysten
Diese Kette bereitet Dokumente sauber für RAG vor. Docling extrahiert Struktur aus Dateien, Pipelines übergibt den Inhalt kontrolliert an Suche und Chat.
Das Kontrollzentrum
Monitoring und Betrieb laufen über Homepage, Dockge, Kuma, Logdy, Dozzle und Gotify. Logdy bündelt die Host-Logs aus /var/log/cortex-prime-installer.log, /var/log/cortex-sync.log, Host-Ollama (/var/log/ollama.log), /var/log/syslog, /var/log/auth.log, /var/log/kern.log, /var/log/ufw.log und /var/log/fail2ban.log. Optional anderer Pfad: OLLAMA_LOG_FILE. Falls GHCR-Pulls für Logdy scheitern, kann das Image per IMG_LOGDY=… (z. B. Docker Hub oder lokales Build) übersteuert werden — siehe README.
Code-Wiki
DeepWiki baut aus Repositories eine durchsuchbare Wissensbasis auf. Teams verstehen dadurch Architektur, Abhängigkeiten und Codebereiche schneller.
Git-Server lokal
Gitea verwaltet Repositories, Branches und Pull-Requests im eigenen Netz. Zusammen mit DeepWiki entsteht ein lokaler Entwicklungsfluss ohne Cloud-Abhängigkeit.
Standard-KI stösst bei komplexem Software-Code oft an ihre Grenzen. Cortex Prime löst dies durch eine ausgeklügelte Datenpipeline: Wissen wird erst strukturiert, dann clever gesucht und abschliessend hochwertig formuliert.
Das System übernimmt komplexe Handbücher und Quelltexte und übersetzt deren Layout-Struktur originalgetreu in maschinenlesbares Markdown.
Fragen an das System nutzen eine kombinierte Suche: Semantische Bedeutung (Vektoren) trifft auf exakte Stichwort-Treffer (BM25).
Ein spezialisiertes Reranking-Modell bewertet die Relevanz der gefundenen Snippets, bevor das Haupt-Sprachmodell die finale, halluzinationsfreie Antwort generiert.
Textalternative zum Sequenzdiagramm: Nutzer, Open WebUI, DeepWiki, Gitea, Qdrant und Ollama; Ablauf von Anfrage über Retrieval und hybride Suche bis zur Antwort.
sequenceDiagram
autonumber
participant U as User
participant W as Open WebUI
participant DW as DeepWiki
participant G as Gitea
participant Q as Qdrant
participant R as "Rerank in WebUI"
participant O as Ollama
U->>W: Frage z. B. Code
W->>DW: Optional Wiki-Kontext
DW->>G: Git-Repo (z. B. Gitea)
DW-->>W: Code-Kontext
W->>Q: Hybride Suche (VECTOR_DB=qdrant)
Q-->>W: Roh-Treffer (Top 20)
W->>R: Reranking (intern)
R-->>W: Top Snippets
W->>O: Prompt (OLLAMA_BASE_URL Host)
O-->>W: Antwort
W-->>U: Ausgabe
Dienstnamen wie im Installer: Open WebUI (VECTOR_DB=qdrant), Qdrant, Ollama auf dem Host. Indexierung läuft über Pipelines/Docling (siehe Architektur-Diagramm) — nicht jeder Schritt erscheint in dieser Chat-Sequenz.
Eine leistungsstarke Architektur ist nur so gut wie ihr messbarer Nutzen im Alltag. Wie verwandelt sich ein passives Sprachmodell in einen aktiven, digitalen Kollegen?
Die folgenden 8 Evolutionsstufen definieren unseren technischen Fahrplan. Im Anschluss zeigen sieben konkrete Use-Cases, wie diese Stufen dein Homelab oder Entwickler-Team heute schon transformieren – von automatisierten Code-Wikis bis zur autonomen IDE-Integration. 100 % lokal, ohne Cloud-Abfluss.
📌 Ebene 1 — Basic Chat (Das Fundament)
Was passiert: Du öffnest Open WebUI im Browser und chattest mit dem konfigurierten Modell (Standardbasis qwen3.5:9b, Ollama-Alias cortex-prime; Code-Alias cortex.prime.coder) über Ollama.
Der Cortex-Vorteil: Die KI läuft komplett lokal. Dank deines RAM-Drives (/mnt/ramdrive) antworten die Modelle latenzfrei. Kein Warten auf Cloud-Server, keine Datenschutzbedenken. Es ist dein privater, rasend schneller Sparringspartner.
📌 Ebene 2 — Memory (Das Langzeitgedächtnis)
Was passiert: Cortex Prime fängt an, dich und deinen Code-Style zu verstehen.
Der Cortex-Vorteil: Über das native Memory-Feature in Open WebUI speichert die KI wichtige Fakten, Vorlieben und Architektur-Entscheidungen dauerhaft in der lokalen Qdrant-Vektordatenbank ab. Du musst dich nicht in jedem Chat neu erklären. Das System wächst mit dir mit.
📌 Ebene 3 — Projekte (Die Wissensräume / RAG)
Was passiert: Die KI wird zum Domänen-Experten für spezifische Aufgaben.
Der Cortex-Vorteil: Du erstellst isolierte Workspaces. Statt allgemeinem Bla-Bla chattest du fokussiert mit deinen eigenen Daten. DeepWiki parst dein Gitea-Repository, Docling zerlegt deine PDFs, und die KI nutzt hybride Suche (BM25 + Vektoren), um millimetergenaue Antworten zu deiner Software-Architektur zu geben.
📌 Ebene 4 — Skills (Lokale Werkzeuge)
Was passiert: Die KI lernt, aktiv Dinge zu tun, statt nur Text zu generieren.
Der Cortex-Vorteil: Du rüstest Open WebUI mit Python-Skripten (Tools) aus. Du gibst der KI die Fähigkeit, selbstständig auf Knopfdruck dein Git-Log auszulesen, lokale Skripte zu triggern oder Server-Metriken abzufragen. Die KI entscheidet im Chat autonom, wann sie welches Werkzeug einsetzen muss, um dein Problem zu lösen.
📌 Ebene 5 — Artifacts (Interaktive Visualisierung)
Was passiert: Code wird nicht nur als Textblöcke ausgespuckt, sondern direkt erlebbar gemacht.
Der Cortex-Vorteil: Wenn Cortex Prime ein Frontend (HTML/JS/React) oder ein komplexes Mermaid-Architekturdiagramm für dich generiert, rendert Open WebUI das Ergebnis als Artifact direkt im Chat-Fenster. Du kannst UI-Komponenten direkt im Browser testen und iterieren, ohne sie erst in deine IDE kopieren zu müssen.
📌 Ebene 6 — Konnektoren (Das MCP-Netzwerk)
Was passiert: Cortex Prime wird zur echten Schaltzentrale für dein gesamtes Netzwerk.
Der Cortex-Vorteil: Über das Model Context Protocol (MCP) dockst du externe Systeme standardisiert an. Ein MCP-Hub im Docker-Netzwerk erlaubt der KI den Live-Zugriff auf PostgreSQL, Gitea-Issues oder Home Assistant. Du sagst: „Analysiere die Fehlermeldungen in der DB und schließe das Gitea-Ticket, wenn es gelöst ist“ – und das System führt es aus.
📌 Ebene 7 — Plugins (Die Automatisierungs-Pipeline)
Was passiert: Event-gesteuerte Workflows laufen im Hintergrund.
Der Cortex-Vorteil: Dein Pipelines-Container (Port 9099) sitzt als intelligenter Filter zwischen WebUI und Ollama. Du baust Logiken wie: „Wenn die KI im Chat einen kritischen Security-Bug im Code findet, schicke automatisch eine Push-Nachricht über Gotify auf mein Handy.“ Das gibt dir programmatische Kontrolle über den gesamten Datenfluss.
📌 Ebene 8 — Cowork & Code (Autonome Agenten)
Was passiert: Die KI verlässt das Chat-Fenster und arbeitet direkt in der Code-Basis mit.
Der Cortex-Vorteil: Der Installer liefert keinen separaten Mission-Control-Stack mehr; autonome Coding-Agenten kannst du z. B. mit VSCodium und Extensions wie Cline betreiben: Der Agent spricht die Host-Ollama-API an, bekommt Terminal- und Workspace-Zugriff und liefert Ergebnisse in deinen Gitea-Flow. Optional externes Cloud-LLM für Open WebUI über EXTERNAL_PROVIDER_*.
Ebenen: 8
Moderne KI geht weiter als nur Chatten. Cortex Prime ist als Laufzeitumgebung für autonome KI-Agenten (Agentic AI) konzipiert. Das latenzfreie RAM-Drive fungiert dabei als Ausführungsumgebung, in der Agenten eigenständig Code generieren, kompilieren und iterativ testen können – wie ein unsichtbarer Entwickler im Team.
Textalternative: Ziel vorgeben, Agent plant, liest Repository, schreibt Code, führt Build und Tests aus, verbessert bei Fehlern und liefert bei Erfolg ein Ergebnis.
%%{init: {'flowchart': {'curve': 'basis', 'diagramPadding': 16, 'nodeSpacing': 38, 'rankSpacing': 42, 'htmlLabels': true}}}%%
flowchart LR
U[Du gibst ein Ziel vor] --> A[Agent plant Schritte]
A --> R[Repository lesen]
R --> C[Code schreiben]
C --> T[Build und Tests ausführen]
T --> D{Tests grün}
D -- Nein --> F[Fehler analysieren und fixen]
F --> C
D -- Ja --> G[Ergebnis bereitstellen]
G --> N[Rückgabe an dich]
classDef default fill:#FFFFFF,stroke:#DEE2E6,stroke-width:1px,color:#343A40,rx:12,ry:12;
classDef highlight fill:#E7F1FD,stroke:#2A7FE1,stroke-width:2px,color:#1A2C3E,rx:12,ry:12;
class A,C,T,F,G highlight;
Vom Ziel bis zur lauffähigen Lösung: planen, bauen, testen, verbessern.
Ebenen: 3, 6
Schluss mit veralteten Readme-Dateien. Durch den Einsatz einer lokalen DeepWiki-Instanz verwandelt Cortex Prime nackte Quellcode-Repositories vollautomatisch in interaktive, KI-gestützte Dokumentationen.
Textalternative: Gitea liefert Code an DeepWiki; Markdown und Mermaid gehen über MCP zu Cortex Prime.
%%{init: {'flowchart': {'curve': 'basis', 'diagramPadding': 16, 'nodeSpacing': 44, 'rankSpacing': 48, 'htmlLabels': true}}}%%
flowchart LR
Gitea[(Lokaler Git-Server)] -->|Code Clone| DW[DeepWiki Engine]
DW -->|Parsing| MD[Markdown Docs]
DW -->|Grafik| Mer[Mermaid Diagramme]
MD --> MCP((MCP Server))
Mer --> MCP
MCP <--> Cortex[Cortex Prime]
classDef default fill:#FFFFFF,stroke:#DEE2E6,stroke-width:1px,color:#343A40,rx:12,ry:12;
classDef highlight fill:#E7F1FD,stroke:#2A7FE1,stroke-width:2px,color:#1A2C3E,rx:12,ry:12;
class DW,Cortex highlight;
Von lokalem Git über DeepWiki bis MCP und Cortex Prime.
Ebenen: 3
Das papierlose Büro neu gedacht: Durch die native Anbindung des Open-Source Dokumentenmanagementsystems Paperless-ngx an das Cortex Prime Ökosystem verwandelt sich ein statisches Archiv in eine interaktive Wissensdatenbank.
Textalternative: Scanner oder Mail zu Paperless, dann Cortex Prime, Docling, Qdrant und Nutzer-Chat.
%%{init: {'flowchart': {'curve': 'basis', 'diagramPadding': 10, 'nodeSpacing': 32, 'rankSpacing': 36, 'htmlLabels': true}}}%%
flowchart LR
Scanner[Scanner / Mail] -->|PDF| Paperless[(Paperless-ngx)]
Paperless -->|Webhook| Cortex[Cortex Prime]
Cortex -->|OCR| Docling[Docling]
Docling -->|Vektoren| Qdrant[(Qdrant)]
Qdrant -->|Abruf| Chat[User Chat]
classDef default fill:#FFFFFF,stroke:#DEE2E6,stroke-width:1px,color:#343A40,rx:12,ry:12;
classDef highlight fill:#E7F1FD,stroke:#2A7FE1,stroke-width:2px,color:#1A2C3E,rx:12,ry:12;
class Paperless,Cortex,Qdrant highlight;
Szenario: Paperless-ngx ist nicht Bestandteil von cortex-jon.sh; Anbindung wäre optional über API/Webhook zu Open WebUI/Docling. Docling + Qdrant entsprechen dem installierten Stack.
Ebenen: 6
Wie verbindet man eine lokale KI mit Home Assistant, IoT-Sensoren oder Datenbanken, ohne im Schnittstellen-Chaos zu versinken? Die Antwort ist das Model Context Protocol (MCP).
Textalternative: Cortex Prime verbindet sich per MCP mit einem zentralen MCP-Hub; der Hub ist mit Home Assistant, PostgreSQL und IoT-Sensoren gekoppelt.
%%{init: {'flowchart': {'curve': 'basis', 'diagramPadding': 10, 'nodeSpacing': 24, 'rankSpacing': 32, 'htmlLabels': true}}}%%
flowchart TD
Cortex[Cortex Prime] <-->|Model Context Protocol| MCP((MCP Hub))
MCP <--> HA[Home Assistant]
MCP <--> DB[(PostgreSQL)]
MCP <--> IoT[IoT Sensoren]
classDef default fill:#FFFFFF,stroke:#DEE2E6,stroke-width:1px,color:#343A40,rx:12,ry:12;
classDef highlight fill:#E7F1FD,stroke:#2A7FE1,stroke-width:2px,color:#1A2C3E,rx:12,ry:12;
classDef hub fill:#E9ECEF,stroke:#6C757D,stroke-width:1px,color:#343A40,rx:12,ry:12;
class Cortex highlight;
class MCP hub;
Ein Protokoll für viele Backends – ohne Einzel-Schnittstellen-Spaghetti.
Ebenen: 8
Standard-Editoren senden massig Nutzungsdaten ab. VSCodium ist der identische Open-Source-Kern von VS Code, jedoch zu 100 % von Telemetrie und Tracking befreit. Das perfekte Frontend für absolute Datenhoheit.
Textalternative: VSCodium mit Extensions nutzt die Ollama-API auf Cortex Prime.
%%{init: {'flowchart': {'curve': 'basis', 'diagramPadding': 16, 'nodeSpacing': 40, 'rankSpacing': 44, 'htmlLabels': true}}}%%
flowchart LR
Dev[Entwickler] -->|App| IDE[VSCodium]
IDE --> Ext[Continue / Cline]
Ext --> Oll[Ollama Host]
Oll -->|Antwort| IDE
classDef default fill:#FFFFFF,stroke:#DEE2E6,stroke-width:1px,color:#343A40,rx:12,ry:12;
classDef highlight fill:#E7F1FD,stroke:#2A7FE1,stroke-width:2px,color:#1A2C3E,rx:12,ry:12;
class IDE,Oll highlight;
Extensions und Agenten sprechen die Host-Ollama-API (:11434). Browser-Web-IDE bei Bedarf selbst hosten.
Ebenen: 3, 6
DeepWiki hilft dir, Repositories schneller zu verstehen. Statt Doku manuell zu pflegen, wird der aktuelle Stand aus dem Code in eine gut nutzbare Wissensbasis überführt.
Textalternative: Gitea liefert Code an DeepWiki; DeepWiki erstellt daraus Docs und Diagramme, die über MCP in Cortex Prime genutzt werden.
%%{init: {'flowchart': {'curve': 'basis', 'diagramPadding': 16, 'nodeSpacing': 50, 'rankSpacing': 60, 'htmlLabels': true}}}%%
flowchart LR
Gitea[(Gitea Git-Server)] -->|Repository Sync| DW[DeepWiki Engine]
subgraph AUTODOC[Auto-Dokumentation]
DW -->|Parsing| MD[Markdown Docs]
DW -->|Visualisierung| Mer[Mermaid Diagramme]
end
MD --> MCP((MCP Server))
Mer --> MCP
MCP <--> Cortex[Cortex Prime]
DW -. Code-Kontext .-> Ollama[Ollama API]
classDef default fill:#FFFFFF,stroke:#DEE2E6,stroke-width:1px,color:#343A40,rx:8,ry:8;
classDef highlight fill:#E7F1FD,stroke:#2A7FE1,stroke-width:2px,color:#1A2C3E,rx:8,ry:8;
classDef cortex fill:#E7F1FD,stroke:#2A7FE1,stroke-width:2px,color:#1A2C3E,rx:8,ry:8;
classDef db fill:#F8FAFC,stroke:#CBD5E1,stroke-width:1px,color:#475569,rx:8,ry:8;
class DW highlight;
class Cortex cortex;
class Gitea db;
Von Gitea über DeepWiki bis zur Nutzung in Cortex Prime.
Ebenen: 4, 5, 6
Ab hier bleibt es nicht bei Chat-Antworten. Die KI nutzt Werkzeuge, bereitet Ergebnisse visuell auf und kann über MCP kontrolliert mit externen Systemen arbeiten.
Textalternative: Externe Systeme sprechen über den MCP-Hub mit Cortex Prime; Skills und Artifacts erweitern den Workflow.
%%{init: {'flowchart': {'curve': 'basis', 'diagramPadding': 16, 'nodeSpacing': 50, 'rankSpacing': 60, 'htmlLabels': true}}}%%
flowchart LR
subgraph EXTERN[Externe Systeme]
Gitea[(Gitea Issues)]
DB[(PostgreSQL)]
HA[Home Assistant]
end
subgraph CORE[Cortex Prime Core]
MCP((MCP Hub))
Tools[Python Skills]
Artifacts[HTML/React Render]
end
Gitea <-->|REST/API| MCP
DB <-->|Query| MCP
HA <-->|Sensoren/Aktoren| MCP
MCP <--> Cortex[Open WebUI / Ollama]
Tools -.-> Cortex
Cortex -.-> Artifacts
classDef default fill:#FFFFFF,stroke:#DEE2E6,stroke-width:1px,color:#343A40,rx:8,ry:8;
classDef highlight fill:#E7F1FD,stroke:#2A7FE1,stroke-width:2px,color:#1A2C3E,rx:8,ry:8;
classDef cortex fill:#E7F1FD,stroke:#2A7FE1,stroke-width:2px,color:#1A2C3E,rx:8,ry:8;
classDef db fill:#F8FAFC,stroke:#CBD5E1,stroke-width:1px,color:#475569,rx:8,ry:8;
class MCP highlight;
class Cortex cortex;
class Gitea,DB,HA db;
Von externen Systemen über den MCP-Hub zur aktiven Nutzung in Cortex Prime.