Unrestricted Development MCP Server

# Unrestricted Dev MCP Server **Supercharge Claude Code with Enterprise-Grade Development Tools** An MCP (Model Context Protocol) server that extends Claude Code's native capabilities with production-ready tools for database operations, container orchestration, advanced networking, and full-stack development workflows. --- ## Table of Contents - [Overview](#overview) - [The Problem: Claude Code's Limitations](#the-problem-claude-codes-limitations) - [The Solution: Agentic Development Tools](#the-solution-agentic-development-tools) - [Current Tools](#current-tools) - [Installation & Setup](#installation--setup) - [Usage Examples](#usage-examples) - [Roadmap: Next-Generation Agentic Features](#roadmap-next-generation-agentic-features) - [Architecture](#architecture) --- ## Overview Claude Code is powerful for scaffolding and basic development tasks, but it lacks critical tools for **real-world software development**: - ❌ Limited database interaction (no structured MongoDB, PostgreSQL, Redis tools) - ❌ No container orchestration (Docker, Kubernetes) - ❌ No advanced network diagnostics - ❌ No process/service management - ❌ No structured testing frameworks - ❌ Limited API testing capabilities - ❌ No performance monitoring This MCP server fills those gaps and goes further, enabling Claude Code to be a **truly autonomous development agent** that can: ✅ Design, develop, test, deploy, and monitor applications end-to-end ✅ Interact with MongoDB databases (19 tools: CRUD, aggregation, indexes, validation) ✅ Orchestrate multi-container applications (Docker & Docker Compose) ✅ Debug network issues and test APIs (HTTP requests, ping, DNS, port checks) ✅ Manage Git workflows with structured responses ✅ Execute shell commands with sudo and streaming support --- ## The Problem: Claude Code's Limitations ### What Claude Code Has (Built-in Tools) Claude Code comes with these native capabilities: **File Operations** - Read, Edit, Write, MultiEdit, Glob - ✅ Excellent - no gaps here, works great for code manipulation **Shell** - Bash (persistent shell with timeout support) - ⚠️ Generic command execution - no structured outputs or typed responses **Search** - Grep (regex search), Glob (pattern matching) - ✅ Excellent - fast codebase search and file discovery **Version Control** - Via Bash (git commands) - ⚠️ No structured git workflows - just raw command execution **Web** - WebFetch (retrieve content), WebSearch (search the web) - ⚠️ Basic HTTP only - no authentication, no API testing, no structured requests **Notebooks** - NotebookRead, NotebookEdit - ✅ Good for data science workflows **Task Management** - TodoWrite, TodoRead - ✅ Good for planning and tracking progress **Agents** - Task (launch autonomous agents) - ✅ Excellent for complex multi-step searches ### Critical Gaps for Production Development #### 1. **Database Operations** ❌ **Problem**: No way to interact with databases without writing custom scripts. **Real-world scenario**: ``` Developer: "Set up a MongoDB database with user authentication" Claude Code: *Creates boilerplate code but can't actually:* - Connect to MongoDB - Create databases/collections - Insert test data - Verify schema - Check indexes ``` #### 2. **Container Orchestration** ❌ **Problem**: No Docker tools means no modern dev workflows. **Real-world scenario**: ``` Developer: "Set up a microservices architecture with Docker Compose" Claude Code: *Creates docker-compose.yml but can't:* - Build images - Start containers - Check logs - Debug networking issues - Inspect container state ``` #### 3. **API Testing & Validation** ❌ **Problem**: Can scaffold API code but can't test it. **Real-world scenario**: ``` Developer: "Build a REST API and test all endpoints" Claude Code: *Writes the API but can't:* - Make structured HTTP requests - Validate response schemas - Run integration tests - Check API health - Monitor performance ``` #### 4. **Process & Service Management** ❌ **Problem**: Can't manage long-running processes or system services. **Real-world scenario**: ``` Developer: "Deploy this app with PM2" Claude Code: *Can't:* - Start/stop PM2 processes - Check process status - View logs - Restart on failure - Monitor resource usage ``` #### 5. **Advanced Network Diagnostics** ❌ **Problem**: Limited to basic WebFetch - no network troubleshooting. **Real-world scenario**: ``` Developer: "Why can't my app connect to the database?" Claude Code: *Can't:* - Ping hosts - Check port availability - Trace network routes - Perform DNS lookups - Diagnose firewall issues ``` --- ## The Solution: Agentic Development Tools This MCP server transforms Claude Code from a **scaffolding assistant** into a **full-stack autonomous developer**. ### Design Philosophy **Principle 1: Structured Over Generic** - Instead of `bash: docker ps`, provide `docker_ps()` with typed responses - Instead of `bash: curl`, provide `http_request()` with parsed JSON - Instead of `bash: mongo`, provide `mongodb_query()` with schema validation **Principle 2: Safe by Default** - All destructive operations require explicit parameters - Database operations support dry-run mode - Container operations include rollback capabilities - Network tools respect timeouts and rate limits **Principle 3: Autonomous-First** - Tools return structured data Claude can reason about - Comprehensive error messages with recovery suggestions - Built-in validation and health checks - Support for complex multi-step workflows --- ## Current Tools ### 🗄️ Filesystem Tools *Enhanced versions of Claude Code's built-in file operations with additional safety features.* - `fs_read_file` - Read files with encoding support - `fs_write_file` - Write files with automatic directory creation - `fs_append_file` - Append to files - `fs_delete_file` - Delete files (safe - no wildcards) - `fs_list_directory` - List directory contents with filters - `fs_create_directory` - Create directories recursively - `fs_delete_directory` - Delete directories with safety checks - `fs_get_file_info` - Get file metadata (size, permissions, timestamps) - `fs_move_file` - Move/rename files - `fs_copy_file` - Copy files **Why not just use Claude Code's built-in file tools?** - These integrate with other MCP tools (e.g., Docker volume inspection) - Consistent error handling across all tools - Additional safety validations --- ### 💻 Shell Execution Tools *Structured shell execution with streaming support.* - `shell_execute` - Execute shell commands with full system access - `shell_execute_streaming` - Execute long-running commands with real-time output **Features:** - Sudo support for privileged operations - Working directory control - Environment variable injection - Configurable timeouts - Streaming output for long-running processes **Why not just use Bash?** - Explicit sudo support (safer than inline sudo) - Streaming output for long builds - Structured error responses - Environment variable management --- ### 🐳 Docker Tools (18 tools) *Complete Docker and Docker Compose orchestration.* **Container Management:** - `docker_ps` - List containers with filtering - `docker_logs` - Fetch container logs (with follow, tail, timestamps) - `docker_exec` - Execute commands inside containers - `docker_start` - Start containers - `docker_stop` - Stop containers (with grace period) - `docker_restart` - Restart containers - `docker_rm` - Remove containers (with force/volume options) - `docker_inspect` - Inspect containers, images, networks, volumes **Image Management:** - `docker_build` - Build images from Dockerfiles - `docker_images` - List images with filtering - `docker_pull` - Pull images from registries - `docker_rmi` - Remove images **Docker Compose:** - `docker_compose_up` - Start multi-container applications - `docker_compose_down` - Stop and remove containers - `docker_compose_ps` - List services - `docker_compose_logs` - View service logs **Use Cases:** ``` ✅ "Set up a MERN stack with Docker" ✅ "Debug why my container keeps restarting" ✅ "Build and deploy this microservices app" ✅ "Check the logs for the last 100 lines of the API service" ``` --- ### 🌐 Network & HTTP Tools (9 tools) *Advanced networking and API testing capabilities.* **HTTP Operations:** - `http_request` - Full HTTP client (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS) - Bearer, Basic, API Key authentication - Custom headers - JSON/text/binary responses - Timeout control - `http_download` - Download files with progress tracking - `http_health_check` - Health check endpoints with status validation **Network Diagnostics:** - `network_ping` - Ping hosts (connectivity + latency) - `network_port_check` - Check if ports are open - `network_dns_lookup` - DNS queries (A, AAAA, MX, TXT, NS, CNAME, SOA, PTR) - `network_curl` - Advanced curl with custom options - `network_netstat` - List network connections and listening ports - `network_traceroute` - Trace network routes **Use Cases:** ``` ✅ "Test all API endpoints and validate responses" ✅ "Why can't my app connect to the database on port 5432?" ✅ "Download this dataset and verify the checksum" ✅ "Check if the deployment is healthy across all regions" ``` --- ### 🔀 Git Tools (21 tools) *Comprehensive version control workflows.* **Repository Operations:** - `git_status` - Working tree status - `git_add` - Stage files - `git_commit` - Create commits - `git_diff` - Show changes - `git_log` - Commit history **Branching & Merging:** - `git_branch` - List/create/delete branches - `git_checkout` - Switch branches - `git_merge` - Merge branches - `git_rebase` - Rebase branches **Remote Operations:** - `git_clone` - Clone repositories - `git_fetch` - Fetch from remote - `git_pull` - Pull changes - `git_push` - Push changes - `git_remote` - Manage remotes **Advanced:** - `git_stash` - Stash changes - `git_reset` - Reset to commit - `git_revert` - Revert commits - `git_tag` - Manage tags - `git_show` - Show commit details - `git_config` - Git configuration - `git_init` - Initialize repository **Why not just use Bash git?** - Structured responses (parsed output) - Better error messages - Prevents common mistakes (force push to main) - Integrates with workflows (auto-commit after fixes) --- ### 🗄️ MongoDB Tools (19 tools) ✅ FULLY IMPLEMENTED *Complete database interaction with MongoDB Atlas and local instances.* **Connection & Discovery:** - `mongodb_connect` - Connect to MongoDB and verify connection - `mongodb_list_databases` - List all databases with sizes - `mongodb_list_collections` - List collections in a database **Collection Management:** - `mongodb_create_collection` - Create collections with JSON Schema validation - `mongodb_drop_collection` - Drop collections safely **Insert Operations:** - `mongodb_insert_one` - Insert single document - `mongodb_insert_many` - Insert multiple documents (ordered/unordered) **Query Operations:** - `mongodb_find` - Query with filtering, projection, sorting, limit, skip - `mongodb_find_one` - Find single document - `mongodb_count` - Count documents with filtering **Update Operations:** - `mongodb_update_one` - Update single document with upsert support - `mongodb_update_many` - Update multiple documents **Delete Operations:** - `mongodb_delete_one` - Delete single document - `mongodb_delete_many` - Delete multiple documents **Advanced:** - `mongodb_aggregate` - Run aggregation pipelines ($match, $group, $sort, $project, etc.) - `mongodb_create_index` - Create indexes (unique, sparse, TTL) - `mongodb_list_indexes` - List all indexes with metadata - `mongodb_drop_index` - Drop indexes safely - `mongodb_stats` - Get collection and database statistics **Use Cases:** ``` ✅ "Set up a MongoDB database with user authentication schema" ✅ "Query all active users and group by city" ✅ "Create indexes for email and username fields" ✅ "Run aggregation pipeline to calculate statistics" ✅ "Backup data, drop collection, and restore" ``` --- ### ⚙️ Process Management Tools (Coming Next) *Currently stubbed - planned implementation.* **Planned Features:** - `process_list` - List running processes - `process_start` - Start processes - `process_stop` - Stop processes - `process_restart` - Restart processes - `process_logs` - View process logs - `process_monitor` - Monitor resource usage --- ## Installation & Setup ### Prerequisites - Node.js 18+ - Claude Code CLI installed - Unix-like system (Linux/macOS) ### Quick Start 1. **Clone the repository:** ```bash git clone https://github.com/yourusername/mcp-unrestricted-dev-server.git cd mcp-unrestricted-dev-server ``` 2. **Install dependencies:** ```bash npm install ``` 3. **Build the project:** ```bash npm run build ``` 4. **Configure Claude Code:** **Option A: CLI (Recommended)** ```bash claude mcp add unrestricted-dev --scope user --transport stdio \ node /absolute/path/to/mcp2/build/index.js ``` **Option B: Manual Config** Edit `~/.claude.json`: ```json { "mcpServers": { "unrestricted-dev": { "type": "stdio", "command": "node", "args": ["/absolute/path/to/mcp2/build/index.js"] } } } ``` 5. **Verify installation:** ```bash claude mcp list ``` You should see `unrestricted-dev` in the list. 6. **Test in Claude Code:** ```bash claude ``` Inside Claude Code: ``` /mcp ``` You should see: `⎿ • unrestricted-dev: connected` ### Development Workflow When making changes to the MCP server: 1. **Rebuild:** ```bash npm run build ``` 2. **Restart Claude Code** (quit completely and relaunch) 3. **Verify connection:** ``` /mcp ``` **Pro tip:** Use the MCP Inspector for faster testing: ```bash npx @modelcontextprotocol/inspector node build/index.js ``` This opens a web UI at `http://localhost:6274` for testing tools without restarting Claude Code. --- ## Usage Examples ### Example 1: Full-Stack Application Setup **Goal:** Set up a MERN stack with Docker, MongoDB, and test the API. ``` User: "Create a MERN stack application with Docker. Set up MongoDB, create a users collection, and test the API endpoints." Claude Code: 1. ✅ Creates application structure (built-in file tools) 2. ✅ Writes Dockerfile and docker-compose.yml (built-in Write) 3. ✅ Builds Docker images (docker_build) 4. ✅ Starts containers (docker_compose_up) 5. ✅ Connects to MongoDB (mongodb_connect) 6. ✅ Creates users collection with schema (mongodb_create_collection) 7. ✅ Inserts test data (mongodb_insert) 8. ✅ Tests API endpoints (http_request) 9. ✅ Validates response schemas (structured parsing) 10. ✅ Commits everything to git (git_add, git_commit) ``` **Without this MCP server:** ``` Claude Code: 1. ✅ Creates files 2. ❌ Tells you to manually run: docker-compose up 3. ❌ Tells you to manually run: mongo shell commands 4. ❌ Tells you to manually test with curl 5. ❌ Can't verify anything actually works ``` --- ### Example 2: Debugging Network Issues **Goal:** Diagnose why an app can't connect to a database. ``` User: "My Node.js app can't connect to MongoDB on port 27017. Debug the issue." Claude Code: 1. ✅ Checks if MongoDB container is running (docker_ps) 2. ✅ Inspects container network config (docker_inspect) 3. ✅ Pings MongoDB host (network_ping) 4. ✅ Checks if port 27017 is open (network_port_check) 5. ✅ Verifies DNS resolution (network_dns_lookup) 6. ✅ Checks firewall rules (network_netstat) 7. ✅ Tests MongoDB connection (mongodb_connect) 8. ✅ Reads application logs (docker_logs) 9. ✅ Identifies issue: "Port 27017 is not exposed in docker-compose.yml" 10. ✅ Fixes docker-compose.yml (Edit) 11. ✅ Restarts containers (docker_compose_restart) 12. ✅ Verifies connection (mongodb_connect) ``` **Without this MCP server:** ``` Claude Code: 1. ❌ "Try running: docker ps" 2. ❌ "Try running: ping mongodb" 3. ❌ "Check your docker-compose.yml manually" ``` --- ### Example 3: API Development & Testing **Goal:** Build a REST API and comprehensively test it. ``` User: "Create a REST API for a todo app. Include CRUD operations and test all endpoints." Claude Code: 1. ✅ Creates Express.js API (built-in Write) 2. ✅ Sets up routes (POST, GET, PUT, DELETE) 3. ✅ Starts development server (shell_execute_streaming) 4. ✅ Waits for server to be ready (network_port_check on port 3000) 5. ✅ Tests POST /todos (http_request) - Validates 201 response - Checks response body schema 6. ✅ Tests GET /todos (http_request) - Validates 200 response - Verifies data structure 7. ✅ Tests PUT /todos/:id (http_request) - Validates update worked 8. ✅ Tests DELETE /todos/:id (http_request) - Confirms deletion 9. ✅ Tests error cases (404, 400) 10. ✅ Generates test report 11. ✅ Commits code + tests (git_add, git_commit) ``` --- ## Roadmap: Next-Generation Agentic Features ### Priority 1: Database Tools 🔥 **Why Critical:** - Every real application needs a database - Claude Code can write DB schemas but can't test them - No way to seed test data or verify migrations **MongoDB Tools:** ✅ **COMPLETE** (19 tools) - [x] Connection management (connect, list databases/collections) - [x] Query execution with aggregation pipeline ($match, $group, $sort, $project) - [x] CRUD operations (insert_one, insert_many, update_one, update_many, delete_one, delete_many, find, find_one, count) - [x] Collection management (create, drop with validation) - [x] Index management (create, list, drop with unique/sparse/TTL support) - [x] Database statistics (collection stats, database stats) - [x] JSON Schema validation (strict/moderate validation levels) **PostgreSQL Tools (Planned):** - [ ] Connection pooling - [ ] SQL query execution - [ ] Transaction management - [ ] Migration runner - [ ] Table introspection - [ ] Index analysis - [ ] Query performance analysis **Redis Tools (Planned):** - [ ] Key-value operations - [ ] Pub/Sub messaging - [ ] Cache management - [ ] Session storage - [ ] Stream processing --- ### Priority 2: Testing Framework Integration 🧪 **Why Critical:** - Claude Code can write tests but can't run them with detailed feedback - No way to verify test coverage - Can't debug failing tests interactively **Planned Tools:** - `jest_run` - Run Jest tests with detailed output - Per-test status - Coverage reports - Failed assertion details - Snapshot diffs - `pytest_run` - Run Pytest with structured results - `vitest_run` - Run Vitest tests - `playwright_test` - Run E2E tests - Screenshots on failure - Video recordings - Trace files - `coverage_report` - Generate coverage reports - `test_watch` - Watch mode for TDD workflows **Use Case:** ``` User: "Write tests for this component and make sure they all pass" Claude Code: 1. ✅ Writes comprehensive test suite 2. ✅ Runs jest_run() 3. ✅ Sees: "12/15 tests passing, 3 failing" 4. ✅ Analyzes failure details 5. ✅ Fixes bugs in component 6. ✅ Re-runs tests 7. ✅ Confirms: "15/15 tests passing" 8. ✅ Checks coverage: "95% coverage" ``` --- ### Priority 3: API Testing & Mocking 🌐 **Why Critical:** - Modern apps integrate with dozens of APIs - No structured way to test API integrations - Can't mock external services for testing **Planned Tools:** - `api_collection_run` - Run Postman-like API test collections - Sequential requests - Variable extraction (save response data for next request) - Assertions on responses - Environment management - `api_mock_server` - Start mock API server - Define mock responses - Simulate delays/errors - Request verification - `graphql_query` - Execute GraphQL queries - Query validation - Type checking - Response parsing - `websocket_test` - Test WebSocket connections - Connect/disconnect - Send/receive messages - Event verification **Use Case:** ``` User: "Test our payment API integration with Stripe" Claude Code: 1. ✅ Starts api_mock_server() simulating Stripe 2. ✅ Configures app to use mock server 3. ✅ Runs api_collection_run() with test scenarios: - ✅ Successful payment - ✅ Declined card - ✅ Network timeout - ✅ Invalid API key 4. ✅ Verifies error handling 5. ✅ Generates test report ``` --- ### Priority 4: Process & Service Management ⚙️ **Why Critical:** - Production apps run as services (PM2, systemd) - No way to manage or monitor long-running processes - Can't debug why services crash **Planned Tools:** - `pm2_start` - Start processes with PM2 - `pm2_stop` - Stop PM2 processes - `pm2_restart` - Restart processes - `pm2_logs` - View logs with filtering - `pm2_monit` - Monitor resource usage (CPU, memory) - `systemctl_status` - Check service status - `systemctl_start/stop/restart` - Manage systemd services - `supervisord_*` - Supervisor process manager tools **Use Case:** ``` User: "Deploy this API with PM2 and monitor it" Claude Code: 1. ✅ Starts pm2_start("api", "npm start") 2. ✅ Configures auto-restart on failure 3. ✅ Checks pm2_monit() - CPU: 2%, Memory: 150MB 4. ✅ Simulates crash 5. ✅ Verifies auto-restart worked 6. ✅ Checks pm2_logs() for crash reason ``` --- ### Priority 5: Environment & Secrets Management 🔐 **Why Critical:** - Every app needs environment variables - Secrets should never be hardcoded - No structured way to manage .env files **Planned Tools:** - `env_read` - Read .env files - `env_write` - Write .env files safely - `env_validate` - Validate required env vars - `env_encrypt` - Encrypt sensitive values - `env_diff` - Compare .env files (.env vs .env.example) - `secrets_vault_*` - HashiCorp Vault integration - `secrets_aws_*` - AWS Secrets Manager integration **Use Case:** ``` User: "Set up environment variables for dev, staging, prod" Claude Code: 1. ✅ Creates .env.example with required vars 2. ✅ Creates .env.dev with env_write() 3. ✅ Creates .env.staging with encrypted secrets 4. ✅ Validates all required vars present (env_validate) 5. ✅ Generates env_diff() report 6. ✅ Adds .env to .gitignore ``` --- ### Priority 6: Performance Monitoring & Profiling 📊 **Why Critical:** - Can't identify performance bottlenecks - No visibility into resource usage - Can't optimize without data **Planned Tools:** - `perf_profile` - CPU/memory profiling - Flame graphs - Call stack analysis - Hotspot identification - `perf_benchmark` - Run performance benchmarks - `perf_monitor` - Real-time system monitoring - CPU usage per process - Memory usage - Disk I/O - Network traffic - `lighthouse_audit` - Run Lighthouse audits - Performance scores - Accessibility - Best practices - SEO **Use Case:** ``` User: "Why is this API endpoint so slow?" Claude Code: 1. ✅ Runs perf_profile() on API process 2. ✅ Identifies: "Database query taking 800ms" 3. ✅ Checks mongodb_stats() - no index on query field 4. ✅ Creates mongodb_create_index() 5. ✅ Re-runs perf_profile() 6. ✅ Confirms: "Query now takes 5ms" ``` --- ### Priority 7: Log Analysis & Aggregation 📝 **Why Critical:** - Applications generate tons of logs - Hard to find relevant information - No structured way to analyze patterns **Planned Tools:** - `log_parse` - Parse structured logs (JSON, syslog) - Filter by level (error, warn, info) - Time range filtering - Field extraction - `log_search` - Search logs with regex/patterns - `log_aggregate` - Aggregate log statistics - Error frequency - Response time percentiles - Top errors - `log_tail` - Real-time log monitoring with filters **Use Case:** ``` User: "Find all errors in the last hour" Claude Code: 1. ✅ Runs log_parse() on application logs 2. ✅ Filters: level="error", time="-1h" 3. ✅ Groups by error type (log_aggregate) 4. ✅ Finds: "Database connection timeout: 47 occurrences" 5. ✅ Shows stack traces for debugging ``` --- ### Priority 8: Package & Dependency Management 📦 **Why Critical:** - Dependencies get outdated quickly - Security vulnerabilities in packages - No way to audit dependencies **Planned Tools:** - `npm_audit` - Security vulnerability scanning - Severity levels - Fix suggestions - CVE details - `npm_outdated` - Check for outdated packages - `npm_update` - Update packages safely - `dependency_graph` - Visualize dependency tree - `license_check` - Check package licenses - `bundle_analyze` - Analyze bundle size **Use Case:** ``` User: "Check this project for security issues" Claude Code: 1. ✅ Runs npm_audit() 2. ✅ Finds: "3 high severity vulnerabilities" 3. ✅ Shows affected packages 4. ✅ Suggests: "Update lodash to 4.17.21" 5. ✅ Runs npm_update() with confirmation 6. ✅ Re-audits: "0 vulnerabilities" ``` --- ### Priority 9: CI/CD Integration 🚀 **Why Critical:** - Modern development requires CI/CD - No way to interact with CI pipelines - Can't debug failed builds **Planned Tools:** - `github_actions_run` - Trigger GitHub Actions - `github_actions_logs` - View workflow logs - `github_actions_status` - Check workflow status - `gitlab_ci_*` - GitLab CI/CD tools - `jenkins_*` - Jenkins integration - `deploy_vercel/netlify/aws` - One-click deployments --- ### Priority 10: Kubernetes & Orchestration ☸️ **Why Critical:** - Production apps increasingly use Kubernetes - No way to manage K8s resources - Can't debug pod failures **Planned Tools:** - `kubectl_get` - Get K8s resources - `kubectl_describe` - Describe resources - `kubectl_logs` - Pod logs - `kubectl_exec` - Execute in pods - `kubectl_apply` - Apply manifests - `helm_install/upgrade` - Helm chart management --- ## Architecture ### Technology Stack - **Runtime**: Node.js 18+ - **MCP SDK**: `@modelcontextprotocol/sdk` - **Validation**: Zod (type-safe schemas) - **Transport**: stdio (JSON-RPC over stdin/stdout) ### Project Structure ``` mcp2/ ├── src/ │ ├── index.ts # Main server & request routing │ ├── tools/ │ │ ├── filesystem.ts # File operations │ │ ├── shell.ts # Shell execution │ │ ├── docker.ts # Docker & Docker Compose │ │ ├── network.ts # HTTP & network tools │ │ ├── git.ts # Git operations │ │ ├── mongodb.ts # MongoDB tools (in progress) │ │ └── process.ts # Process management (planned) ├── build/ # Compiled JavaScript ├── package.json ├── tsconfig.json └── CLAUDE.md # This file ``` ### How It Works 1. **Claude Code connects** to this MCP server via stdio transport 2. **Server registers tools** with typed schemas (Zod validation) 3. **Claude Code calls tools** via JSON-RPC requests 4. **Server executes** tool logic (shell commands, API calls, etc.) 5. **Structured responses** returned as JSON for Claude to reason about ### Adding New Tools 1. **Define schema** in `src/tools/yourTool.ts`: ```typescript export const yourToolSchema = z.object({ param1: z.string().describe('What this param does'), param2: z.number().optional().describe('Optional param') }); ``` 2. **Implement function**: ```typescript export async function yourTool(args: z.infer<typeof yourToolSchema>): Promise<ToolResponse> { // Your logic here return { content: [{ type: "text", text: JSON.stringify({ success: true, data: "result" }, null, 2) }] }; } ``` 3. **Export tool metadata**: ```typescript export const yourTools = [ { name: 'your_tool', description: 'What this tool does and when to use it', inputSchema: { type: 'object', properties: { param1: { type: 'string', description: '...' }, param2: { type: 'number', description: '...' } }, required: ['param1'] } } ]; ``` 4. **Register in `src/index.ts`**: ```typescript import { yourTools, yourTool, yourToolSchema } from './tools/yourTool.js'; // In setupHandlers(): if (name === 'your_tool') { const validated = yourToolSchema.parse(args); return await yourTool(validated); } ``` 5. **Rebuild & test**: ```bash npm run build # Restart Claude Code ``` --- ## Contributing Contributions welcome! Priority areas: 1. MongoDB tool implementation 2. Testing framework integration 3. API testing tools 4. Process management tools --- ## License MIT License - See LICENSE file for details --- ## Support - **Issues**: [GitHub Issues](https://github.com/yourusername/mcp-unrestricted-dev-server/issues) - **Discussions**: [GitHub Discussions](https://github.com/yourusername/mcp-unrestricted-dev-server/discussions) - **MCP Documentation**: [Model Context Protocol](https://modelcontextprotocol.io) - **Claude Code Docs**: [Claude Code Documentation](https://docs.claude.com/en/docs/claude-code) --- **Built with ❤️ for the Claude Code community** *Transform Claude Code from a scaffolding tool into a true autonomous development agent.*