Nexus KI-Tools

Ein umfassendes Model Context Protocol Toolkit für KI-Assistenten

License: MIT Node Version TypeScript MCP

Verwandeln Sie jeden KI-Assistenten in einen autonomen Agenten, der reale Aufgaben ausführen kann.

Dokumentation • Erste Schritte • Roadmap • Architektur

🎯 Überblick

Nexus-MCP ist ein leistungsstarker Model Context Protocol (MCP) Server, der mit TypeScript/Node.js erstellt wurde und KI-Modellen universelle Werkzeuge bietet für:

📁 Dateisystemoperationen (18 Tools) - Dateien lesen, schreiben, suchen und überwachen
🌐 HTTP/Web-Anfragen (16 Tools) - Daten abrufen, Websites scrapen, APIs aufrufen
🔄 Git-Workflows (15 Tools) - Repositories klonen, committen, verzweigen und verwalten
Systembefehle (8 Tools) - Shell-Befehle ausführen und Prozesse verwalten
🔧 Dienstprogramme (8 Tools, codebereit) - JSON/YAML-Parsing, Komprimierung, Verschlüsselung und mehr

Aktueller Status: 49 Tools produktionsbereit, 8 Dienstprogramm-Tools implementiert (Konfigurationsintegration ausstehend)

🚀 Schnellstart

Installation

npm install -g nexus-ai-tools

Konfiguration

# Copy example environment file
cp .env.example .env

# Edit with your settings
nano .env

Ausführen

# Build the project
npm run build

# Run the MCP server (production)
npm start
# or
npm run start:mcp

# Run with CLI
npm run mcp

# Run in development mode
npm run dev

Integration mit Claude Code

Fügen Sie dies zu Ihrer Claude Desktop-Konfiguration hinzu:

{
  "mcpServers": {
    "nexus-mcp": {
      "command": "node",
      "args": ["/path/to/nexus-mcp/dist/index.js"]
    }
  }
}

Verwendung von Umgebungsvariablen-Substitution

Erstellen Sie eine .env-Datei:

NEXUS_LOG_LEVEL=debug
DB_PASSWORD=secret123
ANTHROPIC_API_KEY=sk-ant-...

Verwendung in config.yaml:

server:
  log_level: "${NEXUS_LOG_LEVEL:-info}"
database:
  postgresql:
    password: "${DB_PASSWORD}"
ai:
  anthropic:
    api_key: "${ANTHROPIC_API_KEY}"

Validieren Sie erforderliche Variablen vor dem Start:

import { validateEnvironment, loadConfig } from './config.js';

validateEnvironment(['ANTHROPIC_API_KEY', 'DB_PASSWORD']);
const config = loadConfig();

Verwendung des kontextuellen Loggers

import { ContextualLogger } from './logger.js';
import path from 'path';

const workDir = path.join(process.cwd(), 'logs');
const logger = ContextualLogger.create(workDir, 'workflow-001');

logger.info('workflow.started', { step: 1 });
logger.info('processing.data', { items: 100 });
logger.info('workflow.completed', { success: true });

logger.close();

Siehe Leitfaden zur Konfigurationsverbesserung für vollständige Details.

📦 Funktionen

Dateisystem-Tools

nexus_read_file - Dateien mit Encoding-Unterstützung lesen
nexus_write_file - Dateien schreiben/erstellen
nexus_list_directory - Verzeichnisinhalt auflisten
nexus_search_files - Dateien nach Muster suchen
nexus_search_content - Inhalt innerhalb von Dateien suchen
nexus_watch_directory - Verzeichnisänderungen überwachen

HTTP-Tools

nexus_http_get - HTTP GET-Anfragen
nexus_http_post - HTTP POST-Anfragen
nexus_fetch_url - Webinhalte abrufen und parsen
nexus_parse_html - HTML mit Cheerio parsen
nexus_call_api - Generische API-Aufrufe

Git-Tools

nexus_git_clone - Repositories klonen
nexus_git_commit - Commits erstellen
nexus_git_push - Auf Remote pushen
nexus_git_pr_create - Pull Requests erstellen
Integration mit GitHub, GitLab, Bitbucket

Datenbank-Tools

nexus_db_query - SQL-Abfragen ausführen
nexus_db_list_tables - Datenbanktabellen auflisten
nexus_db_describe_table - Tabellenschema beschreiben
Unterstützung für PostgreSQL, MySQL, SQLite, SQL Server, MongoDB

System-Tools

nexus_exec_command - Shell-Befehle ausführen
nexus_system_info - Systeminformationen abrufen
nexus_process_list - Laufende Prozesse auflisten
nexus_service_start/stop - Dienste verwalten

KI-Tools

nexus_llm_chat - Chat mit LLMs (Anthropic, OpenAI)
nexus_embedding_create - Text-Embeddings erstellen
nexus_text_summarize - Text zusammenfassen
nexus_code_generate - Code generieren

Dienstprogramm-Tools

nexus_json_parse/stringify - JSON-Manipulation
nexus_yaml_parse/stringify - YAML-Manipulation
nexus_zip_create/extract - ZIP-Komprimierung
nexus_encrypt/decrypt - Verschlüsselung/Entschlüsselung

🏗️ Architektur

┌─────────────────────────────────────────┐
│         Claude / LLM Client              │
└──────────────┬──────────────────────────┘
               │ MCP Protocol (stdio)
               ▼
┌─────────────────────────────────────────┐
│           Nexus-MCP Server               │
│  ┌───────────────────────────────────┐  │
│  │      MCP Server Core             │  │
│  └───────────────────────────────────┘  │
│         ┌───────┴───────┐                │
│         │               │                │
│    ┌────▼────┐    ┌────▼────┐           │
│    │ Filesys │    │   HTTP  │           │
│    └─────────┘    └─────────┘           │
│    ┌─────────┐    ┌─────────┐           │
│    │   Git   │    │ Database│           │
│    └─────────┘    └─────────┘           │
│    ┌─────────┐    ┌─────────┐           │
│    │  System │    │    AI   │           │
│    └─────────┘    └─────────┘           │
└─────────────────────────────────────────┘

Für eine detaillierte Architektur siehe docs/architecture.md

🏛️ Produktionsqualität

Nexus-MCP wurde mit dem Fokus auf architektonische Exzellenz entwickelt, konzipiert für den produktiven Einsatz und die Akzeptanz in der Community. Wir folgen strengen Prinzipien:

✅ Typsicherheit: TypeScript Strict Mode + Zod-Validierung
✅ Fehlerbehandlung: Strukturierte, umsetzbare Fehlermeldungen
✅ Leistung: Asynchrone Operationen, Caching, Streaming
✅ Sicherheit: Eingabevalidierung, Bereinigung, Audit-Logs
✅ Beobachtbarkeit: Strukturierte Protokollierung, Metriken, Tracing
✅ Testbarkeit: 80%+ Abdeckung, Dependency Injection
✅ Dokumentation: JSDoc, Beispiele, umfassende Anleitungen
✅ Entwicklererfahrung: Klare Fehler, IDE-Unterstützung, schnelles Feedback

Siehe Architektonische Prinzipien für vollständige Details.

⚙️ Konfigurations- & Logging-Verbesserungen

Nexus-MCP enthält erweiterte Konfigurations- und Logging-Funktionen, die von Produktionssystemen inspiriert sind:

Umgebungsvariablen-Substitution

Verwenden Sie die ${VAR_NAME}-Syntax in YAML-Dateien, um Umgebungsvariablen zu ersetzen:

server:
  log_level: "${NEXUS_LOG_LEVEL:-info}"  # Uses env var, defaults to "info"
database:
  postgresql:
    password: "${DB_PASSWORD}"  # Required - warns if not set

Vorteile:

Sensible Daten (API-Schlüssel, Passwörter) in Umgebungsvariablen halten
Unterschiedliche Konfigurationen für verschiedene Umgebungen verwenden
Spezifische Werte überschreiben, ohne YAML-Dateien zu bearbeiten

Kontextueller Logger

Workflow-spezifisches Logging mit separaten Log-Dateien pro Kontext:

import { ContextualLogger } from './logger.js';

const logger = ContextualLogger.create(workDir, 'migration-123');
logger.info('workflow.started', { step: 1 });
logger.info('extract.completed', { schemaPath: '/path/to/schema.json' });
logger.close();

Vorteile:

End-to-End-Workflows nachverfolgen (Migrationen, Aufgaben, Batch-Jobs)
Komplexe, mehrstufige Operationen debuggen
Logs nach Workflow/Korrelations-ID organisiert halten
Historische Analyse spezifischer Workflows

Dokumentation: Siehe Leitfaden zur Konfigurationsverbesserung für vollständige Details.

📚 Dokumentation

Erste Schritte - Schnellstart und grundlegende Verwendung
Architektur-Dokumentation - Systemarchitektur und Design
Architektonische Prinzipien - Designprinzipien und Best Practices
Konfigurationsverbesserungen - Umgebungsvariablen-Substitution & kontextuelles Logging
API-Referenz - Vollständige API-Dokumentation
Tools-Referenz - Detaillierte Tool-Dokumentation
Roadmap - Entwicklungs-Roadmap und Fortschritt

🛠️ Entwicklung

# Clone repository
git clone https://github.com/your-org/Nexus-MCP.git
cd Nexus-MCP

# Install dependencies
npm install

# Run in development mode
npm run dev

# Run tests
npm test

# Build for production
npm run build

# Lint code
npm run lint

📊 Projektstatus

Aktuelle Version: 1.0.0-alpha
Entwicklungsstatus: Aktive Entwicklung
Kernfortschritt: 36% (9/12 Phasen abgeschlossen)
Implementierte Tools: 57 produktionsbereit, 8 code-implementiert (ausstehend)
Ziel-Tools: 50+ ✅ (übertroffen)
KI-Integration: Ollama + Gemini + OpenAI + Anthropic Claude ✅ (8 Tools)
Erweiterte CLI: Interaktive KI-Tools-CLI mit Farben und Metriken ✅
Testabdeckung: 49 Tests implementiert (35 Unit + 1 Integration + 13 E2E)
Teststatus: ✅ Alle bestanden (49/49)
Dokumentation: 85% abgeschlossen (Installation, Konfiguration, API, Beispiele, KI-Guide)
Build-Status: ✅ Bestehend
Ausführbar: ✅ Bereit für die Bereitstellung
CLI: ✅ Funktional

Siehe ROADMAP.md für detaillierten Fortschritt.

🤖 KI-Tools-Integration

Nexus-MCP beinhaltet die Integration mit 4 großen KI-Anbietern:

Ollama (2 Tools): Lokale LLMs - Chat + Modelle auflisten
Gemini (2 Tools): Google KI - Chat + Modelle auflisten
OpenAI (2 Tools): GPT-Modelle - Chat + Modelle auflisten
Anthropic (2 Tools): Claude-Modelle - Chat + Modelle auflisten

Schnellstart mit KI-Tools

# Configure API keys
export OPENAI_API_KEY="your-key"
export GEMINI_API_KEY="your-key"
export ANTHROPIC_API_KEY="your-key"
export OLLAMA_HOST="http://localhost:11434"

# Run the interactive AI CLI
node examples/ai-interactive-cli.js

# Or run the enhanced demo
node examples/ai-enhanced-demo.js

Siehe KI-Tools-Guide für detaillierte Dokumentation.

🔌 MCP-Integration

Nexus-MCP ist ein MCP (Model Context Protocol) Server, der es KI-Assistenten wie Claude Code ermöglicht, seine 57 Tools zu nutzen.

Schnellstart mit MCP

Server starten:

npm start

Claude Desktop konfigurieren, um eine Verbindung zu Nexus-MCP herzustellen

Siehe MCP-Konfigurationsleitfaden für detaillierte Einrichtungsanweisungen.

Verfügbare Tool-Kategorien

Dateisystem (18 Tools): Dateien lesen, schreiben, auflisten, suchen
HTTP (16 Tools): Anfragen, Scraping, APIs
Git (15 Tools): Klonen, Commits, Branches, PRs
System (8 Tools): Befehle, Prozesse, Systeminformationen
KI (8 Tools): Chat mit Ollama, Gemini, OpenAI, Anthropic
Dienstprogramme (8 Tools): JSON, YAML, Komprimierung, Verschlüsselung

🤝 Mitwirken

Beiträge sind willkommen! Bitte lesen Sie unsere Richtlinien für Mitwirkende, bevor Sie PRs einreichen.

Forken Sie das Repository
Erstellen Sie Ihren Feature-Branch (git checkout -b feature/amazing-feature)
Committen Sie Ihre Änderungen (git commit -m 'Add amazing feature')
Pushen Sie auf den Branch (git push origin feature/amazing-feature)
Öffnen Sie einen Pull Request

📄 Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert - siehe die LICENSE-Datei für Details.

🙏 Danksagungen

Model Context Protocol
Anthropic Claude
MCP SDK TypeScript
App Migración SOUL - Konfigurationsmuster und Inspiration für kontextuelles Logging

📞 Support

Mit ❤️ erstellt vom Nexus-Team

Nexus-MCP