Nexus KI-Tools

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

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

1. Server starten:

npm start

2. 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.

1. Forken Sie das Repository

2. Erstellen Sie Ihren Feature-Branch (git checkout -b feature/amazing-feature)

3. Committen Sie Ihre Änderungen (git commit -m 'Add amazing feature')

4. Pushen Sie auf den Branch (git push origin feature/amazing-feature)

5. Ö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

• 📖 Dokumentation

• 🐛 Issue Tracker

• 💬 Discord-Community

• ✉️ E-Mail: support@nexus-mcp.dev

Mit ❤️ erstellt vom Nexus-Team