OrbitMCP

Plano de control nativo de borde del Model Context Protocol (MCP) y despachador autónomo de herramientas

Una cabina de escritorio ligera y aislada de la red (air-gapped) que conecta modelos de lenguaje locales (Llama 3.2) con herramientas MCP estándar con una seguridad de hardware determinista.

El problema central

Los modelos de lenguaje grandes convencionales —tanto las APIs de nube propietarias como los pesos locales— son predictores de texto aislados. Carecen por completo de visión sobre la máquina física en la que se ejecutan:

1. Sin conocimiento nativo del hardware: Un LLM no puede comprobar de forma independiente la VRAM restante, inspeccionar repositorios de proyectos, ejecutar rutinas de shell ni leer bases de datos SQLite sin código externo de conexión.

2. Privacidad en la nube y riesgo de salida de datos: Transmitir la estructura de los repositorios propietarios, los documentos internos y la telemetría del sistema host a través de APIs en la nube añade costes recurrentes de tokens y vulnerabilidades de cumplimiento normativo de datos.

3. Inflado de Electron: Las interfaces de agente existentes recurren con frecuencia a Electron, que consume entre 800MB y 1.5GB de RAM antes de que tan siquiera se cargue un modelo de inferencia en la memoria.

Related MCP server: ControlMCP

Lo que resuelve OrbitMCP

OrbitMCP convierte tu estación de trabajo local en un entorno de agentes aislado de la red y con cero latencia (air-gapped).

Construido con un caparazón nativo en Rust (Tauri v2) y un Supor FastMCP Python, OrbitMCP funciona con un consumo adicional de menos de 100MB de RAM, reservando todos los recursos del sistema para los pesos de los modelos y la rápida inferencia local.

┌────────────────────────────────────────────────────────────────────────┐
│                        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    │
└────────────────────────────────────────────────────────────────────────┘

Funciones principales

1. Bucle autónomo de ejecución de herramientas MCP

OrbitMCP traduce las consultas del usuario en especificaciones de herramientas compatibles con OpenAI para modelos locales de Ollama. Cuando una consulta requiere contexto del sistema operativo, el modelo interrumpe la generación normal, envía argumentos estructurados de herramientas a la pasarela FastMCP, ejecuta el script de Python localmente y resume la carga de datos final.

2. Sondeo de telemetría del kernel en tiempo real

El sondeo directo del hardware a través de psutil supervisa la utilización de los núcleos de la CPU, el uso de memoria RAM y el margen de memoria disponible cada 3 segundo para evitar fallos de memoria (OOM) durante una sinverencia intensa.

3. Bloque de proceso de pensamiento estilo Claude

Incluye una animación oscilante de 4 barras y un temporizador en vivo (Thought for 11.4s). Los bloques de pensamiento se pueden plegar para convertirse en un block de notas interno que detalla un monólogo con la resolución del esquema y las verificaciones de límites de seguridad en los límites de seguridad.

4. Cuatro temas de desarrollador curados

Incluye cuatro paletas de colores de alto contraste para desarrolladores, conmutables en caliente y con re-renderizado instantáneo de tokens:

• Obsidian Amber (Carbón oscuro + ámbar cálido)

• Tokyo Violet (Indigo synthwave ciber +púrpura)

• Matrix Emerald (Verde terminal + negro azabache)

• Cobalt Cobalto (Pizarra del espacio profundo + azul cielo)

5. Descubrimiento dinámico de modelos y ajuste de parámetros

• Selector de modelos: Consulta automáticamente al daemon local de Ollama al inicio (/api/tags) para cargar los pesos instalados (llama3.2:3b, qwen2.5-coder, mistral, etc.).

• Temperatura de muestreo: Deslizador integrado (0.0 a 1.0) para ajustar dinámicamente el determinismo de la generación.

• Segmentación de herramientas: Interruptores independientes en cada tarjeta de herramienta para habilitar o deshabilitar esas funciones MCP en el esquema del modelo de forma dinámica.

Pila tecnológica

Estructura del proyecto

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)

Primeros pasos

Requisitos previos

Asegúrate de tener los siguientes entornos de ejecución instalados en tu sistema:

• Node.js (v18.0 o superior)

• Python (v3.10 a v3.12)

• Rust y Cargo (para compilar el escritorio Tauri)

• Ollama (con llama3.2:3b descargado)

Instalación y configuración

1. Clona el repositorio

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

2. Configura el backend de FastMCP de Python

Crea y activa un entorno virtual y, a continuación, instala las dependencias:

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

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

3. Instala las dependencias del frontend

npm install

4. Descarga el modelo de inferencia local

Asegúrate de que Ollama esté en funcionamiento y, a continuación, descarga el modelo de llamada a herramientas ligero por defecto:

ollama pull llama3.2:3b

Cómo ejecutar OrbitMCP

Paso A: Inicia el servidor backend FastMCP

En tu primera terminal (con .venv activado):

python backend/server.py

La pasarela se inicializará en http://127.0.0.1:8765.

Paso B: Lanza la ventana de escritorio nativa

En tu segunda terminal:

npx tauri dev

OrbitMCP compilará el binario nativo de Rust, abrirá la ventana de escritorio y establecerá automáticamente un puente IPC en vivo con el backend FastMCP.

Cómo escribir herramientas FastMCP personalizadas

OrbitMCP está diseñado para ampliarse fácilmente. Para registrar una nueva herramienta en el bucle del agente:

1. Define la función de tu herramienta en backend/tools/ utilizando 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. Registra el decorador y el esquema de la herramienta en 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. Reinicia server.py. La herramienta aparecerá automáticamente en el panel Herramientas registradas y estará disponible para su invocación autónoma.

Hoja de ruta

• Integración de la pasarela FastMCP en Python

• Sondeo de telemetría del hardware host en tiempo real (CPU / RAM)

• Bucle autónomo de ejecución de herramientas de Llama 3.2

• Acordeón de pensamiento estilo Claude y temporizador de tiempo transcurrido

• Selector de múltiples temas en tiempo de ejecución (Obsidian, Tokyo, Emerald, Cobalt)

• Integración nativa con el shell de Windows de Tauri v2

• Streaming de tokens con Server-Sent Events (SSE)

• Empaquetado automático del binario secundario con PyInstaller

• Memoria de conversación con varios turnos

Licencia

Distribuido bajo la Licencia MIT. Consulta LICENSE para obtener más información.