gh-phaezer-claude-mkt-plugins-mcp/commands/mcp-full-stack-dev.md

description, argument-hint

description	argument-hint
End-to-end orchestrated MCP development workflow	Project requirements

MCP Full-Stack Development Workflow

Complete end-to-end development of an MCP server from requirements to deployment.

Usage

/mcp-full-stack-dev [requirements]

Arguments:

• requirements: Brief description of what to build (optional if discussed interactively)

Examples:

/mcp-full-stack-dev GitHub integration server with issue and PR management
/mcp-full-stack-dev PostgreSQL database query tool with read-only access
/mcp-full-stack-dev File system operations server for project management

What This Command Does

This is the master orchestration command that runs the complete MCP development lifecycle:

1. Requirements gathering
2. Architecture design
3. Implementation
4. Testing
5. Security review
6. Deployment configuration
7. Documentation
8. Final validation

This command uses all other MCP engineer agents in a coordinated workflow.

Workflow Steps

Step 1: Requirements Gathering

Have a comprehensive discussion with the user to understand:

Project Basics:

• What problem does this server solve?
• Who will use it?
• What makes this useful?

Technical Requirements:

1. Server Purpose: Detailed description of functionality
2. Tools Needed: What actions should the LLM perform?
   • Create, read, update, delete operations?
   • Search/query functionality?
   • External API interactions?
3. Resources Needed: What data should the LLM access?
   • File system resources?
   • Database queries?
   • API endpoints?
4. Prompts Needed: Common workflows that need templates?
5. External Services: APIs, databases, file systems?
6. Authentication: API keys, tokens, credentials?
7. Language: Python or TypeScript?
8. Target Users: Claude Desktop, web app, CLI?

Document Requirements: Create a requirements document summarizing all inputs.

Step 2: Phase 1 - Architecture Design

Launch mcp-server-architect agent via Task tool.

Agent Task:

Design comprehensive MCP server architecture:

Project: [project name]
Purpose: [detailed purpose]

Requirements:
Tools:
- [list each tool with description]

Resources:
- [list each resource with description]

Prompts:
- [list each prompt with description]

External Services:
- [list APIs, databases, etc.]

Transport: stdio (Claude Desktop)
Language: [Python/TypeScript]

Provide:
1. Complete tools specification
   - Names, descriptions
   - Input schemas with validation rules
   - Output formats
   - Error handling requirements

2. Resources specification
   - URI patterns
   - Data sources
   - Access patterns
   - Caching strategy

3. Prompts specification
   - Template content
   - Parameters
   - Use cases

4. Server structure
   - File organization
   - Module breakdown
   - Configuration needs

5. Security considerations
   - Input validation requirements
   - Access control needs
   - Credential management

Output: Complete architecture document with all specifications.

Checkpoint: Review architecture with user and confirm before proceeding.

Step 3: Phase 2 - Project Initialization

Use /mcp-init-project command to create project structure.

/mcp-init-project server [python/typescript]

This creates:

• Complete directory structure
• Configuration files
• Testing setup
• Development tools
• Git repository

Validate: Ensure project structure is created correctly.

Step 4: Phase 3 - Implementation

Launch mcp-python-developer or mcp-typescript-developer agent via Task tool.

Agent Task:

Implement MCP server based on architecture:

Architecture: [paste complete architecture from Step 2]
Project Location: [path]
Language: [Python/TypeScript]

Implementation Requirements:
1. Implement ALL tools with:
   - Complete input validation (Pydantic/Zod)
   - Proper error handling
   - Comprehensive logging
   - Return type consistency

2. Implement ALL resources with:
   - Efficient data access
   - Caching where appropriate
   - Access control validation
   - Error handling

3. Implement ALL prompts with:
   - Parameter handling
   - Template rendering
   - Example usage

4. Configuration management:
   - Environment variables for all secrets
   - Configuration validation
   - Sensible defaults

5. Server setup:
   - [stdio/SSE] transport configuration
   - Proper initialization
   - Graceful shutdown
   - Health monitoring

Code Quality Requirements:
- Type hints (Python) / TypeScript types
- Docstrings for all functions
- Clear variable names
- Modular organization
- No hardcoded values

Output: Complete, working server implementation.

Validate: Test server starts and basic functionality works.

Step 5: Phase 4 - Testing

Launch mcp-testing-engineer agent via Task tool.

Agent Task:

Create comprehensive test suite for MCP server:

Project: [project name]
Location: [path]
Language: [Python/TypeScript]

Testing Requirements:
1. Unit Tests (target >80% coverage):
   - Test each tool individually
   - Test all success paths
   - Test all error paths
   - Test edge cases
   - Mock external dependencies

2. Integration Tests:
   - Test with MCP Inspector
   - Test tool chains
   - Test resource access
   - Test prompt generation
   - Test configuration loading

3. Error Scenario Tests:
   - Invalid inputs
   - Network failures
   - Timeouts
   - Missing credentials
   - Rate limiting

4. Performance Tests:
   - Response time checks
   - Concurrent request handling
   - Memory usage

5. Mock Fixtures:
   - Mock external APIs
   - Mock database responses
   - Sample test data

Deliverables:
- Complete test suite
- pytest/jest configuration
- Mock fixtures
- Coverage report (>80%)
- Integration test results

Output: Complete test suite with high coverage.

Checkpoint: Run tests and ensure all pass:

# Python
pytest --cov=src --cov-report=term-missing

# TypeScript
npm test -- --coverage

Step 6: Phase 5 - Security Review

Launch mcp-security-reviewer agent via Task tool.

Agent Task:

Perform comprehensive security review:

Project: [project name]
Location: [path]
Language: [Python/TypeScript]

Review all code for:
1. Input Validation
   - Tool parameter validation
   - File path sanitization
   - SQL query safety
   - Command execution safety

2. Authentication & Authorization
   - Credential management
   - API key handling
   - No hardcoded secrets

3. Information Disclosure
   - Error messages
   - Logging practices
   - Stack trace exposure

4. Dependency Security
   - Known vulnerabilities
   - Outdated packages

5. Rate Limiting
   - Abuse prevention
   - Resource protection

Deliverables:
- Security review report
- Vulnerability list with severity
- Code fixes for all issues
- Updated secure implementation

Output: Security review report with fixes.

Checkpoint: Apply all critical and high severity fixes, re-run tests.

Step 7: Phase 6 - Deployment Configuration

Launch mcp-deployment-engineer agent via Task tool.

Agent Task:

Create deployment configuration:

Project: [project name]
Location: [path]
Language: [Python/TypeScript]
Target: local and docker

Deployment Requirements:
1. Claude Desktop Integration
   - Configuration example
   - Installation instructions
   - Environment variable guide

2. Package Configuration
   - pip/npm package setup
   - Version configuration
   - Dependency management

3. Docker Configuration
   - Optimized Dockerfile
   - docker-compose.yml
   - Health checks
   - Security best practices

4. Documentation
   - Complete README.md
   - Installation guide
   - Configuration guide
   - Troubleshooting guide
   - Usage examples

5. Environment Management
   - .env.example with all variables
   - Variable documentation
   - Secret management guide

Deliverables:
- Claude Desktop config
- pyproject.toml/package.json
- Dockerfile and docker-compose.yml
- Complete documentation
- Troubleshooting guide

Output: Complete deployment configuration and documentation.

Step 8: Phase 7 - Integration Testing

Test the complete deployment workflow:

Test 1: Local Installation

# Python
pip install -e .
my-mcp-server  # Should start without errors

# TypeScript
npm install
npm run build
node build/index.js  # Should start without errors

Test 2: MCP Inspector Validation

# Test protocol compliance
mcp-inspector python -m my_mcp_server
# or
mcp-inspector node build/index.js

# Verify:
# - Server starts
# - Tools discovered
# - Resources discovered
# - Prompts discovered
# - Protocol compliant

Test 3: Claude Desktop Integration

1. Add to claude_desktop_config.json
2. Restart Claude Desktop
3. Verify tools appear in Claude
4. Test each tool execution
5. Test resource access
6. Test prompt usage

Test 4: Docker Deployment

# Build image
docker build -t my-mcp-server:latest .

# Run container
docker run -i -e API_KEY=test my-mcp-server:latest

# Test with inspector
docker run -i my-mcp-server:latest | mcp-inspector -

Test 5: Error Scenarios

• Start without required environment variables
• Invalid API credentials
• Network connectivity issues
• Malformed inputs to tools

Step 9: Phase 8 - Final Documentation

Compile comprehensive project documentation:

README.md sections:

1. Project Overview

   • What it does
   • Key features
   • Use cases

2. Quick Start

   • Fastest way to get running
   • Minimal configuration

3. Installation

   • Multiple installation methods
   • Prerequisites
   • Step-by-step instructions

4. Configuration

   • All environment variables
   • How to get API keys
   • Configuration file options

5. Usage Examples

   • Each tool with examples
   • Each resource with examples
   • Common workflows

6. Development

   • Setup dev environment
   • Running tests
   • Contributing

7. Troubleshooting

   • Common issues
   • Debug mode
   • Getting help

Additional Documentation:

• API.md (detailed tool/resource docs)
• SECURITY.md (security considerations)
• CHANGELOG.md (version history)
• CONTRIBUTING.md (contribution guide)
• LICENSE (license file)

Step 10: Final Validation and Handoff

Create comprehensive project summary:

✓ MCP Server Development Complete: [project-name]

═══════════════════════════════════════════════════════
PROJECT SUMMARY
═══════════════════════════════════════════════════════

Purpose: [brief description]
Language: [Python/TypeScript]
Transport: stdio
Target: Claude Desktop

═══════════════════════════════════════════════════════
ARCHITECTURE
═══════════════════════════════════════════════════════

Tools Implemented: [count]
  1. [tool_name] - [description]
  2. [tool_name] - [description]
  ...

Resources Implemented: [count]
  1. [uri_pattern] - [description]
  2. [uri_pattern] - [description]
  ...

Prompts Implemented: [count]
  1. [prompt_name] - [description]
  ...

═══════════════════════════════════════════════════════
IMPLEMENTATION METRICS
═══════════════════════════════════════════════════════

Lines of Code: [count]
Files: [count]
Modules: [count]

Dependencies:
  - [dependency]: [version]
  - [dependency]: [version]
  ...

═══════════════════════════════════════════════════════
TESTING RESULTS
═══════════════════════════════════════════════════════

Unit Tests: [count]/[count] passed ✓
Integration Tests: [count]/[count] passed ✓
MCP Inspector: PASS ✓
Protocol Compliance: PASS ✓
Performance: PASS ✓

Code Coverage: [percentage]%
  - Tools: [percentage]%
  - Resources: [percentage]%
  - Prompts: [percentage]%
  - Config: [percentage]%

═══════════════════════════════════════════════════════
SECURITY REVIEW
═══════════════════════════════════════════════════════

Vulnerabilities Found: [count]
  - Critical: 0 ✓
  - High: 0 ✓
  - Medium: [count] (all fixed)
  - Low: [count] (documented)

Security Checklist: [percentage]% complete
Input Validation: ✓
Authentication: ✓
Authorization: ✓
Error Handling: ✓
Dependency Security: ✓

═══════════════════════════════════════════════════════
DEPLOYMENT STATUS
═══════════════════════════════════════════════════════

Local Deployment: ✓ Ready
  - Claude Desktop: Configured
  - pip/npm: Package ready
  - Documentation: Complete

Docker Deployment: ✓ Ready
  - Dockerfile: Optimized ([size]MB)
  - docker-compose.yml: Configured
  - Health checks: Implemented

═══════════════════════════════════════════════════════
DOCUMENTATION
═══════════════════════════════════════════════════════

✓ README.md - Complete guide
✓ API.md - Full API documentation
✓ TROUBLESHOOTING.md - Common issues and solutions
✓ SECURITY.md - Security considerations
✓ CONTRIBUTING.md - Contribution guidelines
✓ CHANGELOG.md - Version history

═══════════════════════════════════════════════════════
NEXT STEPS
═══════════════════════════════════════════════════════

1. Test Locally:
   $ pip install -e .        # or: npm install
   $ my-mcp-server           # Verify it starts

2. Test with Inspector:
   $ mcp-inspector python -m my_mcp_server

3. Configure Claude Desktop:
   Edit: ~/Library/Application Support/Claude/claude_desktop_config.json
   Add: [see claude-desktop-config.example.json]

4. Restart Claude Desktop

5. Test in Claude:
   - Verify tools appear
   - Test each tool
   - Try example workflows

6. (Optional) Publish:
   Python: python -m build && twine upload dist/*
   Node.js: npm publish

7. (Optional) Deploy Docker:
   $ docker-compose up -d

═══════════════════════════════════════════════════════
FILES CREATED
═══════════════════════════════════════════════════════

Source Code:
  [list all source files]

Tests:
  [list all test files]

Configuration:
  - pyproject.toml / package.json
  - .env.example
  - claude-desktop-config.example.json
  - Dockerfile
  - docker-compose.yml

Documentation:
  - README.md
  - API.md
  - TROUBLESHOOTING.md
  - SECURITY.md
  - CONTRIBUTING.md
  - CHANGELOG.md

═══════════════════════════════════════════════════════

Your MCP server is ready for use! 🎉

For support or questions, see TROUBLESHOOTING.md or open an issue.

Example Full Workflow

User: /mcp-full-stack-dev GitHub integration server

[Step 1: Requirements]
Gathering requirements...
Tools: create_issue, list_repos, create_pr, search_code, get_pr_status
Resources: repos, issues, pull_requests
Authentication: GitHub Personal Access Token
Language: Python

[Step 2: Architecture]
Launching mcp-server-architect...
✓ Architecture complete
  - 5 tools designed
  - 3 resources designed
  - 2 prompts designed

[Step 3: Initialization]
Running /mcp-init-project...
✓ Project structure created
✓ Git repository initialized

[Step 4: Implementation]
Launching mcp-python-developer...
✓ Server implemented with FastMCP
✓ All tools implemented
✓ All resources implemented
✓ Configuration management added

[Step 5: Testing]
Launching mcp-testing-engineer...
✓ 28 tests created
✓ Coverage: 89%
✓ All tests passing

[Step 6: Security Review]
Launching mcp-security-reviewer...
✓ Security review complete
✓ 2 medium issues found and fixed
✓ No critical issues

[Step 7: Deployment]
Launching mcp-deployment-engineer...
✓ Claude Desktop config created
✓ Docker configuration created
✓ Documentation complete

[Step 8: Integration Testing]
✓ Local installation tested
✓ MCP Inspector validation passed
✓ Claude Desktop integration verified
✓ Docker deployment tested

[Step 9: Final Documentation]
✓ All documentation complete

[Step 10: Handoff]
✓ Complete project summary generated

🎉 github-mcp-server is ready for production use!

Success Criteria

• Requirements fully documented
• Architecture designed and approved
• Project structure created
• Complete implementation
• All tests passing (>80% coverage)
• Security review complete with fixes
• Deployment configuration ready
• All documentation complete
• MCP Inspector validation passed
• Claude Desktop integration tested
• Docker deployment tested
• User has production-ready MCP server

This command provides the complete end-to-end orchestrated workflow for professional MCP server development.