🤖 Claude Code MCP Server

Möchten Sie schnell loslegen? Schauen Sie sich unseren QUICKSTART.md- Leitfaden an!

Dieses Projekt ist ein Fork von steipete/claude-code-mcp mit erweiterten Orchestrierungsfunktionen, Zuverlässigkeitsverbesserungen und zusätzlicher Dokumentation.

Ein erweiterter Model Context Protocol (MCP)-Server ermöglicht die Ausführung von Claude Code im One-Shot-Modus mit automatischer Umgehung von Berechtigungen. Dieser Server bietet erweiterte Funktionen zur Task-Orchestrierung, robuste Fehlerbehandlung und ein „Boomerang-Muster“ zur Aufteilung komplexer Tasks in überschaubare Untertasks.

Ist Ihnen aufgefallen, dass herkömmliche KI-Assistenten manchmal mit komplexen, mehrstufigen Bearbeitungen oder Operationen zu kämpfen haben? Dieser Server mit seinem leistungsstarken, einheitlichen claude_code -Tool und verbesserten Zuverlässigkeitsfunktionen macht Claude zu einem direkteren und leistungsfähigeren Agenten für Ihre Programmieraufgaben.

🔍 Übersicht

Dieser MCP-Server bietet leistungsstarke Tools, die von LLMs zur Interaktion mit Claude Code genutzt werden können. Durch die Integration mit Claude Desktop oder anderen MCP-Clients ermöglicht er LLMs Folgendes:

• Führen Sie Claude Code mit umgangenen Berechtigungen aus (mit --dangerously-skip-permissions )

• Führen Sie Claude Code mit jeder Eingabeaufforderung ohne Berechtigungsunterbrechungen aus

• Greifen Sie direkt auf die Dateibearbeitungsfunktionen zu

• Führen Sie komplexe mehrstufige Vorgänge mit robuster Fehlerbehandlung und Wiederholungsversuchen aus

• Orchestrieren Sie Aufgaben durch spezialisierte Agentenrollen mithilfe des Boomerang-Musters

• Sorgen Sie für eine zuverlässige Ausführung durch Heartbeat-Mechanismen, um Timeouts zu verhindern

Related MCP server: Scenario Word

✨ Vorteile

• Verbesserte Zuverlässigkeit: Robuste Fehlerbehandlung, automatische Wiederholungsversuche, ordnungsgemäßes Herunterfahren und Anforderungsverfolgung

• Aufgabenorchestrierung: Komplexe Arbeitsabläufe können in spezialisierte Teilaufgaben zerlegt werden

• Aufgabenautomatisierung: Konvertieren Sie menschenlesbare Markdown-Aufgabenlisten automatisch in ausführbare MCP-Befehle

• Leistungsoptimierung: Verbesserte Ausführung durch Konfigurations-Caching und Ressourceneffizienz

• Bessere Überwachung: Health Check API, detaillierte Fehlerberichte und umfassende Protokollierung

• Entwicklererfahrung: Hot-Reloading der Konfiguration, flexible Umgebungskontrollen und vereinfachte API

Plus alle Standardvorteile des Claude Code:

• Claude/Windsurf haben oft Probleme beim Bearbeiten von Dateien. Claude Code kann das besser und schneller.

• Anstatt Befehle direkt auszuführen, können mehrere Befehle in die Warteschlange gestellt werden. Dadurch wird Kontextspeicherplatz gespart, sodass wichtige Informationen länger erhalten bleiben.

• Dateioperationen, Git oder andere Operationen benötigen keine kostspieligen Modelle. Claude Code ist kostengünstig, wenn Sie sich für Anthropic Max anmelden.

• Claude verfügt über einen umfassenderen Systemzugriff. Wenn Standardassistenten also nicht weiterkommen, bitten Sie sie einfach, „den Claude-Code zu verwenden“, um den Fortschritt freizugeben.

📝 Voraussetzungen

• Node.js v20 oder höher (Verwenden Sie fnm oder nvm zur Installation)

• Claude CLI lokal installiert (ausführen und /doctor aufrufen) und -dangerously-skip-permissions akzeptiert.

💾 Installation und Nutzung

Sie können diesen MCP-Server auf drei verschiedene Arten installieren und verwenden:

🚀 Methode 1: Über die GitHub-URL (empfohlen)

Die flexibelste Methode ist die direkte Installation von GitHub mit npx . Dadurch wird immer die neueste Version aus dem Repository abgerufen.

Fügen Sie Ihrer .mcp.json Datei Folgendes hinzu:

{
  "mcpServers": {
    "claude-code-mcp-enhanced": {
      "command": "npx",
      "args": [
        "github:grahama1970/claude-code-mcp-enhanced"
      ],
      "env": {
        "MCP_CLAUDE_DEBUG": "false",
        "MCP_HEARTBEAT_INTERVAL_MS": "15000",
        "MCP_EXECUTION_TIMEOUT_MS": "1800000"
      }
    }
  }
}

📦 Methode 2: Über das npm-Paket

Wenn das Paket auf npm veröffentlicht ist, können Sie es mit dem npm-Paketnamen installieren:

{
  "mcpServers": {
    "claude-code-mcp-enhanced": {
      "command": "npx",
      "args": [
        "-y",
        "@grahama1970/claude-code-mcp-enhanced@latest"
      ],
      "env": {
        "MCP_CLAUDE_DEBUG": "false",
        "MCP_HEARTBEAT_INTERVAL_MS": "15000",
        "MCP_EXECUTION_TIMEOUT_MS": "1800000"
      }
    }
  }
}

🔧 Methode 3: Lokale Installation

Zu Entwicklungs- oder Testzwecken können Sie den Server von einer lokalen Installation aus ausführen:

1. Klonen Sie das Repository:

   git clone https://github.com/grahama1970/claude-code-mcp-enhanced.git
   cd claude-code-mcp-enhanced

2. Installieren Sie Abhängigkeiten und erstellen Sie:

   npm install
   npm run build

3. Konfigurieren Sie Ihre .mcp.json Datei für die Verwendung des lokalen Servers:

{
  "mcpServers": {
    "claude-code-mcp-enhanced": {
      "command": "node",
      "args": [
        "/path/to/claude-code-mcp-enhanced/dist/server.js"
      ],
      "env": {
        "MCP_CLAUDE_DEBUG": "false",
        "MCP_HEARTBEAT_INTERVAL_MS": "15000",
        "MCP_EXECUTION_TIMEOUT_MS": "1800000"
      }
    }
  }
}

🔑 Wichtig bei der Ersteinrichtung: Berechtigungen akzeptieren

Bevor der MCP-Server das Tool claude_code erfolgreich verwenden kann, müssen Sie die Claude CLI zunächst einmal manuell mit dem Flag --dangerously-skip-permissions ausführen, sich anmelden und die Bedingungen akzeptieren.

Dies ist eine einmalige Anforderung der Claude CLI.

npm install -g @anthropic-ai/claude-code

claude --dangerously-skip-permissions

Befolgen Sie die Anweisungen zum Akzeptieren. Sobald dies erledigt ist, kann der MCP-Server das Flag nicht-interaktiv verwenden.

macOS fragt beim ersten Ausführen des Tools möglicherweise nach verschiedenen Ordnerberechtigungen, und der erste Durchlauf kann fehlschlagen. Nachfolgende Durchläufe funktionieren normal.

🔗 Herstellen einer Verbindung zu Ihrem MCP-Client

Nachdem Sie den Server eingerichtet haben, müssen Sie Ihren MCP-Client konfigurieren (wie Cursor, Claude Desktop oder andere, die mcp.json oder mcp_config.json verwenden).

Beispiel einer MCP-Konfigurationsdatei

Hier ist ein Beispiel, wie Sie den Claude Code MCP-Server zu Ihrer .mcp.json Datei hinzufügen:

{
  "mcpServers": {
    "Local MCP Server": {
      "type": "stdio",
      "command": "node",
      "args": [
        "dist/server.js"
      ],
      "env": {
        "MCP_USE_ROOMODES": "true",
        "MCP_WATCH_ROOMODES": "true",
        "MCP_CLAUDE_DEBUG": "false"
      }
    },
    "other-services": {
      // Your other MCP services here
    }
  }
}

MCP-Konfigurationsstandorte

Die Konfiguration erfolgt typischerweise in einer JSON-Datei. Name und Speicherort können je nach Client variieren.

Cursor

Der Cursor verwendet mcp.json .

• macOS: ~/.cursor/mcp.json

• Windows: %APPDATA%\\Cursor\\mcp.json

• Linux: ~/.config/cursor/mcp.json

Windsurf

Windsurf-Benutzer verwenden mcp_config.json

• macOS: ~/.codeium/windsurf/mcp_config.json

• Windows: %APPDATA%\\Codeium\\windsurf\\mcp_config.json

• Linux: ~/.config/.codeium/windsurf/mcp_config.json

(Hinweis: In einigen gemischten Setups greifen diese Clients möglicherweise auf den Cursor-Pfad ~/.cursor/mcp.json zurück, wenn auch Cursor installiert ist. Priorisieren Sie die Codeium-spezifischen Pfade, wenn Sie die Codeium-Erweiterung verwenden.)

Erstellen Sie diese Datei, falls sie nicht vorhanden ist.

🛠️ Mitgelieferte Tools

Dieser Server stellt drei Haupttools bereit:

claude_code 💬

Führt eine Eingabeaufforderung direkt mithilfe der Claude Code CLI mit --dangerously-skip-permissions aus.

Argumente:

• prompt (Zeichenfolge, erforderlich): Die an Claude Code zu sendende Eingabeaufforderung.

• workFolder (Zeichenfolge, optional): Das Arbeitsverzeichnis für die Claude CLI-Ausführung, das bei der Verwendung von Dateivorgängen oder beim Verweisen auf eine Datei erforderlich ist.

• parentTaskId (Zeichenfolge, optional): ID der übergeordneten Aufgabe, die diese Aufgabe erstellt hat (für Aufgabenorchestrierung/Boomerang).

• returnMode (Zeichenfolge, optional): Wie Ergebnisse zurückgegeben werden sollen: „summary“ (prägnant) oder „full“ (detailliert). Standardmäßig ist „full“ eingestellt.

• taskDescription (Zeichenfolge, optional): Kurzbeschreibung der Aufgabe zur besseren Organisation und Nachverfolgung in orchestrierten Arbeitsabläufen.

• mode (Zeichenfolge, optional): Wenn MCP_USE_ROOMODES=true, gibt den zu verwendenden Roo-Modus an (z. B. „Boomerang-Modus“, „Coder“, „Designer“ usw.).

health 🩺

Gibt den Integritätsstatus, Versionsinformationen und die aktuelle Konfiguration des Claude Code MCP-Servers zurück.

Beispiel einer Integritätsprüfungsanforderung:

{
  "toolName": "claude_code:health",
  "arguments": {}
}

Beispielantwort:

{
  "status": "ok",
  "version": "1.12.0",
  "claudeCli": {
    "path": "claude",
    "status": "available"
  },
  "config": {
    "debugMode": true,
    "heartbeatIntervalMs": 15000,
    "executionTimeoutMs": 1800000,
    "useRooModes": true,
    "maxRetries": 3,
    "retryDelayMs": 1000
  },
  "system": {
    "platform": "linux",
    "release": "6.8.0-57-generic",
    "arch": "x64",
    "cpus": 16,
    "memory": {
      "total": "32097MB",
      "free": "12501MB"
    },
    "uptime": "240 minutes"
  },
  "timestamp": "2025-05-15T18:30:00.000Z"
}

convert_task_markdown 📋

Konvertiert Markdown-Task-Dateien in das Claude Code MCP-kompatible JSON-Format.

Argumente:

• markdownPath (Zeichenfolge, erforderlich): Pfad zur zu konvertierenden Markdown-Task-Datei.

• outputPath (Zeichenfolge, optional): Pfad, unter dem die JSON-Ausgabe gespeichert werden soll. Falls nicht angegeben, wird das JSON direkt zurückgegeben.

Beispielanfrage:

{
  "toolName": "claude_code:convert_task_markdown",
  "arguments": {
    "markdownPath": "/home/user/tasks/validation.md",
    "outputPath": "/home/user/tasks/validation.json"
  }
}

Beispielhafte Nutzungsszenarien

1. Grundlegende Codebedienung

Beispiel einer MCP-Anforderung:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nRefactor the function foo in main.py to be async.",
    "workFolder": "/path/to/project"
  }
}

2. Aufgabenorchestrierung (Bumerang-Muster)

Übergeordnete Aufgabenanforderung:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nOrchestrate the implementation of a new API endpoint with the following subtasks:\n1. Create database models\n2. Implement API route handlers\n3. Write unit tests\n4. Document the API",
    "workFolder": "/path/to/project"
  }
}

Unteraufgabenanforderung (vom übergeordneten Element generiert):

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nCreate database models for the new API endpoint as specified in the requirements.",
    "workFolder": "/path/to/project",
    "parentTaskId": "task-123",
    "returnMode": "summary",
    "taskDescription": "Database model creation for API endpoint"
  }
}

3. Spezialmodusanforderung

Beispiel für die Verwendung des Roo-Modus:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nCreate unit tests for the user authentication module.",
    "workFolder": "/path/to/project",
    "mode": "coder"
  }
}

🔄 Aufgabenkonverter

Der MCP-Server enthält ein leistungsstarkes Task-Konverter-Tool, das menschenlesbare Markdown-Aufgabenlisten automatisch in vollständig ausführbare MCP-Befehle umwandelt. Dieser intelligente Konverter schließt die Lücke zwischen der menschlichen Denkweise und der maschinellen Ausführung von Aufgaben.

Vollständiger Workflow

graph TD
    A["👤 User"] -->|"Create tasks.md"| B["📝 Multi-Task Markdown"]
    A -->|"Prompt Claude"| C["🤖 Claude Desktop"]
    C -->|"Use convert_task_markdown"| D["🔄 Task Converter MCP"]
    D -->|"Validate Format"| E{"Format Valid?"}
    E -->|"No"| F["📑 Error + Fix Instructions"]
    F -->|"Return to User"| A
    E -->|"Yes"| G["📋 MCP Task List"]
    G -->|"Execute Task"| H1["⚡ Claude Task #1"]
    H1 -->|"Complete"| I1["Next Task"]
    I1 -->|"Execute Task"| H2["⚡ Claude Task #2"]
    H2 -->|"Complete"| I2["Next Task"]
    I2 -->|"Execute Task"| H3["⚡ Claude Task #3"]
    H3 -->|"Complete"| I3["More Tasks"]
    I3 -->|"Execute Task"| HN["⚡ Claude Task #N"]
    HN -->|"Complete"| IN["🎉 All Tasks Completed!"]
    
    style A fill:#4A90E2,stroke:#fff,stroke-width:2px,color:#fff
    style C fill:#7C4DFF,stroke:#fff,stroke-width:2px,color:#fff
    style D fill:#00BCD4,stroke:#fff,stroke-width:2px,color:#fff
    style F fill:#FF5252,stroke:#fff,stroke-width:2px,color:#fff
    style G fill:#4CAF50,stroke:#fff,stroke-width:2px,color:#fff
    style H1 fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
    style H2 fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
    style H3 fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
    style HN fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
    style IN fill:#4CAF50,stroke:#fff,stroke-width:2px,color:#fff

Workflow-Schritte

1. Der Benutzer fügt das MCP zu seiner Konfigurationsdatei hinzu

2. Der Benutzer fordert Claude auf : „Verwende convert_task_markdown, um meine Datei tasks.md auszuführen.“

3. Das MCP führt automatisch Folgendes aus:

   • Lädt die Markdown-Datei

   • Validiert das Format (gibt Fehler zurück, wenn Abschnitte fehlen)

   • Wandelt menschenlesbare Aufgaben in exakt ausführbare Befehle um

   • Gibt JSON zurück, das Claude Code sequenziell ausführen kann

4. Claude empfängt das JSON und kann jede Aufgabe mit dem Tool claude_code ausführen

Hauptmerkmale

• Automatische Pfadauflösung: Konvertiert allgemeine Anweisungen wie „Verzeichnis zum Projekt ändern“ in exakte ausführbare Befehle mit vollständigen Pfaden

• Intelligente Befehlsübersetzung: Wandelt englische Anweisungen in präzise Terminalbefehle um (z. B. „Aktiviere die virtuelle Umgebung“ → source .venv/bin/activate )

• MCP-Protokollkonformität: Stellt sicher, dass die gesamte Ausgabe zu 100 % mit dem Model Context Protocol kompatibel ist

• Keine Mehrdeutigkeit: Alle generierten Befehle verwenden exakte Pfade und ausführbare Syntax – keine Platzhalter oder generischen Referenzen

• Formatvalidierung: Erzwingt eine korrekte Markdown-Struktur und liefert hilfreiche Fehlermeldungen bei fehlerhafter Formatierung

• Echtzeit-Fortschrittsaktualisierungen: Bietet Live-Fortschrittsaktualisierungen während der Konvertierung, die zeigen, welche Aufgaben verarbeitet werden

Konvertieren Sie Markdown-Aufgaben in MCP-Befehle

Das Tool convert_task_markdown verarbeitet strukturierte Markdown-Dateien und generiert MCP-kompatibles JSON:

Anforderungsformat:

{
  "tool": "convert_task_markdown",
  "arguments": {
    "markdownPath": "/path/to/tasks.md",
    "outputPath": "/path/to/output.json" // optional
  }
}

Antwortformat:

{
  "tasksCount": 5,
  "outputPath": "/path/to/output.json",
  "tasks": [
    {
      "tool": "claude_code",
      "arguments": {
        "command": "cd /project && source .venv/bin/activate\n\nTASK TYPE: Validation...",
        "dangerously_skip_permissions": true,
        "timeout_ms": 300000
      }
    }
    // ... more tasks
  ]
}

Markdown-Task-Dateiformat

Task-Markdown-Dateien sollten dieser Struktur folgen:

# Task 001: Task Title

## Objective
Clear description of what needs to be accomplished.

## Requirements
1. [ ] First requirement
2. [ ] Second requirement

## Tasks

### Module or Component Name
- [ ] Validate `path/to/file.py`
   - [ ] Step 1
   - [ ] Step 2
   - [ ] Step 3

Der Konverter wird:

1. Analysieren Sie die Markdown-Struktur

2. Extrahieren von Aufgabenmetadaten und Anforderungen

3. Generieren Sie detaillierte Eingabeaufforderungen für jede Validierungsaufgabe

4. Schließen Sie die richtige Einrichtung des Arbeitsverzeichnisses ein

5. Fügen Sie Überprüfungs- und Abschlusszusammenfassungen hinzu

Beispielverwendung

1. Erstellen Sie eine Task-Datei ( tasks/api_validation.md ):

# Task 001: API Endpoint Validation

## Objective
Validate all API endpoints work with real database connections.

## Requirements
1. [ ] All endpoints must use real database
2. [ ] No mock data in validation

## Core API Tasks
- [ ] Validate `api/users.py`
   - [ ] Change directory to project and activate .venv
   - [ ] Test user creation endpoint
   - [ ] Test user retrieval endpoint
   - [ ] Verify JSON responses

2. In MCP-Aufgaben konvertieren :

{
  "tool": "convert_task_markdown",
  "arguments": {
    "markdownPath": "/project/tasks/api_validation.md"
  }
}

3. Der Konverter zeigt den Fortschritt in Echtzeit an :

   [Progress] Loading task file...
   [Progress] Validating markdown structure...
   [Progress] Converting 27 validation tasks...
   [Progress] Task 1/27: Converting core/constants.py
   [Progress] Task 2/27: Converting core/arango_setup.py
   ...
   [Progress] Conversion complete!

4. Der Konverter wandelt allgemeine Anweisungen in genaue Befehle um :

   • Aus „Verzeichnis zum Projekt wechseln und .venv aktivieren“ wird:

     cd /home/user/project && source .venv/bin/activate

   • Alle Pfade werden in absolute Pfade aufgelöst

   • Alle Befehle sind vollständig und ohne Mehrdeutigkeiten ausführbar

5. Führen Sie die konvertierten Aufgaben aus : Die zurückgegebenen Aufgaben enthalten genaue, ausführbare Befehle und können mit dem Tool claude_code sequenziell ausgeführt werden.

Vollständiges Beispiel: Vom Markdown zur Ausführung

Schritt 1: Der Benutzer erstellt eine Markdown-Aufgabendatei ( project_tasks.md ):

# Task 001: Setup Development Environment

## Objective
Initialize the development environment with all dependencies.

## Requirements
1. [ ] Python 3.11+ installed
2. [ ] Virtual environment created

## Tasks
- [ ] Validate `setup.py`
   - [ ] Change to project directory
   - [ ] Create virtual environment
   - [ ] Install dependencies

Schritt 2: Der Benutzer fordert Claude auf :

Use convert_task_markdown to process /home/user/project_tasks.md

Schritt 3: MCP konvertiert und validiert :

• Wenn das Format korrekt ist: Gibt ausführbares JSON zurück

• Bei falschem Format: Gibt einen Fehler mit Anleitung zurück

Schritt 4: Ergebnis (bei Erfolg) :

[
  {
    "tool": "claude_code",
    "arguments": {
      "prompt": "cd /home/user/project && python -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt",
      "workFolder": "/home/user/project"
    }
  }
]

Schritt 5: Claude kann jede Aufgabe nacheinander ausführen

Formatvalidierung und Fehlerbehandlung

Der Task-Konverter erzwingt eine spezifische Markdown-Struktur, um eine konsistente und zuverlässige Task-Konvertierung zu gewährleisten. Sollte Ihre Markdown-Datei falsch formatiert sein, gibt der Konverter hilfreiche Fehlermeldungen aus:

Beispiel für eine Fehlerantwort:

{
  "status": "error",
  "error": "Markdown format validation failed",
  "details": "Markdown format validation failed:\n  - Missing required title. Format: '# Task NNN: Title'\n  - Missing or empty 'Requirements' section. Format: '## Requirements\\n1. [ ] Requirement'\n  - No validation tasks found. Format: '- [ ] Validate `module.py`' with indented steps\n\nRequired markdown format:\n# Task NNN: Title\n## Objective\nClear description\n## Requirements\n1. [ ] First requirement\n## Task Section\n- [ ] Validate `file.py`\n   - [ ] Step 1\n   - [ ] Step 2",
  "helpUrl": "https://github.com/grahama1970/claude-code-mcp-enhanced/blob/main/README.md#markdown-task-file-format"
}

Die Validierung stellt sicher:

1. Erforderliche Abschnitte sind vorhanden (Titel, Ziel, Anforderungen)

2. Aufgaben verwenden das richtige Kontrollkästchenformat

3. Jede Aufgabe hat eingerückte Schritte

4. Anforderungen verwenden aus Konsistenzgründen das Kontrollkästchenformat

🦚 Aufgabenorchestrierungsmuster

Dieser MCP-Server unterstützt leistungsstarke Aufgabenorchestrierungsfunktionen, um komplexe Arbeitsabläufe effizient zu handhaben.

Bumerang-Muster (Claude Desktop ⟷ Claude Code)

Das Boomerang-Muster ermöglicht es Claude Desktop, Aufgaben zu orchestrieren und an Claude Code zu delegieren. Dies ermöglicht Ihnen:

1. Zerlegen Sie komplexe Arbeitsabläufe in kleinere, überschaubare Teilaufgaben

2. Kontext von übergeordneten Aufgaben an untergeordnete Aufgaben weitergeben

3. Ergebnisse von Unteraufgaben an die übergeordnete Aufgabe zurückgeben

4. Wählen Sie zwischen detaillierten oder zusammengefassten Ergebnissen

5. Verfolgen und verwalten Sie den Fortschritt mithilfe strukturierter Aufgabenlisten

Bumerang-Muster-Visualisierung

Hier ist ein einfaches Diagramm, das zeigt, wie Claude eine Rezeptaufgabe in Schritte unterteilt und diese an Claude Code delegiert:

graph TB
    User("👨‍🍳 User")
    Claude("🤖 Claude (Parent)")
    Code1("🧁 Claude Code")
    Code2("🧁 Claude Code")
    
    User-->|"Make chocolate cake"| Claude
    Claude-->|"Task 1: Find recipe"| Code1
    Code1-->|"Result: Recipe found"| Claude
    Claude-->|"Task 2: Convert measurements"| Code2
    Code2-->|"Result: Measurements converted"| Claude
    Claude-->|"Complete recipe + instructions"| User

In diesem Beispiel:

1. Der Benutzer bittet Claude, ein Schokoladenkuchenrezept zu machen

2. Claude (Elternteil) unterteilt dies in einzelne Aufgaben

3. Claude delegiert die Aufgabe „Rezept finden“ an Claude Code mit einer übergeordneten Aufgaben-ID

4. Claude Code gibt die Rezeptinformationen an Claude zurück

5. Claude delegiert die Aufgabe „Messwerte konvertieren“ an Claude Code

6. Claude Code gibt die konvertierten Messungen zurück

7. Claude kombiniert alle Ergebnisse und präsentiert dem Benutzer die komplette Lösung

Einfache Aufgabenbeispiele:

Aufgabe 1 – Rezept finden:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Search for a classic chocolate cake recipe. Find one with good reviews.",
    "parentTaskId": "cake-recipe-123",
    "returnMode": "summary",
    "taskDescription": "Find Chocolate Cake Recipe"
  }
}

Aufgabe 2 – Maße umrechnen:

{
  "toolName": "claude_code:claude_code",
  "arguments": {
    "prompt": "Convert the measurements in this recipe from cups to grams:\n\n- 2 cups flour\n- 1.5 cups sugar\n- 3/4 cup cocoa powder",
    "parentTaskId": "cake-recipe-123",
    "returnMode": "summary",
    "taskDescription": "Convert Recipe Measurements"
  }
}

Wie es funktioniert

1. Erstellen einer Unteraufgabe:

   • Generieren Sie eine eindeutige Aufgaben-ID in Ihrer übergeordneten Aufgabe

   • Senden Sie eine Anfrage an das Tool claude_code mit:

     • Ihre konkrete Aufforderung

     • Die übergeordnete Aufgaben-ID

     • Eine Aufgabenbeschreibung

     • Der gewünschte Rückgabemodus ('Zusammenfassung' oder 'Vollständig')

2. Ergebnisse erhalten:

   • Das Ergebnis der Unteraufgabe enthält eine spezielle Markierung: <!-- BOOMERANG_RESULT {...} -->

   • Dieser Marker enthält JSON mit den Aufgabenmetadaten

   • Die übergeordnete Aufgabe kann dies analysieren, um abgeschlossene Unteraufgaben zu identifizieren

3. Beispiel-Workflow mit Claude Desktop:

You: I need to refactor this codebase. It's quite complex.

Claude Desktop: I'll help you with that. Let me break this down into smaller tasks for Claude Code to handle:

1. First, I'll have Claude Code analyze the codebase structure
2. Then, I'll have it identify problematic patterns
3. Finally, I'll ask it to generate a refactoring plan

[Claude Desktop sends a request to the claude_code tool with parentTaskId="task1" and returnMode="summary"]

[Claude Code analyzes the codebase and returns a summary with the BOOMERANG_RESULT marker]

Claude Desktop: Based on Claude Code's analysis, here are the key issues found:
- Duplicate code in modules X and Y
- Poor separation of concerns in module Z
- Inconsistent naming conventions

Now I'll ask Claude Code to suggest specific refactorings...

Dieser Ansatz ist besonders nützlich für komplexe Aufgaben, die eine gründliche Analyse oder mehrere Schritte erfordern.

Beispiel für umfassendes Aufgabenlistenmanagement

Hier ist ein ausführliches Beispiel für die Verwendung von Claude mit dem Claude Code MCP zum Verwalten und Ausführen einer strukturierten Aufgabenliste:

1. Einrichten der Aufgabenlistenstruktur

Erstellen Sie zunächst eine Aufgabenlistendatei (z. B. tasks.md ) mit der folgenden Struktur:

# Project Task List

## Parent Task: API Optimization Project
- [ ] Optimize API performance for high-traffic endpoints
  - [ ] Analyze current API performance and identify bottlenecks
  - [ ] Implement database query optimization for user endpoints
  - [ ] Add Redis caching for frequently accessed data
  - [ ] Set up performance monitoring

## Assumptions and Decisions
- [2025-05-15] Assumption: Redis is available in the infrastructure
- [2025-05-15] Decision: Focus on user endpoints first (Rationale: Highest traffic area)

## Relevant Files
- `src/controllers/userController.js`: User API endpoints
- `src/services/userService.js`: Business logic for user operations

## Improvement Notes
- Pattern identified: N+1 query issue in user listing endpoint
- Automation opportunity: Add caching automatically for all get-by-id endpoints

2. Ausführen der Aufgabenliste

Claude kann die Aufgaben nun mithilfe von Claude Code systematisch abarbeiten:

You: Please help me execute the task list in tasks.md, starting with the first subtask.

Claude: I'll help you work through your task list systematically. Let me first check the current task list to identify the next task to work on.

[Claude uses claude_code to read the task list]

I see the first subtask is "Analyze current API performance and identify bottlenecks". I'll execute this task now using Claude Code.

[Claude sends the following request to claude_code]:

{
  "toolName": "claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nTASK TYPE: Analysis\nTASK ID: api-perf-analysis\nCURRENT SUBTASK: Analyze current API performance and identify bottlenecks\n\nCONTEXT:\n- Parent task goal: Optimize API performance for high-traffic endpoints\n- This is the first step in our optimization process\n- Focus on user endpoints as noted in assumptions\n\nINSTRUCTIONS:\n1. Analyze the current API implementation in src/controllers/userController.js and src/services/userService.js\n2. Run performance tests on the user endpoints\n3. Identify specific bottlenecks and performance issues\n4. Document findings in a clear, structured format\n5. Update task list file after completion\n\nAfter completion, provide summary in this format:\n\nCOMPLETION SUMMARY:\n- What was done:\n- Results:\n- Files analyzed:\n- Issues identified:\n- Recommendations:\n- Next subtask in list:",
    "workFolder": "/path/to/project"
  }
}

[Claude Code executes the analysis task and returns results]

Great! Claude Code has completed the analysis. Here's what was found:

1. Main performance bottlenecks identified:
   - N+1 query problem in the user listing endpoint
   - Missing indexes on frequently queried fields
   - No caching for repetitive data lookups

2. Recommendations:
   - Add eager loading for user relationships
   - Create database indexes for user_id and email fields
   - Implement Redis caching with a 5-minute TTL

Let me update the task list to mark this task as complete and proceed to the next one.

[Claude uses claude_code to update the task list]:

{
  "toolName": "claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nTASK TYPE: Task List Update\n\n1. Read the current task list in tasks.md\n2. Mark the 'Analyze current API performance and identify bottlenecks' subtask as [x]\n3. Add new findings to the Improvement Notes section\n4. Add any new relevant files identified during analysis\n5. Write updated task list\n6. Return the updated task list",
    "workFolder": "/path/to/project"
  }
}

[Claude Code updates the task list and marks the first subtask complete]

I've updated the task list. The first subtask is now complete, and I've added the detailed findings to the Improvement Notes section. The next subtask is "Implement database query optimization for user endpoints".

Would you like me to proceed with this next subtask now?

3. Weiter mit den Folgeaufgaben

Nach Erhalt der Bestätigung würde Claude mit der nächsten Unteraufgabe fortfahren:

You: Yes, please proceed with the next subtask.

Claude: I'll now execute the next subtask: "Implement database query optimization for user endpoints". This will involve fixing the N+1 query problem identified in the analysis and adding appropriate database indexes.

[Claude sends the following request to claude_code]:

{
  "toolName": "claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nTASK TYPE: Code Implementation\nTASK ID: db-query-optimization\nCURRENT SUBTASK: Implement database query optimization for user endpoints\n\nCONTEXT:\n- Parent task goal: Optimize API performance for high-traffic endpoints\n- Previous subtask identified N+1 query issues and missing indexes\n- Need to implement eager loading and proper indexes\n\nINSTRUCTIONS:\n1. Modify src/controllers/userController.js to implement eager loading for related data\n2. Add appropriate database indexes to user-related tables\n3. Refactor any inefficient database queries in userService.js\n4. Ensure changes maintain existing functionality\n5. Run tests to verify performance improvements\n6. Update task list file after completion\n\nAfter completion, provide summary in this format:\n\nCOMPLETION SUMMARY:\n- What was done:\n- Results:\n- Files modified:\n- Performance improvements:\n- Next subtask in list:",
    "workFolder": "/path/to/project"
  }
}

[Claude Code implements the optimizations and returns results]

Excellent! The database query optimizations have been successfully implemented. Here's a summary:

1. Changes made:
   - Added eager loading in userController.js for user relationships
   - Created new database indexes for user_id and email fields
   - Refactored list query to use a single efficient JOIN statement
   - Added pagination to prevent large result sets

2. Performance results:
   - User listing endpoint response time reduced by 68%
   - Database query count reduced from 25+ to 3 for typical requests

Let me update the task list again to reflect this progress.

[Claude uses claude_code to update the task list again]:

{
  "toolName": "claude_code",
  "arguments": {
    "prompt": "Your work folder is /path/to/project\n\nTASK TYPE: Task List Update\n\n1. Read the current task list in tasks.md\n2. Mark the 'Implement database query optimization for user endpoints' subtask as [x]\n3. Add new files modified to the Relevant Files section\n4. Update Improvement Notes with performance metrics\n5. Write updated task list\n6. Return the updated task list",
    "workFolder": "/path/to/project"
  }
}

[Claude Code updates the task list and marks the second subtask complete]

I've updated the task list again. Two subtasks are now complete, and the next one is "Add Redis caching for frequently accessed data". Would you like me to continue with this subtask?

Dieser strukturierte Ansatz ermöglicht es Claude, komplexe Aufgabenlisten systematisch abzuarbeiten und gleichzeitig während des gesamten Prozesses eine klare Dokumentation des Fortschritts, der Annahmen und der relevanten Dateien aufrechtzuerhalten.

🎭 Selbstorchestrierungsmuster (Claude Code als Orchestrator)

Während Claude Desktop häufig als übergeordneter Agent verwendet wird, können Sie Claude Code selbst sowohl als Orchestrator als auch als Executor einsetzen. Dieser Ansatz schafft ein in sich geschlossenes System, in dem Claude Code seine eigene Aufgabenorchestrierung verwaltet, ohne dass Claude Desktop erforderlich ist.

graph TB
    User("👨‍💻 User")
    ClaudeCode("🤖 Claude Code\nOrchestrator")
    ClaudeCodeSubtask1("⚙️ Claude Code\nSubtask 1")
    ClaudeCodeSubtask2("⚙️ Claude Code\nSubtask 2")
    
    User-->|"Complex project request"| ClaudeCode
    ClaudeCode-->|"1. Plans tasks"| ClaudeCode
    ClaudeCode-->|"2. Executes subtask 1"| ClaudeCodeSubtask1
    ClaudeCodeSubtask1-->|"3. Returns result"| ClaudeCode
    ClaudeCode-->|"4. Executes subtask 2"| ClaudeCodeSubtask2
    ClaudeCodeSubtask2-->|"5. Returns result"| ClaudeCode
    ClaudeCode-->|"6. Final solution"| User

Implementierungsschritte

1. Erstellen Sie ein Einstiegsskript , das Ihre Aufgabenstruktur initialisiert und Claude Code als Orchestrator startet

2. Entwerfen Sie eine Aufgabendatenstruktur (normalerweise im JSON-Format), die den Aufgabenstatus und die Abhängigkeiten verfolgt

3. Erstellen Sie Task-Executor-Skripte, um einzelne Tasks zu verarbeiten und den Task-Status zu aktualisieren.

Hauptvorteile der Selbstorchestrierung

1. Eigenständig : Kein externer Orchestrator (wie Claude Desktop) erforderlich

2. Persistenter Status : Alle Aufgabeninformationen werden in JSON-Dateien gespeichert

3. Fehlerbehebung : Kann bei einer Unterbrechung mit der letzten erfolgreichen Aufgabe fortfahren

4. Vereinfachtes Abhängigkeitsmanagement : Ein einziges System verwaltet alle Claude Code-Interaktionen

5. Shell-Skript-Automatisierung : Einfache Integration in CI/CD-Pipelines oder automatisierte Workflows

Eine ausführliche Implementierungsanleitung mit Beispielskripten und Aufgabenstrukturen finden Sie unter Selbstorchestrierung mit Claude Code .

👓 Roo-Modus-Integration

Dieser MCP-Server unterstützt die Integration spezialisierter Modi über eine .roomodes -Konfigurationsdatei. Wenn diese Option aktiviert ist, können Sie den Modus für jede Aufgabe festlegen und so spezialisiertes Verhalten ermöglichen.

So verwenden Sie Roo-Modi

1. Roo-Modus-Unterstützung aktivieren:

   • Setzen Sie die Umgebungsvariable MCP_USE_ROOMODES=true in Ihrer MCP-Konfiguration

   • Erstellen Sie eine .roomodes -Datei im Stammverzeichnis Ihres MCP-Servers

   • Aktivieren Sie optional Hot-Reloading mit MCP_WATCH_ROOMODES=true um die Konfiguration automatisch neu zu laden, wenn sich die Datei ändert

2. Konfigurieren Sie Ihre Modi:

   • Die .roomodes Datei sollte ein JSON-Objekt mit einem customModes -Array enthalten

   • Jeder Modus sollte einen slug , name , roleDefinition und optional eine apiConfiguration mit einer modelId haben.

3. Verwenden eines Modus:

   • Wenn Sie Anfragen an das Tool claude_code stellen, fügen Sie einen mode mit dem Slug des gewünschten Modus ein.

   • Der MCP-Server wendet die Rollendefinition und Modellkonfiguration automatisch an

4. Beispiel einer .roomodes-Datei:

   {
     "customModes": [
       {
         "slug": "coder",
         "name": "💻 Coder",
         "roleDefinition": "You are a coding specialist who writes clean, efficient code.",
         "apiConfiguration": {
           "modelId": "claude-3-sonnet-20240229"
         }
       },
       {
         "slug": "designer", 
         "name": "🎨 Designer",
         "roleDefinition": "You are a design specialist focused on UI/UX solutions."
       }
     ]
   }

5. Beispiel für eine Umgebungskonfiguration:

   {
     "mcpServers": {
       "claude-code-mcp-enhanced": {
         "command": "npx",
         "args": ["github:grahama1970/claude-code-mcp-enhanced"],
         "env": {
           "MCP_USE_ROOMODES": "true",
           "MCP_WATCH_ROOMODES": "true",
           "MCP_CLAUDE_DEBUG": "false"
         }
       }
     }
   }

6. Anfragen mit Modi stellen:

   {
     "toolName": "claude_code:claude_code",
     "arguments": {
       "prompt": "Your work folder is /path/to/project\n\nCreate unit tests for the user authentication module.",
       "workFolder": "/path/to/project",
       "mode": "coder"
     }
   }

Hauptfunktionen der Roo-Modi:

• Spezialisiertes Verhalten : Verschiedene Modi können unterschiedliche Systemaufforderungen und Modellkonfigurationen haben

• Hot Reloading : Wenn MCP_WATCH_ROOMODES=true , lädt der Server die Konfiguration automatisch neu, wenn sich die .roomodes -Datei ändert

• Leistung : Der Server speichert die Roomodes-Konfiguration für eine bessere Leistung

• Fallback : Wenn ein Modus nicht gefunden wird oder Raummodi deaktiviert sind, fährt der Server mit dem Standardverhalten fort

🛠️ Verbesserte Zuverlässigkeitsfunktionen

Dieser Server enthält mehrere Verbesserungen zur Verbesserung der Zuverlässigkeit und Leistung:

1. Heartbeat- und Timeout-Prävention

So verhindern Sie clientseitige Timeouts bei Vorgängen mit langer Ausführungsdauer:

• Ein konfigurierbarer Heartbeat-Mechanismus wurde hinzugefügt, der alle 15 Sekunden Fortschrittsaktualisierungen sendet

• Implementierte Ausführungszeitverfolgung und Berichterstattung

• Konfigurierbare Timeout-Parameter durch Umgebungsvariablen hinzugefügt

2. Robuste Fehlerbehandlung mit Wiederholungsversuchen

Intelligente Wiederholungslogik für vorübergehende Fehler hinzugefügt:

• Automatischer Wiederholungsversuch mit konfigurierbaren Parametern implementiert

• Fehlerklassifizierung hinzugefügt, um wiederholbare Probleme zu identifizieren

• Detaillierte Fehlerberichte und -verfolgung erstellt

3. Anfrageverfolgungssystem

Umfassendes Request-Lifecycle-Management implementiert:

• Für jede Anfrage wurden eindeutige IDs hinzugefügt

• Tracking für laufende Anfragen erstellt

• Gewährleistete ordnungsgemäße Bereinigung nach Abschluss oder Fehler

4. Ordnungsgemäßes Herunterfahren

Korrekte Behandlung der Prozessbeendigung hinzugefügt:

• Signalhandler für SIGINT und SIGTERM implementiert

• Tracking für laufende Anfragen hinzugefügt

• Wartelogik für sauberes Herunterfahren erstellt

• Sorgte für eine ordnungsgemäße Bereinigung beim Verlassen

5. Konfigurations-Caching und Hot Reloading

Leistungsoptimierung für die Konfiguration hinzugefügt:

• Caching für Roomodes-Datei implementiert

• Automatische Ungültigkeitserklärung basierend auf Dateiänderungen hinzugefügt

• Konfigurierbarer Dateiüberwachungsmechanismus erstellt

⚙️ Konfigurationsoptionen

Das Verhalten des Servers kann mithilfe dieser Umgebungsvariablen angepasst werden:

Diese können in Ihrer Shell-Umgebung oder im env Ihrer mcp.json Serverkonfiguration festgelegt werden.

📸 Visuelle Beispiele

Hier sind einige visuelle Beispiele des Servers in Aktion:

Beheben des ESLint-Setups

Hier ist ein Beispiel für die Verwendung des Claude Code MCP-Tools zum interaktiven Reparieren eines ESLint-Setups durch Löschen alter Konfigurationsdateien und Erstellen einer neuen:

Beispiel zum Auflisten von Dateien

Hier ist ein Beispiel für das Claude Code-Tool, das Dateien in einem Verzeichnis auflistet:

Komplexe mehrstufige Vorgänge

Dieses Beispiel veranschaulicht, wie claude_code eine komplexere, mehrstufige Aufgabe verarbeitet, z. B. die Vorbereitung einer Version durch Erstellen eines Zweigs, Aktualisieren mehrerer Dateien ( package.json , CHANGELOG.md ), Übernehmen von Änderungen und Initiieren einer Pull-Anfrage – alles in einem einzigen, zusammenhängenden Vorgang.

Korrektur des GitHub Actions-Workflows

🎯 Wichtige Anwendungsfälle

Dieser Server erschließt mit seinem einheitlichen claude_code Tool eine Vielzahl leistungsstarker Funktionen, indem er Ihrer KI direkten Zugriff auf die Claude Code-CLI gewährt. Hier sind einige Beispiele dafür, was Sie erreichen können:

1. Codegenerierung, -analyse und -refactoring:

   • "Generate a Python script to parse CSV data and output JSON."

   • "Analyze my_script.py for potential bugs and suggest improvements."

2. Dateisystemoperationen (Erstellen, Lesen, Bearbeiten, Verwalten):

   • Dateien erstellen: "Your work folder is /Users/steipete/my_project\n\nCreate a new file named 'config.yml' in the 'app/settings' directory with the following content:\nport: 8080\ndatabase: main_db"

   • Dateien bearbeiten: "Your work folder is /Users/steipete/my_project\n\nEdit file 'public/css/style.css': Add a new CSS rule at the end to make all 'h2' elements have a 'color: navy'."

   • Verschieben/Kopieren/Löschen: "Your work folder is /Users/steipete/my_project\n\nMove the file 'report.docx' from the 'drafts' folder to the 'final_reports' folder and rename it to 'Q1_Report_Final.docx'."

3. Versionskontrolle (Git):

   • "Your work folder is /Users/steipete/my_project\n\n1. Stage the file 'src/main.java'.\n2. Commit the changes with the message 'feat: Implement user authentication'.\n3. Push the commit to the 'develop' branch on origin."

4. Ausführen von Terminalbefehlen:

   • "Your work folder is /Users/steipete/my_project/frontend\n\nRun the command 'npm run build'."

   • "Open the URL https://developer.mozilla.org in my default web browser."

5. Websuche und Zusammenfassung:

   • "Search the web for 'benefits of server-side rendering' and provide a concise summary."

6. Komplexe mehrstufige Arbeitsabläufe:

   • Automatisieren Sie Versionssprünge, aktualisieren Sie Änderungsprotokolle und kennzeichnen Sie Releases: "Your work folder is /Users/steipete/my_project\n\nFollow these steps: 1. Update the version in package.json to 2.5.0. 2. Add a new section to CHANGELOG.md for version 2.5.0 with the heading '### Added' and list 'New feature X'. 3. Stage package.json and CHANGELOG.md. 4. Commit with message 'release: version 2.5.0'. 5. Push the commit. 6. Create and push a git tag v2.5.0."

7. Reparieren von Dateien mit Syntaxfehlern:

   • "Your work folder is /path/to/project\n\nThe file 'src/utils/parser.js' has syntax errors after a recent complex edit that broke its structure. Please analyze it, identify the syntax errors, and correct the file to make it valid JavaScript again, ensuring the original logic is preserved as much as possible."

8. Interaktion mit GitHub (z. B. Erstellen einer Pull-Anfrage):

   • "Your work folder is /Users/steipete/my_project\n\nCreate a GitHub Pull Request in the repository 'owner/repo' from the 'feature-branch' to the 'main' branch. Title: 'feat: Implement new login flow'. Body: 'This PR adds a new and improved login experience for users.'"

9. Interaktion mit GitHub (z. B. Überprüfen des PR-CI-Status):

   • "Your work folder is /Users/steipete/my_project\n\nCheck the status of CI checks for Pull Request #42 in the GitHub repository 'owner/repo'. Report if they have passed, failed, or are still running."

WICHTIG: Denken Sie daran, in Ihren Eingabeaufforderungen für Dateisystem- oder Git-Operationen den Kontext des aktuellen Arbeitsverzeichnisses (CWD) anzugeben (z. B. "Your work folder is /path/to/project\n\n...your command..." ).

🔧 Fehlerbehebung

• „Befehl nicht gefunden“ (claude-code-mcp): Stellen Sie bei globaler Installation sicher, dass sich das globale Bin-Verzeichnis von npm im Pfad Ihres Systems befindet. Stellen Sie bei Verwendung von npx sicher, dass npx selbst funktioniert.

• „Befehl nicht gefunden“ (claude oder ~/.claude/local/claude): Stellen Sie sicher, dass die Claude-CLI korrekt installiert ist. Führen Sie claude/doctor aus oder lesen Sie die Dokumentation.

• Berechtigungsprobleme: Stellen Sie sicher, dass Sie den Schritt „Wichtige Ersteinrichtung“ ausgeführt haben.

• JSON-Fehler vom Server: Wenn MCP_CLAUDE_DEBUG auf true gesetzt ist, können Fehlermeldungen oder Protokolle die JSON-Analyse von MCP beeinträchtigen. Für den normalen Betrieb auf false setzen.

• ESM-/Importfehler: Stellen Sie sicher, dass Sie Node.js v20 oder höher verwenden.

• Client-Timeouts: Bei lang andauernden Vorgängen sendet der Server alle 15 Sekunden Heartbeat-Nachrichten, um Client-Timeouts zu vermeiden. Sollten dennoch Timeouts auftreten, können Sie das Heartbeat-Intervall mit der Umgebungsvariable MCP_HEARTBEAT_INTERVAL_MS anpassen.

• Netzwerk-/Serverfehler: Der Server verfügt jetzt über eine automatische Wiederholungslogik für vorübergehende Fehler. Sollten weiterhin Probleme auftreten, erhöhen Sie die Werte für MCP_MAX_RETRIES und MCP_RETRY_DELAY_MS .

• Claude CLI-Fallback-Warnung: Wenn Sie eine Warnung sehen, dass die Claude CLI unter ~/.claude/local/claude nicht gefunden wurde, ist das normal. Der Server verwendet den claude -Befehl aus Ihrem Pfad. Sie können die Umgebungsvariable CLAUDE_CLI_PATH setzen, um bei Bedarf den genauen Pfad zu Ihrer Claude CLI-Programmdatei anzugeben.

👨‍💻 Für Entwickler: Lokale Einrichtung und Beitrag

Wenn Sie diesen Server weiterentwickeln oder zu ihm beitragen möchten oder ihn zu Testzwecken aus einem geklonten Repository ausführen möchten, lesen Sie bitte unseren Einrichtungsleitfaden für die lokale Installation und Entwicklung .

💪 Beitragen

Beiträge sind willkommen! Weitere Informationen zur Einrichtung Ihrer Umgebung finden Sie im Handbuch zur lokalen Installation und Entwicklung .

Senden Sie Probleme und Pull-Anfragen an das GitHub-Repository .

⚖️ Lizenz

MIT

💬 Feedback und Support

Wenn Sie auf Probleme stoßen oder Fragen zur Verwendung des Claude Code MCP-Servers haben, gehen Sie bitte wie folgt vor:

1. Lesen Sie den Abschnitt zur Fehlerbehebung oben

2. Senden Sie ein Problem im GitHub-Repository

3. Beteiligen Sie sich an der Diskussion im Abschnitt „Repository-Diskussionen“

Wir freuen uns über Ihr Feedback und Ihren Beitrag zur Verbesserung dieses Tools!