LLMGui — Model Context Protocol (MCP)

LLMGui implementiert das Model Context Protocol (MCP) in beide Richtungen: als Server (exponiert seine eigenen Tools nach außen) und als Client (konsumiert externe MCP-Server). Damit ist LLMGui vollständig in MCP-Ökosysteme wie Claude Desktop integrierbar.

Navigation

Was ist MCP?

Das Model Context Protocol ist ein offenes Standardprotokoll von Anthropic, das LLMs den strukturierten Zugriff auf externe Tools und Ressourcen ermöglicht. Ein MCP-Server exponiert Tools über eine JSON-RPC-Schnittstelle (stdio oder HTTP), ein MCP-Client ruft diese Tools auf.

LLMGui spielt beide Rollen:

Claude Desktop / MCP-Client
        ↕ (MCP stdio)
  LLMGui MCP-Server
  (brainy/mcp/server.py)
        ↕ (intern)
  LLMGui Tools & Commands

  LLMGui REPL / Server
  (MCP-Client-Modus)
        ↕ (MCP stdio/HTTP)
  Externe MCP-Server
  (z.B. filesystem, git, custom)

LLMGui als MCP-Server

Starten

# Via Python-Modul
python3 -m brainy.mcp.server

# Via .pyz-Bundle
./dist/llmgui.pyz mcp

# Via Wrapper-Script
./llmgui.sh mcp

Der MCP-Server läuft über stdio (JSON-RPC). Er ist direkt in Claude Desktop oder jedem anderen MCP-Client verwendbar.

stdout-Isolation

Das MCP-Protokoll nutzt stdout für JSON-RPC-Nachrichten. LLMGui stellt sicher, dass alle Rich-Console-Ausgaben auf stderr umgeleitet werden, sobald MCP_SERVER=true gesetzt ist. Der OutputManager.console ist dafür als lazy @property implementiert — er prüft bei jedem Zugriff das Environment und erstellt die Console ggf. neu. Dies ermöglicht korrekte Umleitung auch dann, wenn das Singleton-Objekt bereits vor dem MCP_SERVER-Setzen durch den Import-Mechanismus erzeugt wurde.

Exponierte Tools

Der MCP-Server exponiert alle registrierten LLMGui-Tools sowie ausgewählte Slash Commands als MCP-Tools:

Filesystem-Tools:

MCP-Tool Beschreibung
read_file Datei lesen (mit Workspace-relativer Pfadauflösung)
write_file Datei schreiben
list_directory Verzeichnis auflisten
search_files Dateien nach Glob/Regex suchen
grep_files Dateiinhalt durchsuchen
move_file Datei verschieben
delete_file Datei löschen

Git-Tools:

MCP-Tool Beschreibung
git_status Git-Status abrufen
git_diff Git-Diff abrufen
git_log Git-Log abrufen
git_commit Commit erstellen

Analyse-Tools:

MCP-Tool Beschreibung
execute_command Shell-Befehl ausführen
web_fetch URL abrufen
web_search Web-Suche
project_memory Projektgedächtnis lesen/schreiben

Slash Commands als MCP-Tools:

Ausgewählte Slash Commands werden zusätzlich als MCP-Tools exponiert (z.B. /review, /analyze, /security). Sie verwenden intern MockApp — einen leichtgewichtigen App-Kontext ohne interaktive Session.

Integration in Claude Desktop

~/.config/claude/claude_desktop_config.json:

{
  "mcpServers": {
    "llmgui": {
      "command": "/path/to/llmgui.pyz",
      "args": ["mcp"],
      "env": {
        "LLMGUI_WORKSPACE": "/path/to/your/project"
      }
    }
  }
}

Oder mit Python:

{
  "mcpServers": {
    "llmgui": {
      "command": "python3",
      "args": ["-m", "brainy.mcp.server"],
      "cwd": "/path/to/llmgui",
      "env": {
        "PYTHONPATH": "/path/to/llmgui"
      }
    }
  }
}

LLMGui als MCP-Client

LLMGui kann selbst externe MCP-Server konsumieren. Konfiguriert in ~/.llmgui/slash_commands.yaml:

mcp_servers:
  - name: filesystem
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/workspace"]

  - name: git
    command: uvx
    args: ["mcp-server-git", "--repository", "/path/to/repo"]

  - name: custom-server
    command: python3
    args: ["-m", "my_custom_mcp_server"]
    env:
      SOME_VAR: value

Wie funktioniert der MCP-Client?

  1. Beim Start verbindet sich LLMGui mit allen konfigurierten MCP-Servern via stdio
  2. Die Tools der externen Server werden automatisch in die Tool-Registry integriert
  3. Im autonomen Modus kann das LLM sowohl native LLMGui-Tools als auch externe MCP-Tools aufrufen
  4. Tool-Ergebnisse werden bei Bedarf auf MAX_TOOL_OUTPUT_CHARS = 8000 Zeichen gekürzt

MockApp für Command-Ausführung

Wenn Slash Commands ohne interaktive Session ausgeführt werden (z.B. im MCP-Server oder API-Server), verwendet LLMGui MockApp (brainy/core/mock_app.py):

# Bereitgestellte API
class MockApp:
    def chat_message(msg)          # Ausgabe (rendert Rich-Objekte)
    def log_activity(msg)          # Logging
    def get_output()               # Gesammelte Ausgabe zurückgeben
    def get_combined_output()      # Kombiniete Ausgabe (Messages + Logs)
    def query_llm(prompt, json_format=False)  # LLM-Aufruf

Architektur

brainy/mcp/
├── server.py    # MCP-Server-Implementierung (stdio JSON-RPC)
│               # Exponiert Tools + Commands als MCP-Tools
│               # stdout → stderr Umleitung via OutputManager
└── client.py   # MCP-Client (verbindet sich mit externen MCP-Servern)
                # Integriert externe Tools in LLMGui Tool-Registry

Tool-Schema (Beispiel)

Der MCP-Server beschreibt jedes Tool im JSON-Schema-Format:

{
  "name": "read_file",
  "description": "Read the contents of a file",
  "inputSchema": {
    "type": "object",
    "properties": {
      "path": {
        "type": "string",
        "description": "Absolute or workspace-relative file path"
      }
    },
    "required": ["path"]
  }
}

Sicherheitshinweise