LLMGui — Autonomer KI-Coding-Assistent

Version: 2.x
Lizenz: privat / intern
Plattform: Linux (primär), macOS kompatibel
Sprache: Python 3.10+

LLMGui (brainy) ist ein privacy-first, terminal- und serverbasiertes Framework für lokale KI-Modelle. Es läuft vollständig lokal auf Basis von Ollama, unterstützt aber auch optionale Cloud-Fallbacks (Gemini). Der Fokus liegt auf realen Coding-Workflows: Code Review, Sicherheitsanalyse, Refactoring, Testgenerierung und autonome Multi-Tool-Agenten.

Dokumentations-Navigation

Bereich	Beschreibung
VS Code Extension	Native VS Code Integration — Chat, CodeLens, Context Menu
MCP Server & Client	Model Context Protocol — LLMGui als MCP-Server und -Client
Control Center	GTK-Desktop-App mit Benchmark, Modellverwaltung und Live-Chat
Recent Changes	Changelog — alle aktuellen Änderungen und neuen Features

Kernfeatures

130+ Slash Commands

Alle Slash Commands sind über /command_name args im REPL oder via API aufrufbar:

Code-Qualität

Command	Beschreibung
`/review <datei>`	Vollständige Code-Review mit Sicherheitsfocus
`/analyze <datei>`	Statische Analyse und Architektur-Bewertung
`/refactor <datei>`	KI-gestütztes Refactoring
`/autofix <datei>`	Automatische Fehlerbehebung
`/harden <datei>`	Security-Hardening-Vorschläge
`/lint <datei>`	Linting (flake8/ruff)
`/typecheck <datei>`	Typprüfung (mypy)
`/complexity <datei>`	Komplexitätsanalyse (radon)
`/deadcode <datei>`	Tote-Code-Erkennung
`/full-audit [pfad]`	Alle Checks in einem Durchlauf — Lint · Typecheck · Security · Complexity · Dead Code · Vuln-Scan · Secret-Scan

Sicherheit

Command	Beschreibung
`/security <datei>`	Pattern-basierter Security-Scan (bandit)
`/vuln-scan <pfad>`	Vulnerability-Scan (pip-audit / safety / semgrep)
`/secret-scan <pfad>`	Secrets & API-Key-Erkennung
`/sec-audit <pfad>`	Vollständiges Security-Audit
`/sec-fix <id>`	KI-gestützte Behebung eines DB-Findings per ID
`/sec-verify <id>`	Exploit-Verifikation für einen Fix
`/sec-monitor [pfad]`	Real-Time File Integrity Monitoring (FIM)
`/threat-model [pfad]`	STRIDE-Threat-Model generieren
`/pentest [pfad]`	Adversarial Taint-Path-Analyse

Git & Dokumentation

Command	Beschreibung
`/diff`	Aktuellen Git-Diff analysieren
`/commitmsg`	Commit-Message generieren
`/blame <datei>`	Git-Blame mit KI-Kommentar
`/changelog`	Changelog aus Git-History generieren
`/doc <datei>`	Dokumentation generieren
`/arch-doc`	Architektur-Dokumentation

Code-Navigation

Command	Beschreibung
`/explain <datei>`	Code erklären
`/search <query>`	Semantische Code-Suche
`/callers <funktion>`	Aufrufer einer Funktion finden
`/callees <funktion>`	Aufgerufene Funktionen anzeigen
`/diagram <datei>`	Klassendiagramm generieren

Tests & Qualität

Command	Beschreibung
`/testgen <datei>`	Unit-Tests generieren
`/testgaps <datei>`	Fehlende Test-Coverage ermitteln
`/deps <datei>`	Abhängigkeiten analysieren
`/health`	Projekt-Health-Check

22+ Autonomous Tools

Im autonomen Modus (/agent) ruft das LLM selbständig Tools auf und iteriert bis zur Lösung. Sensible Tools (Datei schreiben, Befehle ausführen) erfordern Benutzerbestätigung.

Tool	Beschreibung
`read_file`	Datei lesen
`write_file`	Datei schreiben (mit Bestätigung)
`delete_file`	Datei löschen (mit Bestätigung)
`move_file`	Datei verschieben (mit Bestätigung)
`list_directory`	Verzeichnis auflisten
`execute_command`	Shell-Befehl ausführen (mit Bestätigung)
`search_files`	Dateien durchsuchen (Glob/Regex)
`grep_files`	Inhalt durchsuchen
`git_status`	Git-Status abfragen
`git_diff`	Git-Diff abrufen
`git_log`	Git-Log abrufen
`git_commit`	Commit erstellen
`web_fetch`	URL abrufen
`web_search`	Web-Suche
`project_memory`	Projektgedächtnis lesen/schreiben
`submit_patch`	Patch einreichen (mit Bestätigung)
`debug_*`	DAP-Integration: Breakpoints, Stack Traces

Architektur

brainy/
├── core/         # Config (Pydantic BaseSettings), Konstanten, MockApp
├── llm/          # LLM-Client, Autonomous-Handler, Swarm-Koordinator
├── commands/     # 130+ Slash-Command-Implementierungen + Registry
├── tools/        # 22+ Tool-Implementierungen + Registry + Executor
├── mcp/          # MCP-Server (Tools extern verfügbar) + MCP-Client
├── utils/        # OutputManager, Logger, Memory, History
└── ui/           # Mission Control TUI (Textual)

Weitere Top-Level-Module: analyzers, codegen, context, dap, debugging, docs, git, integrations, lsp, models, navigation, quality, rag, runtime, search, skills, testing, xlang.

LLM-Client (`brainy/llm/client.py`)

query_llm() — Einzelner Aufruf mit automatischem Retry und Fallback auf konfigurierte Fallback-Modelle
query_llm_with_tools() — Agentischer Loop: Iteriert Tool-Calls bis keine mehr angefordert werden oder MAX_TOOL_ITERATIONS erreicht ist
Unterstützt Ollama (/api/chat, /api/generate) und OpenAI-kompatible APIs (auto-detected)
StreamingFilter bereinigt JSON-Wrapper-Artefakte aus gestreamten Antworten
_prune_tool_history() kürzt Konversationshistorie bei Annäherung an den Context Window

Konfiguration

Alle Einstellungen in ~/.llmgui/slash_commands.yaml:

models:
  - name: qwen2.5-coder:14b
    apiBase: http://localhost:11434
    num_ctx: 12288
    num_gpu: 100
    system_prompt: "Du bist ein erfahrener Python-Entwickler..."
fallback_model: gemini-pro          # oder Liste von Modellnamen
embedding_model: nomic-embed-text
mcp_servers:
  - name: my-server
    command: python3
    args: ["-m", "my_server"]

Deployment-Modi

1. Interaktives REPL

python3 llmgui.py
# oder via installiertem CLI
llmgui

Standard-Modus für direkte Nutzung im Terminal. Slash Commands, autonome Agenten und alle Tools sind verfügbar.

2. FastAPI-Server (Port 8080)

# Entwicklungsmodus (Auto-Reload)
PYTHONPATH=. LLMGUI_DEV=1 python3 llmgui.py --serve

# Produktion via .pyz-Bundle
./llmgui.sh --serve

# Mit Rebuild
./llmgui.sh --build --serve

Der Server stellt eine REST-API bereit, die von der VS Code Extension und anderen Clients genutzt wird. Wichtige Endpunkte:

Endpunkt	Methode	Beschreibung
`/chat`	POST	Slash Command oder Freitext senden
`/status`	GET	Server-Status
`/ollama/status`	GET	Ollama-Status (Modelle, VRAM)
`/models`	GET	Verfügbare Modelle
`/health`	GET	Health-Check

3. MCP-Server (stdio)

python3 -m brainy.mcp.server
# oder
./dist/llmgui.pyz mcp

Exponiert alle LLMGui-Tools als MCP-Tools für Claude Desktop und andere MCP-Clients. Vollständige Details: MCP-Dokumentation.

Schnellstart

Voraussetzungen

# Ollama installieren und Modell laden
curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen2.5-coder:14b

# Python-Abhängigkeiten
pip install -r requirements.txt

# Konfiguration anlegen
mkdir -p ~/.llmgui
cat > ~/.llmgui/slash_commands.yaml << 'EOF'
models:
  - name: qwen2.5-coder:14b
    apiBase: http://localhost:11434
    num_ctx: 12288
EOF

Produktiv-Deployment (empfohlen)

Das kanonische Deployment-Artefakt ist ein self-contained .pyz-Bundle (shiv). Alle Abhängigkeiten sind eingebettet — auf dem Zielsystem wird nur Python 3.10+ benötigt.

# Bundle bauen
./build_shiv.sh            # ~280 MB Output: dist/llmgui.pyz
./build_shiv.sh --no-cache # Sauberer Rebuild

# Server starten
./llmgui.sh --serve

Privacy & Lokale Modelle

LLMGui ist privacy-first designed:

Standardmäßig werden keine Daten an externe Server gesendet
Alle Verarbeitungen laufen über lokales Ollama
Local-Only-Modus: Deaktiviert alle Cloud-Fallbacks (konfigurierbar in VS Code Extension und YAML)
Code und Daten verlassen nie das eigene Netzwerk — außer bei explizit konfigurierten Remote-Modellen

Tests ausführen

# Vollständiger Test-Run
PYTHONPATH=/home/mrmarco/Documents/gitlab/llmgui .venv/bin/pytest tests/ -v

# Einzelne Test-Datei
PYTHONPATH=. .venv/bin/pytest tests/test_autonomous.py -v

# Linting
.venv/bin/python -m flake8 brainy/
.venv/bin/python -m ruff check brainy/
.venv/bin/python -m mypy brainy/