OrbitMCP

Edge-natives Model Context Protocol (MCP) Control Plane & autonomer Tool-Dispatcher

Ein leichtgewichtiges, luftgekapseltes Desktop-Cockpit, das lokale LLMs (Llama 3.2) mit standardisierten MCP-Tools und deterministischer Hardwaresicherheit verbindet.

Das Kernproblem

Standard-Large-Language-Modelle – sowohl proprietäre Cloud-APIs als auch lokale Gewichte – sind isolierte Textprädiktoren. Sie sind grundsätzlich blind für die physische Maschine, auf der sie ausgeführt werden:

1. Kein natives Hardware-Bewusstsein: Ein LLM kann ohne externen Klebecode nicht eigenständig den verbleibenden VRAM prüfen, Projekt-Repositories inspizieren, Shell-Routinen ausführen oder SQLite-Datenbanken lesen.

2. Cloud-Privacy- und Egress-Risiko: Die Übertragung proprietärer Codebasen, interner Dokumente und Host-Telemetrie über Cloud-APIs verursacht wiederkehrende Token-Kosten und Compliance-Schwachstellen bei der Datenverarbeitung.

3. Electron-Aufblähung: Bestehende Agent-GUIs setzen häufig auf Electron und verbrauchen 800 MB–1,5 GB RAM, bevor ein Inferenzmodell überhaupt in den Speicher geladen wird.

Related MCP server: ControlMCP

Was OrbitMCP löst

OrbitMCP verwandelt Ihre lokale Workstation in eine latenzfreie, airgekoppelte Agent-Umgebung.

Mit einer nativen Rust (Tauri v2)-Shell und einem Python-FastMCP-Sidecar arbeitet OrbitMCP mit einem RAM-Overhead von unter 100 MB und reserviert Ihre Systemressourcen vollständig für Modellgewichte und schnelle lokale Inferenz.

┌────────────────────────────────────────────────────────────────────────┐
│                        User Prompt / Directive                         │
└───────────────────────────────────┬────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────────────────────┐
│               Local Quantized LLM (Ollama / Llama-3.2)                 │
│  - Analyzes intent & generates standard JSON tool execution schema     │
└───────────────────────────────────┬────────────────────────────────────┘
│ (MCP Tool Call)
▼
┌────────────────────────────────────────────────────────────────────────┐
│               OrbitMCP FastMCP Gateway (Local :8765)                   │
│  - Validates sandbox path boundaries & executes kernel functions       │
└───────────────────┬────────────────────────────────┬───────────────────┘
│                                │
▼                                ▼
┌─────────────────────────┐      ┌─────────────────────────┐
│   system_telemetry()    │      │      list_files()       │
│  (RAM / CPU / Headroom) │      │  (Safe Workspace Tree)  │
└────────────┬────────────┘      └────────────┬────────────┘
│                                │
└────────────────┬───────────────┘
│
▼
┌────────────────────────────────────────────────────────────────────────┐
│           React 18 Control Plane (Geist UI + Claude Thinking)          │
│  - Real-time hardware stream, collapsible trace & typewriter output    │
└────────────────────────────────────────────────────────────────────────┘

Hauptfunktionen

1. Autonomer MCP-Tool-Ausführungszyklus

OrbitMCP übersetzt Benutzeranfragen in OpenAI-kompatible Tool-Spezifikationen für lokale Ollama-Modelle. Wenn eine Anfrage OS-Kontext erfordert, unterbricht das Modell die Standardgenerierung, sendet strukturierte Tool-Argumente an das FastMCP-Gateway, führt das Python-Skript lokal aus und fasst die endgültige Payload zusammen.

2. Live-Kernel-Telemetrie-Abfrage

Direkte Hardware-Abfrage über psutil überwacht alle 3 Sekunden die CPU-Kernauslastung, den residenten RAM-Verbrauch und den verfügbaren Speicher-Headroom, um Out-of-Memory (OOM)-Sperren bei intensiver Inferenz zu verhindern.

3. Claude-artiger Denkprozess-Block

Enthält eine oszillierende 4-Balken-Wellenform-Animation und einen Live-Elapsed-Timer (Thought for 11.4s). Denkblöcke können in ein internes Monolog-Notizbuch eingeklappt werden, das die Schema-Auflösung und Sicherheitsgrenzen-Prüfungen detailliert.

4. Vier kuratierte Entwickler-Designs

Enthält vier kontrastreiche Entwickler-Farbpaletten, die zur Laufzeit mit sofortigem Token-Rendering umschaltbar sind:

• Obsidian Amber (Dunkle Holzkohle + Warmes Bernstein)

• Tokyo Violet (Cyber-Synth-Indigo + Lila)

• Matrix Emerald (Terminal-Grün + Jet-Schwarz)

• Linear Cobalt (Deep-Space-Schiefer + Himmelblau)

5. Dynamische Modell-Erkennung & Parameter-Tuning

• Modell-Dropdown: Fragt beim Start automatisch den lokalen Ollama-Daemon ab (/api/tags), um installierte Gewichte zu füllen (llama3.2:3b, qwen2.5-coder, mistral usw.).

• Sampling-Temperatur: Integrierter Schieberegler (0.0 bis 1.0) zur dynamischen Anpassung der Generierungsdeterminismus.

• Tool-Gating: Unabhängige Schalter auf jeder Tool-Karte, um bestimmte MCP-Funktionen dynamisch aus dem Schema des Modells zu aktivieren oder zu deaktivieren.

Tech-Stack

Projektstruktur

orbit-mcp/
├── backend/                  # FastMCP Python engine
│   ├── tools/
│   │   ├── telemetry.py      # Kernel hardware metrics polling
│   │   └── fs.py             # Sandboxed workspace filesystem inspector
│   ├── server.py             # FastAPI gateway & Ollama tool loop dispatcher
│   └── requirements.txt      # Python dependencies
├── src/                      # React frontend source
│   ├── App.tsx               # Main OrbitMCP Control Plane component
│   ├── main.tsx              # React DOM entry point
│   ├── index.css             # Tailwind base styles & Claude wave keyframes
│   └── vite-env.d.ts         # Vite client TypeScript definitions
├── src-tauri/                # Native Rust desktop application
│   ├── capabilities/         # Tauri v2 security policies
│   ├── icons/                # Multi-platform application icon sets
│   ├── src/main.rs           # Rust application entry point
│   ├── Cargo.toml            # Rust dependencies & metadata
│   └── tauri.conf.json       # Window geometry, title, and build targets
├── orbitmcp-cover.png        # Repository hero cover banner
├── orbit-icon.png            # Master 1024x1024 application icon
├── package.json              # Node dependencies and scripts
├── tailwind.config.js        # Color tokens & typography configuration
└── tsconfig.json             # TypeScript compiler rules (TS5 bundler mode)

Erste Schritte

Voraussetzungen

Stellen Sie sicher, dass die folgenden Laufzeiten auf Ihrem Host-System installiert sind:

• Node.js (v18.0 oder später)

• Python (v3.10 bis v3.12)

• Rust & Cargo (für die Tauri-Desktop-Kompilierung)

• Ollama (mit llama3.2:3b gezogen)

Installation & Einrichtung

1. Repository klonen

git clone [https://github.com/Velocity07/OrbitMCP.git](https://github.com/Velocity07/OrbitMCP.git)
cd OrbitMCP

2. Python-FastMCP-Backend konfigurieren

Erstellen und aktivieren Sie eine virtuelle Umgebung und installieren Sie dann die Abhängigkeiten:

# Windows PowerShell
python -m venv .venv
.\.venv\Scripts\Activate.ps1

# Install backend requirements
pip install -r backend/requirements.txt

3. Frontend-Abhängigkeiten installieren

npm install

4. Lokales Inferenzmodell ziehen

Stellen Sie sicher, dass Ollama läuft, und ziehen Sie dann das Standard-Leichtgewicht-Tool-Calling-Modell:

ollama pull llama3.2:3b

OrbitMCP ausführen

Schritt A: FastMCP-Backend-Server starten

In Ihrem ersten Terminal (mit aktiviertem .venv):

python backend/server.py

Das Gateway wird auf http://127.0.0.1:8765 initialisiert.

Schritt B: Natives Desktop-Fenster starten

In Ihrem zweiten Terminal:

npx tauri dev

OrbitMCP kompiliert das native Rust-Binary, startet das Desktop-Fenster und stellt automatisch eine Live-IPC-Brücke zum FastMCP-Backend her.

Benutzerdefinierte FastMCP-Tools schreiben

OrbitMCP ist so konzipiert, dass es leicht erweiterbar ist. Um ein neues Tool im Agent-Zyklus zu registrieren:

1. Definieren Sie Ihre Tool-Funktion in backend/tools/ mit FastMCP:

# backend/tools/network.py
import socket
from typing import Dict, Any

def test_port(host: str, port: int) -> Dict[str, Any]:
    """Check if a specific host and port is accepting connections."""
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.settimeout(2.0)
    try:
        s.connect((host, port))
        s.close()
        return {"host": host, "port": port, "open": True}
    except Exception as e:
        return {"host": host, "port": port, "open": False, "error": str(e)}

2. Registrieren Sie den Tool-Dekorator und das Schema in backend/server.py:

from tools.network import test_port

@mcp.tool()
def check_port(host: str, port: int) -> Dict[str, Any]:
    """Test connection status for a remote host and port."""
    return test_port(host, port)

3. Starten Sie server.py neu. Das Tool wird sofort im Registrierte Tools-Panel angezeigt und ist für die autonome Ausführung verfügbar.

Roadmap

• FastMCP-Python-Gateway-Integration

• Echtzeit-Host-Hardware-Telemetrie-Polling (CPU / RAM)

• Llama 3.2 autonomer Tool-Ausführungszyklus

• Claude-artiges Denk-Akkordeon und Elapsed-Timer

• Multi-Theme-Laufzeit-Switcher (Obsidian, Tokyo, Emerald, Cobalt)

• Native Tauri v2 Windows-Shell-Integration

• Server-Sent Events (SSE) Token-für-Token-Streaming

• Automatisierte PyInstaller-Sidecar-Binary-Paketierung

• Multi-Turn-Konversationsspeicher-Notizbuch

Lizenz

Verteilt unter der MIT-Lizenz. Weitere Informationen finden Sie in LICENSE.