Skip to content
Back to search

claude-code-mcp-enhanced

Enhanced Claude Code MCP server with orchestration capabilities, reliability improvements, and self-contained execution patterns

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/grahama1970--claude-code-mcp-enhanced/badge.svg)](/listings/grahama1970--claude-code-mcp-enhanced)

HTML

<a href="/listings/grahama1970--claude-code-mcp-enhanced"><img src="/api/listings/grahama1970--claude-code-mcp-enhanced/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

You can install and use this MCP server in three different ways:

๐Ÿš€ Method 1: Via GitHub URL (Recommended)

The most flexible method is to install directly from GitHub using `npx`. This always fetches the latest version from the repository.

Add the following to your `.mcp.json` file:

{
  "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"
      }
    }
  }
}

๐Ÿ“ฆ Method 2: Via npm Package

If the package is published to npm, you can install it using the npm package name:

{
  "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"
      }
    }
  }
}

๐Ÿ”ง Method 3: Local Installation

For development or testing purposes, you can run the server from a local installation:

1. Clone the repository:

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

2. Install dependencies and build:

   npm install
   npm run build

3. Configure your `.mcp.json` file to use the local server:

{
  "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"
      }
    }
  }
}

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md ยท README ยท 1,098 lines ยท 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # ๐Ÿค– Claude Code MCP Server
  2. > **Want to get started quickly? Check out our [QUICKSTART.md](QUICKSTART.md) guide!**
  3. > This project is a fork of [steipete/claude-code-mcp](https://github.com/steipete/claude-code-mcp) with enhanced orchestration capabilities, reliability improvements, and additional documentation.
  4. An enhanced Model Context Protocol (MCP) server that allows running Claude Code in one-shot mode with permissions bypassed automatically. This server includes advanced task orchestration capabilities, robust error handling, and a "boomerang pattern" for breaking complex tasks into manageable subtasks.
  5. Did you notice that standard AI assistants sometimes struggle with complex, multi-step edits or operations? This server, with its powerful unified `claude_code` tool and enhanced reliability features, aims to make Claude a more direct and capable agent for your coding tasks.
  6. <img src="assets/claude_code_example_20250515.png" alt="Claude Code Example" width="400">
  7. ## ๐Ÿ” Overview
  8. This MCP server provides powerful tools that can be used by LLMs to interact with Claude Code. When integrated with Claude Desktop or other MCP clients, it allows LLMs to:
  9. - Run Claude Code with all permissions bypassed (using `--dangerously-skip-permissions`)
  10. - Execute Claude Code with any prompt without permission interruptions
  11. - Access file editing capabilities directly
  12. - Execute complex multi-step operations with robust error handling and retries
  13. - Orchestrate tasks through specialized agent roles using the boomerang pattern
  14. - Maintain reliable execution through heartbeat mechanisms to prevent timeouts
  15. ## โœจ Benefits
  16. - **Enhanced Reliability:** Robust error handling, automatic retries, graceful shutdown, and request tracking
  17. - **Task Orchestration:** Complex workflows can be broken down into specialized subtasks
  18. - **Task Automation:** Convert human-readable markdown task lists into executable MCP commands automatically
  19. - **Performance Optimization:** Improved execution with configuration caching and resource efficiency
  20. - **Better Monitoring:** Health check API, detailed error reporting, and comprehensive logging
  21. - **Developer Experience:** Hot reloading of configuration, flexible environment controls, and simplified API
  22. Plus all the standard Claude Code benefits:
  23. - Claude/Windsurf often have trouble editing files. Claude Code is better and faster at it.
  24. - Multiple commands can be queued instead of direct execution. This saves context space so more important information is retained longer.
  25. - File ops, git, or other operations don't need costly models. Claude Code is cost-effective if you sign up for Anthropic Max.
  26. - Claude has wider system access, so when standard assistants are stuck, just ask them to "use claude code" to unblock progress.
  27. ## ๐Ÿ“ Prerequisites
  28. - Node.js v20 or later (Use fnm or nvm to install)
  29. - Claude CLI installed locally (run it and call /doctor) and `-dangerously-skip-permissions` accepted.
  30. ## ๐Ÿ’พ Installation & Usage
  31. You can install and use this MCP server in three different ways:
  32. ### ๐Ÿš€ Method 1: Via GitHub URL (Recommended)
  33. The most flexible method is to install directly from GitHub using `npx`. This always fetches the latest version from the repository.
  34. Add the following to your `.mcp.json` file:
  35. ```json
  36. {
  37. "mcpServers": {
  38. "claude-code-mcp-enhanced": {
  39. "command": "npx",
  40. "args": [
  41. "github:grahama1970/claude-code-mcp-enhanced"
  42. ],
  43. "env": {
  44. "MCP_CLAUDE_DEBUG": "false",
  45. "MCP_HEARTBEAT_INTERVAL_MS": "15000",
  46. "MCP_EXECUTION_TIMEOUT_MS": "1800000"
  47. }
  48. }
  49. }
  50. }
  51. ```
  52. ### ๐Ÿ“ฆ Method 2: Via npm Package
  53. If the package is published to npm, you can install it using the npm package name:
  54. ```json
  55. {
  56. "mcpServers": {
  57. "claude-code-mcp-enhanced": {
  58. "command": "npx",
  59. "args": [
  60. "-y",
  61. "@grahama1970/claude-code-mcp-enhanced@latest"
  62. ],
  63. "env": {
  64. "MCP_CLAUDE_DEBUG": "false",
  65. "MCP_HEARTBEAT_INTERVAL_MS": "15000",
  66. "MCP_EXECUTION_TIMEOUT_MS": "1800000"
  67. }
  68. }
  69. }
  70. }
  71. ```
  72. ### ๐Ÿ”ง Method 3: Local Installation
  73. For development or testing purposes, you can run the server from a local installation:
  74. 1. Clone the repository:
  75. ```bash
  76. git clone https://github.com/grahama1970/claude-code-mcp-enhanced.git
  77. cd claude-code-mcp-enhanced
  78. ```
  79. 2. Install dependencies and build:
  80. ```bash
  81. npm install
  82. npm run build
  83. ```
  84. 3. Configure your `.mcp.json` file to use the local server:
  85. ```json
  86. {
  87. "mcpServers": {
  88. "claude-code-mcp-enhanced": {
  89. "command": "node",
  90. "args": [
  91. "/path/to/claude-code-mcp-enhanced/dist/server.js"
  92. ],
  93. "env": {
  94. "MCP_CLAUDE_DEBUG": "false",
  95. "MCP_HEARTBEAT_INTERVAL_MS": "15000",
  96. "MCP_EXECUTION_TIMEOUT_MS": "1800000"
  97. }
  98. }
  99. }
  100. }
  101. ```
  102. ## ๐Ÿ”‘ Important First-Time Setup: Accepting Permissions
  103. **Before the MCP server can successfully use the `claude_code` tool, you must first run the Claude CLI manually once with the `--dangerously-skip-permissions` flag, login and accept the terms.**
  104. This is a one-time requirement by the Claude CLI.
  105. ```bash
  106. npm install -g @anthropic-ai/claude-code
  107. ```
  108. ```bash
  109. claude --dangerously-skip-permissions
  110. ```
  111. Follow the prompts to accept. Once this is done, the MCP server will be able to use the flag non-interactively.
  112. macOS might ask for various folder permissions the first time the tool runs, and the first run may fail. Subsequent runs will work normally.
  113. ## ๐Ÿ”— Connecting to Your MCP Client
  114. After setting up the server, you need to configure your MCP client (like Cursor, Claude Desktop, or others that use `mcp.json` or `mcp_config.json`).
  115. ### Example MCP Configuration File
  116. Here's an example of how to add the Claude Code MCP server to your `.mcp.json` file:
  117. ```json
  118. {
  119. "mcpServers": {
  120. "Local MCP Server": {
  121. "type": "stdio",
  122. "command": "node",
  123. "args": [
  124. "dist/server.js"
  125. ],
  126. "env": {
  127. "MCP_USE_ROOMODES": "true",
  128. "MCP_WATCH_ROOMODES": "true",
  129. "MCP_CLAUDE_DEBUG": "false"
  130. }
  131. },
  132. "other-services": {
  133. // Your other MCP services here
  134. }
  135. }
  136. }
  137. ```
  138. ### MCP Configuration Locations
  139. The configuration is typically done in a JSON file. The name and location can vary depending on your client.
  140. #### Cursor
  141. Cursor uses `mcp.json`.
  142. - **macOS:** `~/.cursor/mcp.json`
  143. - **Windows:** `%APPDATA%\\Cursor\\mcp.json`
  144. - **Linux:** `~/.config/cursor/mcp.json`
  145. #### Windsurf
  146. Windsurf users use `mcp_config.json`
  147. - **macOS:** `~/.codeium/windsurf/mcp_config.json`
  148. - **Windows:** `%APPDATA%\\Codeium\\windsurf\\mcp_config.json`
  149. - **Linux:** `~/.config/.codeium/windsurf/mcp_config.json`
  150. (Note: In some mixed setups, if Cursor is also installed, these clients might fall back to using Cursor's `~/.cursor/mcp.json` path. Prioritize the Codeium-specific paths if using the Codeium extension.)
  151. Create this file if it doesn't exist.
  152. ## ๐Ÿ› ๏ธ Tools Provided
  153. This server exposes three primary tools:
  154. ### `claude_code` ๐Ÿ’ฌ
  155. Executes a prompt directly using the Claude Code CLI with `--dangerously-skip-permissions`.
  156. **Arguments:**
  157. - `prompt` (string, required): The prompt to send to Claude Code.
  158. - `workFolder` (string, optional): The working directory for the Claude CLI execution, required when using file operations or referencing any file.
  159. - `parentTaskId` (string, optional): ID of the parent task that created this task (for task orchestration/boomerang).
  160. - `returnMode` (string, optional): How results should be returned: 'summary' (concise) or 'full' (detailed). Defaults to 'full'.
  161. - `taskDescription` (string, optional): Short description of the task for better organization and tracking in orchestrated workflows.
  162. - `mode` (string, optional): When MCP_USE_ROOMODES=true, specifies the Roo mode to use (e.g., "boomerang-mode", "coder", "designer", etc.).
  163. ### `health` ๐Ÿฉบ
  164. Returns health status, version information, and current configuration of the Claude Code MCP server.
  165. **Example Health Check Request:**
  166. ```json
  167. {
  168. "toolName": "claude_code:health",
  169. "arguments": {}
  170. }
  171. ```
  172. **Example Response:**
  173. ```json
  174. {
  175. "status": "ok",
  176. "version": "1.12.0",
  177. "claudeCli": {
  178. "path": "claude",
  179. "status": "available"
  180. },
  181. "config": {
  182. "debugMode": true,
  183. "heartbeatIntervalMs": 15000,
  184. "executionTimeoutMs": 1800000,
  185. "useRooModes": true,
  186. "maxRetries": 3,
  187. "retryDelayMs": 1000
  188. },
  189. "system": {
  190. "platform": "linux",
  191. "release": "6.8.0-57-generic",
  192. "arch": "x64",
  193. "cpus": 16,
  194. "memory": {
  195. "total": "32097MB",
  196. "free": "12501MB"
  197. },
  198. "uptime": "240 minutes"
  199. },
  200. "timestamp": "2025-05-15T18:30:00.000Z"
  201. }
  202. ```
  203. ### `convert_task_markdown` ๐Ÿ“‹
  204. Converts markdown task files into Claude Code MCP-compatible JSON format.
  205. **Arguments:**
  206. - `markdownPath` (string, required): Path to the markdown task file to convert.
  207. - `outputPath` (string, optional): Path where to save the JSON output. If not provided, returns the JSON directly.
  208. **Example Request:**
  209. ```json
  210. {
  211. "toolName": "claude_code:convert_task_markdown",
  212. "arguments": {
  213. "markdownPath": "/home/user/tasks/validation.md",
  214. "outputPath": "/home/user/tasks/validation.json"
  215. }
  216. }
  217. ```
  218. ## Example Usage Scenarios
  219. ### 1. Basic Code Operation
  220. **Example MCP Request:**
  221. ```json
  222. {
  223. "toolName": "claude_code:claude_code",
  224. "arguments": {
  225. "prompt": "Your work folder is /path/to/project\n\nRefactor the function foo in main.py to be async.",
  226. "workFolder": "/path/to/project"
  227. }
  228. }
  229. ```
  230. ### 2. Task Orchestration (Boomerang Pattern)
  231. **Parent Task Request:**
  232. ```json
  233. {
  234. "toolName": "claude_code:claude_code",
  235. "arguments": {
  236. "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",
  237. "workFolder": "/path/to/project"
  238. }
  239. }
  240. ```
  241. **Subtask Request (Generated by Parent):**
  242. ```json
  243. {
  244. "toolName": "claude_code:claude_code",
  245. "arguments": {
  246. "prompt": "Your work folder is /path/to/project\n\nCreate database models for the new API endpoint as specified in the requirements.",
  247. "workFolder": "/path/to/project",
  248. "parentTaskId": "task-123",
  249. "returnMode": "summary",
  250. "taskDescription": "Database model creation for API endpoint"
  251. }
  252. }
  253. ```
  254. ### 3. Specialized Mode Request
  255. **Example Using Roo Mode:**
  256. ```json
  257. {
  258. "toolName": "claude_code:claude_code",
  259. "arguments": {
  260. "prompt": "Your work folder is /path/to/project\n\nCreate unit tests for the user authentication module.",
  261. "workFolder": "/path/to/project",
  262. "mode": "coder"
  263. }
  264. }
  265. ```
  266. ## ๐Ÿ”„ Task Converter
  267. The MCP server includes a powerful task converter tool that automatically transforms human-readable markdown task lists into fully executable MCP commands. This intelligent converter bridges the gap between how humans think about tasks and how machines execute them.
  268. ### Complete Workflow
  269. ```mermaid
  270. graph TD
  271. A["๐Ÿ‘ค User"] -->|"Create tasks.md"| B["๐Ÿ“ Multi-Task Markdown"]
  272. A -->|"Prompt Claude"| C["๐Ÿค– Claude Desktop"]
  273. C -->|"Use convert_task_markdown"| D["๐Ÿ”„ Task Converter MCP"]
  274. D -->|"Validate Format"| E{"Format Valid?"}
  275. E -->|"No"| F["๐Ÿ“‘ Error + Fix Instructions"]
  276. F -->|"Return to User"| A
  277. E -->|"Yes"| G["๐Ÿ“‹ MCP Task List"]
  278. G -->|"Execute Task"| H1["โšก Claude Task #1"]
  279. H1 -->|"Complete"| I1["Next Task"]
  280. I1 -->|"Execute Task"| H2["โšก Claude Task #2"]
  281. H2 -->|"Complete"| I2["Next Task"]
  282. I2 -->|"Execute Task"| H3["โšก Claude Task #3"]
  283. H3 -->|"Complete"| I3["More Tasks"]
  284. I3 -->|"Execute Task"| HN["โšก Claude Task #N"]
  285. HN -->|"Complete"| IN["๐ŸŽ‰ All Tasks Completed!"]
  286. style A fill:#4A90E2,stroke:#fff,stroke-width:2px,color:#fff
  287. style C fill:#7C4DFF,stroke:#fff,stroke-width:2px,color:#fff
  288. style D fill:#00BCD4,stroke:#fff,stroke-width:2px,color:#fff
  289. style F fill:#FF5252,stroke:#fff,stroke-width:2px,color:#fff
  290. style G fill:#4CAF50,stroke:#fff,stroke-width:2px,color:#fff
  291. style H1 fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
  292. style H2 fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
  293. style H3 fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
  294. style HN fill:#FFC107,stroke:#fff,stroke-width:2px,color:#fff
  295. style IN fill:#4CAF50,stroke:#fff,stroke-width:2px,color:#fff
  296. ```
  297. ### Workflow Steps
  298. 1. **User adds the MCP** to their configuration file
  299. 2. **User prompts Claude**: "Use convert_task_markdown to execute my tasks.md file"
  300. 3. **The MCP automatically**:
  301. - Loads the markdown file
  302. - Validates the format (returns errors if sections are missing)
  303. - Converts human-readable tasks into exact executable commands
  304. - Returns JSON that Claude Code can execute sequentially
  305. 4. **Claude receives the JSON** and can execute each task using the `claude_code` tool
  306. ### Key Features
  307. - **Automatic Path Resolution:** Converts generic instructions like "change directory to project" into exact executable commands with full paths
  308. - **Smart Command Translation:** Transforms English instructions into precise terminal commands (e.g., "activate the virtual environment" โ†’ `source .venv/bin/activate`)
  309. - **MCP Protocol Compliance:** Ensures all output is 100% compatible with the Model Context Protocol
  310. - **No Ambiguity:** All generated commands use exact paths and executable syntax - no placeholders or generic references
  311. - **Format Validation:** Enforces proper markdown structure and provides helpful error messages for incorrect formatting
  312. - **Real-time Progress Updates:** Provides live progress updates during conversion showing which tasks are being processed
  313. ### Convert Markdown Tasks to MCP Commands
  314. The `convert_task_markdown` tool processes structured markdown files and generates MCP-compatible JSON:
  315. **Request Format:**
  316. ```json
  317. {
  318. "tool": "convert_task_markdown",
  319. "arguments": {
  320. "markdownPath": "/path/to/tasks.md",
  321. "outputPath": "/path/to/output.json" // optional
  322. }
  323. }
  324. ```
  325. **Response Format:**
  326. ```json
  327. {
  328. "tasksCount": 5,
  329. "outputPath": "/path/to/output.json",
  330. "tasks": [
  331. {
  332. "tool": "claude_code",
  333. "arguments": {
  334. "command": "cd /project && source .venv/bin/activate\n\nTASK TYPE: Validation...",
  335. "dangerously_skip_permissions": true,
  336. "timeout_ms": 300000
  337. }
  338. }
  339. // ... more tasks
  340. ]
  341. }
  342. ```
  343. ### Markdown Task File Format
  344. Task markdown files should follow this structure:
  345. ```markdown
  346. # Task 001: Task Title
  347. ## Objective
  348. Clear description of what needs to be accomplished.
  349. ## Requirements
  350. 1. [ ] First requirement
  351. 2. [ ] Second requirement
  352. ## Tasks
  353. ### Module or Component Name
  354. - [ ] Validate `path/to/file.py`
  355. - [ ] Step 1
  356. - [ ] Step 2
  357. - [ ] Step 3
  358. ```
  359. The converter will:
  360. 1. Parse the markdown structure
  361. 2. Extract task metadata and requirements
  362. 3. Generate detailed prompts for each validation task
  363. 4. Include proper working directory setup
  364. 5. Add verification and completion summaries
  365. ### Example Usage
  366. 1. **Create a task file** (`tasks/api_validation.md`):
  367. ```markdown
  368. # Task 001: API Endpoint Validation
  369. ## Objective
  370. Validate all API endpoints work with real database connections.
  371. ## Requirements
  372. 1. [ ] All endpoints must use real database
  373. 2. [ ] No mock data in validation
  374. ## Core API Tasks
  375. - [ ] Validate `api/users.py`
  376. - [ ] Change directory to project and activate .venv
  377. - [ ] Test user creation endpoint
  378. - [ ] Test user retrieval endpoint
  379. - [ ] Verify JSON responses
  380. ```
  381. 2. **Convert to MCP tasks**:
  382. ```json
  383. {
  384. "tool": "convert_task_markdown",
  385. "arguments": {
  386. "markdownPath": "/project/tasks/api_validation.md"
  387. }
  388. }
  389. ```
  390. 3. **The converter shows real-time progress**:
  391. ```
  392. [Progress] Loading task file...
  393. [Progress] Validating markdown structure...
  394. [Progress] Converting 27 validation tasks...
  395. [Progress] Task 1/27: Converting core/constants.py
  396. [Progress] Task 2/27: Converting core/arango_setup.py
  397. ...
  398. [Progress] Conversion complete!
  399. ```
  400. 4. **The converter transforms generic instructions into exact commands**:
  401. - "Change directory to project and activate .venv" becomes:
  402. ```bash
  403. cd /home/user/project && source .venv/bin/activate
  404. ```
  405. - All paths are resolved to absolute paths
  406. - All commands are fully executable with no ambiguity
  407. 5. **Execute the converted tasks**:
  408. The returned tasks contain exact, executable commands and can be executed sequentially using the `claude_code` tool.
  409. ### Complete Example: From Markdown to Execution
  410. **Step 1: User creates a markdown task file** (`project_tasks.md`):
  411. ```markdown
  412. # Task 001: Setup Development Environment
  413. ## Objective
  414. Initialize the development environment with all dependencies.
  415. ## Requirements
  416. 1. [ ] Python 3.11+ installed
  417. 2. [ ] Virtual environment created
  418. ## Tasks
  419. - [ ] Validate `setup.py`
  420. - [ ] Change to project directory
  421. - [ ] Create virtual environment
  422. - [ ] Install dependencies
  423. ```
  424. **Step 2: User prompts Claude**:
  425. ```
  426. Use convert_task_markdown to process /home/user/project_tasks.md
  427. ```
  428. **Step 3: MCP converts and validates**:
  429. - If format is correct: Returns executable JSON
  430. - If format is wrong: Returns error with guidance
  431. **Step 4: Result (if successful)**:
  432. ```json
  433. [
  434. {
  435. "tool": "claude_code",
  436. "arguments": {
  437. "prompt": "cd /home/user/project && python -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt",
  438. "workFolder": "/home/user/project"
  439. }
  440. }
  441. ]
  442. ```
  443. **Step 5: Claude can execute each task sequentially**
  444. ### Format Validation and Error Handling
  445. The task converter enforces a specific markdown structure to ensure consistent and reliable task conversion. If your markdown file is incorrectly formatted, the converter provides helpful error messages:
  446. **Example error response:**
  447. ```json
  448. {
  449. "status": "error",
  450. "error": "Markdown format validation failed",
  451. "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",
  452. "helpUrl": "https://github.com/grahama1970/claude-code-mcp-enhanced/blob/main/README.md#markdown-task-file-format"
  453. }
  454. ```
  455. The validation ensures:
  456. 1. Required sections are present (Title, Objective, Requirements)
  457. 2. Tasks use proper checkbox format
  458. 3. Each task has indented steps
  459. 4. Requirements use checkbox format for consistency
  460. ## ๐Ÿฆš Task Orchestration Patterns
  461. This MCP server supports powerful task orchestration capabilities to handle complex workflows efficiently.
  462. ### Boomerang Pattern (Claude Desktop โŸท Claude Code)
  463. The Boomerang pattern allows Claude Desktop to orchestrate tasks and delegate them to Claude Code. This allows you to:
  464. 1. Break down complex workflows into smaller, manageable subtasks
  465. 2. Pass context from parent tasks to subtasks
  466. 3. Get results back from subtasks to the parent task
  467. 4. Choose between detailed or summarized results
  468. 5. Track and manage progress through structured task lists
  469. ### Boomerang Pattern Visualization
  470. Here's a simple diagram showing how Claude breaks down a recipe task into steps and delegates them to Claude Code:
  471. ```mermaid
  472. graph TB
  473. User("๐Ÿ‘จโ€๐Ÿณ User")
  474. Claude("๐Ÿค– Claude (Parent)")
  475. Code1("๐Ÿง Claude Code")
  476. Code2("๐Ÿง Claude Code")
  477. User-->|"Make chocolate cake"| Claude
  478. Claude-->|"Task 1: Find recipe"| Code1
  479. Code1-->|"Result: Recipe found"| Claude
  480. Claude-->|"Task 2: Convert measurements"| Code2
  481. Code2-->|"Result: Measurements converted"| Claude
  482. Claude-->|"Complete recipe + instructions"| User
  483. ```
  484. In this example:
  485. 1. The user asks Claude to make a chocolate cake recipe
  486. 2. Claude (Parent) breaks this down into separate tasks
  487. 3. Claude delegates "Find recipe" task to Claude Code with a parent task ID
  488. 4. Claude Code returns the recipe information to Claude
  489. 5. Claude delegates "Convert measurements" task to Claude Code
  490. 6. Claude Code returns the converted measurements
  491. 7. Claude combines all results and presents the complete solution to the user
  492. **Simple Task Examples:**
  493. **Task 1 - Find Recipe:**
  494. ```json
  495. {
  496. "toolName": "claude_code:claude_code",
  497. "arguments": {
  498. "prompt": "Search for a classic chocolate cake recipe. Find one with good reviews.",
  499. "parentTaskId": "cake-recipe-123",
  500. "returnMode": "summary",
  501. "taskDescription": "Find Chocolate Cake Recipe"
  502. }
  503. }
  504. ```
  505. **Task 2 - Convert Measurements:**
  506. ```json
  507. {
  508. "toolName": "claude_code:claude_code",
  509. "arguments": {
  510. "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",
  511. "parentTaskId": "cake-recipe-123",
  512. "returnMode": "summary",
  513. "taskDescription": "Convert Recipe Measurements"
  514. }
  515. }
  516. ```
  517. ### How It Works
  518. 1. **Creating a Subtask:**
  519. - Generate a unique task ID in your parent task
  520. - Send a request to the `claude_code` tool with:
  521. - Your specific prompt
  522. - The parent task ID
  523. - A task description
  524. - The desired return mode ('summary' or 'full')
  525. 2. **Receiving Results:**
  526. - The subtask result will include a special marker: `<!-- BOOMERANG_RESULT {...} -->`
  527. - This marker contains JSON with the task metadata
  528. - The parent task can parse this to identify completed subtasks
  529. 3. **Example Workflow with Claude Desktop:**
  530. ```
  531. You: I need to refactor this codebase. It's quite complex.
  532. Claude Desktop: I'll help you with that. Let me break this down into smaller tasks for Claude Code to handle:
  533. 1. First, I'll have Claude Code analyze the codebase structure
  534. 2. Then, I'll have it identify problematic patterns
  535. 3. Finally, I'll ask it to generate a refactoring plan
  536. [Claude Desktop sends a request to the claude_code tool with parentTaskId="task1" and returnMode="summary"]
  537. [Claude Code analyzes the codebase and returns a summary with the BOOMERANG_RESULT marker]
  538. Claude Desktop: Based on Claude Code's analysis, here are the key issues found:
  539. - Duplicate code in modules X and Y
  540. - Poor separation of concerns in module Z
  541. - Inconsistent naming conventions
  542. Now I'll ask Claude Code to suggest specific refactorings...
  543. ```
  544. This approach is particularly useful for complex tasks that require deep analysis or multiple steps.
  545. ### Comprehensive Task List Management Example
  546. Here's a detailed example of using Claude with the Claude Code MCP to manage and execute a structured task list:
  547. #### 1. Setting Up Task List Structure
  548. First, create a task list file (e.g., `tasks.md`) with the following structure:
  549. ```markdown
  550. # Project Task List
  551. ## Parent Task: API Optimization Project
  552. - [ ] Optimize API performance for high-traffic endpoints
  553. - [ ] Analyze current API performance and identify bottlenecks
  554. - [ ] Implement database query optimization for user endpoints
  555. - [ ] Add Redis caching for frequently accessed data
  556. - [ ] Set up performance monitoring
  557. ## Assumptions and Decisions
  558. - [2025-05-15] Assumption: Redis is available in the infrastructure
  559. - [2025-05-15] Decision: Focus on user endpoints first (Rationale: Highest traffic area)
  560. ## Relevant Files
  561. - `src/controllers/userController.js`: User API endpoints
  562. - `src/services/userService.js`: Business logic for user operations
  563. ## Improvement Notes
  564. - Pattern identified: N+1 query issue in user listing endpoint
  565. - Automation opportunity: Add caching automatically for all get-by-id endpoints
  566. ```
  567. #### 2. Executing the Task List
  568. Claude can now systematically work through the tasks using Claude Code:
  569. ```
  570. You: Please help me execute the task list in tasks.md, starting with the first subtask.
  571. 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.
  572. [Claude uses claude_code to read the task list]
  573. I see the first subtask is "Analyze current API performance and identify bottlenecks". I'll execute this task now using Claude Code.
  574. [Claude sends the following request to claude_code]:
  575. {
  576. "toolName": "claude_code",
  577. "arguments": {
  578. "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:",
  579. "workFolder": "/path/to/project"
  580. }
  581. }
  582. [Claude Code executes the analysis task and returns results]
  583. Great! Claude Code has completed the analysis. Here's what was found:
  584. 1. Main performance bottlenecks identified:
  585. - N+1 query problem in the user listing endpoint
  586. - Missing indexes on frequently queried fields
  587. - No caching for repetitive data lookups
  588. 2. Recommendations:
  589. - Add eager loading for user relationships
  590. - Create database indexes for user_id and email fields
  591. - Implement Redis caching with a 5-minute TTL
  592. Let me update the task list to mark this task as complete and proceed to the next one.
  593. [Claude uses claude_code to update the task list]:
  594. {
  595. "toolName": "claude_code",
  596. "arguments": {
  597. "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",
  598. "workFolder": "/path/to/project"
  599. }
  600. }
  601. [Claude Code updates the task list and marks the first subtask complete]
  602. 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".
  603. Would you like me to proceed with this next subtask now?
  604. ```
  605. #### 3. Continuing with Subsequent Tasks
  606. After getting confirmation, Claude would continue with the next subtask:
  607. ```
  608. You: Yes, please proceed with the next subtask.
  609. 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.
  610. [Claude sends the following request to claude_code]:
  611. {
  612. "toolName": "claude_code",
  613. "arguments": {
  614. "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:",
  615. "workFolder": "/path/to/project"
  616. }
  617. }
  618. [Claude Code implements the optimizations and returns results]
  619. Excellent! The database query optimizations have been successfully implemented. Here's a summary:
  620. 1. Changes made:
  621. - Added eager loading in userController.js for user relationships
  622. - Created new database indexes for user_id and email fields
  623. - Refactored list query to use a single efficient JOIN statement
  624. - Added pagination to prevent large result sets
  625. 2. Performance results:
  626. - User listing endpoint response time reduced by 68%
  627. - Database query count reduced from 25+ to 3 for typical requests
  628. Let me update the task list again to reflect this progress.
  629. [Claude uses claude_code to update the task list again]:
  630. {
  631. "toolName": "claude_code",
  632. "arguments": {
  633. "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",
  634. "workFolder": "/path/to/project"
  635. }
  636. }
  637. [Claude Code updates the task list and marks the second subtask complete]
  638. 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?
  639. ```
  640. This structured approach enables Claude to systematically work through complex task lists while maintaining clear documentation of progress, assumptions, and relevant files throughout the process.
  641. ### ๐ŸŽญ Self-Orchestration Pattern (Claude Code as Orchestrator)
  642. While Claude Desktop is often used as the parent agent, you can use Claude Code itself as both the orchestrator and executor. This approach creates a self-contained system where Claude Code manages its own task orchestration, without requiring Claude Desktop.
  643. ```mermaid
  644. graph TB
  645. User("๐Ÿ‘จโ€๐Ÿ’ป User")
  646. ClaudeCode("๐Ÿค– Claude Code\nOrchestrator")
  647. ClaudeCodeSubtask1("โš™๏ธ Claude Code\nSubtask 1")
  648. ClaudeCodeSubtask2("โš™๏ธ Claude Code\nSubtask 2")
  649. User-->|"Complex project request"| ClaudeCode
  650. ClaudeCode-->|"1. Plans tasks"| ClaudeCode
  651. ClaudeCode-->|"2. Executes subtask 1"| ClaudeCodeSubtask1
  652. ClaudeCodeSubtask1-->|"3. Returns result"| ClaudeCode
  653. ClaudeCode-->|"4. Executes subtask 2"| ClaudeCodeSubtask2
  654. ClaudeCodeSubtask2-->|"5. Returns result"| ClaudeCode
  655. ClaudeCode-->|"6. Final solution"| User
  656. ```
  657. #### Implementation Steps
  658. 1. **Create an entry script** that initializes your task structure and launches Claude Code as the orchestrator
  659. 2. **Design a task data structure** (typically in JSON format) that tracks task status and dependencies
  660. 3. **Create task executor scripts** to process individual tasks and update task state
  661. #### Key Benefits of Self-Orchestration
  662. 1. **Self-contained**: No external orchestrator (like Claude Desktop) required
  663. 2. **Persistent state**: All task information is stored in JSON files
  664. 3. **Error recovery**: Can resume from the last successful task if interrupted
  665. 4. **Simplified dependency management**: Single system manages all Claude Code interactions
  666. 5. **Shell script automation**: Easily integrated into CI/CD pipelines or automated workflows
  667. For a detailed implementation guide with example scripts and task structures, see [Self-Orchestration with Claude Code](./claude-code-orchestrator.md).
  668. ## ๐Ÿ‘“ Roo Modes Integration
  669. This MCP server supports integration with specialized modes through a `.roomodes` configuration file. When enabled, you can specify which mode to use for each task, allowing for specialized behavior.
  670. ### How to Use Roo Modes
  671. 1. **Enable Roo Mode Support:**
  672. - Set the environment variable `MCP_USE_ROOMODES=true` in your MCP configuration
  673. - Create a `.roomodes` file in the root directory of your MCP server
  674. - Optionally enable hot-reloading with `MCP_WATCH_ROOMODES=true` to automatically reload the configuration when the file changes
  675. 2. **Configure Your Modes:**
  676. - The `.roomodes` file should contain a JSON object with a `customModes` array
  677. - Each mode should have a `slug`, `name`, `roleDefinition`, and optionally an `apiConfiguration` with a `modelId`
  678. 3. **Using a Mode:**
  679. - When making requests to the `claude_code` tool, include a `mode` parameter with the slug of the desired mode
  680. - The MCP server will automatically apply the role definition and model configuration
  681. 4. **Example .roomodes File:**
  682. ```json
  683. {
  684. "customModes": [
  685. {
  686. "slug": "coder",
  687. "name": "๐Ÿ’ป Coder",
  688. "roleDefinition": "You are a coding specialist who writes clean, efficient code.",
  689. "apiConfiguration": {
  690. "modelId": "claude-3-sonnet-20240229"
  691. }
  692. },
  693. {
  694. "slug": "designer",
  695. "name": "๐ŸŽจ Designer",
  696. "roleDefinition": "You are a design specialist focused on UI/UX solutions."
  697. }
  698. ]
  699. }
  700. ```
  701. 5. **Environment Configuration Example:**
  702. ```json
  703. {
  704. "mcpServers": {
  705. "claude-code-mcp-enhanced": {
  706. "command": "npx",
  707. "args": ["github:grahama1970/claude-code-mcp-enhanced"],
  708. "env": {
  709. "MCP_USE_ROOMODES": "true",
  710. "MCP_WATCH_ROOMODES": "true",
  711. "MCP_CLAUDE_DEBUG": "false"
  712. }
  713. }
  714. }
  715. }
  716. ```
  717. 6. **Making Requests with Modes:**
  718. ```json
  719. {
  720. "toolName": "claude_code:claude_code",
  721. "arguments": {
  722. "prompt": "Your work folder is /path/to/project\n\nCreate unit tests for the user authentication module.",
  723. "workFolder": "/path/to/project",
  724. "mode": "coder"
  725. }
  726. }
  727. ```
  728. ### Key Features of Roo Modes:
  729. - **Specialized Behaviors**: Different modes can have different system prompts and model configurations
  730. - **Hot Reloading**: When `MCP_WATCH_ROOMODES=true`, the server automatically reloads the configuration when the `.roomodes` file changes
  731. - **Performance**: The server caches the roomodes configuration for better performance
  732. - **Fallback**: If a mode isn't found or roomodes are disabled, the server continues with default behavior
  733. ## ๐Ÿ› ๏ธ Enhanced Reliability Features
  734. This server includes several improvements to enhance reliability and performance:
  735. ### 1. Heartbeat & Timeout Prevention
  736. To prevent client-side timeouts during long-running operations:
  737. - Added a configurable heartbeat mechanism that sends progress updates every 15 seconds
  738. - Implemented execution time tracking and reporting
  739. - Added configurable timeout parameters through environment variables
  740. ### 2. Robust Error Handling with Retries
  741. Added intelligent retry logic for transient errors:
  742. - Implemented automatic retry with configurable parameters
  743. - Added error classification to identify retryable issues
  744. - Created detailed error reporting and tracking
  745. ### 3. Request Tracking System
  746. Implemented comprehensive request lifecycle management:
  747. - Added unique IDs for each request
  748. - Created tracking for in-progress requests
  749. - Ensured proper cleanup on completion or failure
  750. ### 4. Graceful Shutdown
  751. Added proper process termination handling:
  752. - Implemented signal handlers for SIGINT and SIGTERM
  753. - Added tracking for in-progress requests
  754. - Created wait logic for clean shutdown
  755. - Ensured proper cleanup on exit
  756. ### 5. Configuration Caching and Hot Reloading
  757. Added performance optimization for configuration:
  758. - Implemented caching for roomodes file
  759. - Added automatic invalidation based on file changes
  760. - Created configurable file watching mechanism
  761. ## โš™๏ธ Configuration Options
  762. The server's behavior can be customized using these environment variables:
  763. | Variable | Description | Default |
  764. |----------|-------------|---------|
  765. | `CLAUDE_CLI_PATH` | Absolute path to the Claude CLI executable | Auto-detect |
  766. | `MCP_CLAUDE_DEBUG` | Enable verbose debug logging | `false` |
  767. | `MCP_HEARTBEAT_INTERVAL_MS` | Interval between progress reports | 15000 (15s) |
  768. | `MCP_EXECUTION_TIMEOUT_MS` | Timeout for CLI execution | 1800000 (30m) |
  769. | `MCP_MAX_RETRIES` | Maximum retry attempts for transient errors | 3 |
  770. | `MCP_RETRY_DELAY_MS` | Delay between retry attempts | 1000 (1s) |
  771. | `MCP_USE_ROOMODES` | Enable Roo modes integration | `false` |
  772. | `MCP_WATCH_ROOMODES` | Auto-reload .roomodes on changes | `false` |
  773. These can be set in your shell environment or within the `env` block of your `mcp.json` server configuration.
  774. ## ๐Ÿ“ธ Visual Examples
  775. Here are some visual examples of the server in action:
  776. <img src="assets/claude_tool_git_example.png" alt="Claude Tool Git Example" width="50%">
  777. <img src="assets/additional_claude_screenshot.png" alt="Additional Claude Screenshot" width="50%">
  778. <img src="assets/cursor-screenshot.png" alt="Cursor Screenshot" width="50%">
  779. ### Fixing ESLint Setup
  780. Here's an example of using the Claude Code MCP tool to interactively fix an ESLint setup by deleting old configuration files and creating a new one:
  781. <img src="assets/eslint_example.png" alt="ESLint file operations example" width="50%">
  782. ### Listing Files Example
  783. Here's an example of the Claude Code tool listing files in a directory:
  784. <img src="assets/file_list_example.png" alt="File listing example" width="50%">
  785. ### Complex Multi-Step Operations
  786. This example illustrates `claude_code` handling a more complex, multi-step task, such as preparing a release by creating a branch, updating multiple files (`package.json`, `CHANGELOG.md`), committing changes, and initiating a pull request, all within a single, coherent operation.
  787. <img src="assets/claude_code_multistep_example.png" alt="Claude Code multi-step example" width="50%">
  788. ### GitHub Actions Workflow Correction
  789. <img src="assets/github_actions_fix_example.png" alt="GitHub Actions workflow fix example" width="50%">
  790. ## ๐ŸŽฏ Key Use Cases
  791. This server, through its unified `claude_code` tool, unlocks a wide range of powerful capabilities by giving your AI direct access to the Claude Code CLI. Here are some examples of what you can achieve:
  792. 1. **Code Generation, Analysis & Refactoring:**
  793. - `"Generate a Python script to parse CSV data and output JSON."`
  794. - `"Analyze my_script.py for potential bugs and suggest improvements."`
  795. 2. **File System Operations (Create, Read, Edit, Manage):**
  796. - **Creating Files:** `"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"`
  797. - **Editing Files:** `"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'."`
  798. - **Moving/Copying/Deleting:** `"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'."`
  799. 3. **Version Control (Git):**
  800. - `"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."`
  801. 4. **Running Terminal Commands:**
  802. - `"Your work folder is /Users/steipete/my_project/frontend\n\nRun the command 'npm run build'."`
  803. - `"Open the URL https://developer.mozilla.org in my default web browser."`
  804. 5. **Web Search & Summarization:**
  805. - `"Search the web for 'benefits of server-side rendering' and provide a concise summary."`
  806. 6. **Complex Multi-Step Workflows:**
  807. - Automate version bumps, update changelogs, and tag 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."`
  808. 7. **Repairing Files with Syntax Errors:**
  809. - `"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."`
  810. 8. **Interacting with GitHub (e.g., Creating a Pull Request):**
  811. - `"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.'"`
  812. 9. **Interacting with GitHub (e.g., Checking PR CI Status):**
  813. - `"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."`
  814. **CRITICAL: Remember to provide Current Working Directory (CWD) context in your prompts for file system or git operations (e.g., `"Your work folder is /path/to/project\n\n...your command..."`).**
  815. ## ๐Ÿ”ง Troubleshooting
  816. - **"Command not found" (claude-code-mcp):** If installed globally, ensure the npm global bin directory is in your system's PATH. If using `npx`, ensure `npx` itself is working.
  817. - **"Command not found" (claude or ~/.claude/local/claude):** Ensure the Claude CLI is installed correctly. Run `claude/doctor` or check its documentation.
  818. - **Permissions Issues:** Make sure you've run the "Important First-Time Setup" step.
  819. - **JSON Errors from Server:** If `MCP_CLAUDE_DEBUG` is `true`, error messages or logs might interfere with MCP's JSON parsing. Set to `false` for normal operation.
  820. - **ESM/Import Errors:** Ensure you are using Node.js v20 or later.
  821. - **Client Timeouts:** For long-running operations, the server sends heartbeat messages every 15 seconds to prevent client timeouts. If you still experience timeouts, you can adjust the heartbeat interval using the `MCP_HEARTBEAT_INTERVAL_MS` environment variable.
  822. - **Network/Server Errors:** The server now includes automatic retry logic for transient errors. If you're still experiencing issues, try increasing the `MCP_MAX_RETRIES` and `MCP_RETRY_DELAY_MS` values.
  823. - **Claude CLI Fallback Warning:** If you see a warning about Claude CLI not found at ~/.claude/local/claude, this is normal. The server is falling back to using the `claude` command from your PATH. You can set the `CLAUDE_CLI_PATH` environment variable to specify the exact path to your Claude CLI executable if needed.
  824. ## ๐Ÿ‘จโ€๐Ÿ’ป For Developers: Local Setup & Contribution
  825. If you want to develop or contribute to this server, or run it from a cloned repository for testing, please see our [Local Installation & Development Setup Guide](./docs/local_install.md).
  826. ## ๐Ÿ’ช Contributing
  827. Contributions are welcome! Please refer to the [Local Installation & Development Setup Guide](./docs/local_install.md) for details on setting up your environment.
  828. Submit issues and pull requests to the [GitHub repository](https://github.com/grahama1970/claude-code-mcp-enhanced).
  829. ## โš–๏ธ License
  830. MIT
  831. ## ๐Ÿ’ฌ Feedback and Support
  832. If you encounter any issues or have questions about using the Claude Code MCP server, please:
  833. 1. Check the Troubleshooting section above
  834. 2. Submit an issue on the [GitHub repository](https://github.com/grahama1970/claude-code-mcp-enhanced)
  835. 3. Join the discussion in the repository discussions section
  836. We appreciate your feedback and contributions to making this tool better!

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If itโ€™s helped, pass it on.