gh-phaezer-claude-mkt-plugins-mcp/commands/mcp-init-project.md

description, argument-hint

description	argument-hint
Initialize new MCP server or client project	Project type (server/client) and language (python/typescript)

Initialize MCP Project

Initialize a new MCP server or client project with proper structure, dependencies, and configuration.

Usage

/mcp-init-project [type] [language]

Arguments:

• type: Project type - either "server" or "client"
• language: Programming language - either "python" or "typescript"

Examples:

/mcp-init-project server python
/mcp-init-project client typescript
/mcp-init-project server typescript
/mcp-init-project client python

What This Command Does

This command creates a complete project structure for an MCP server or client with:

• Proper directory structure
• Configuration files (pyproject.toml, package.json, tsconfig.json)
• Example implementations
• Testing setup
• Development tools configuration
• Documentation templates

Workflow Steps

Step 1: Gather Project Requirements

Ask the user for:

1. Project name: What should this project be called?
2. Project description: Brief description of what it does
3. Author information: Name and email
4. License: MIT, Apache-2.0, etc. (default: MIT)
5. Additional features:
   • For servers: What tools/resources/prompts to include?
   • For clients: Which servers to connect to?

Step 2: Create Project Structure

Based on project type and language, create the appropriate directory structure:

Python Server:

project-name/
├── src/
│   └── project_name/
│       ├── __init__.py
│       ├── __main__.py
│       ├── server.py
│       ├── config.py
│       └── tools/
│           └── __init__.py
├── tests/
│   ├── __init__.py
│   └── test_tools.py
├── pyproject.toml
├── README.md
├── LICENSE
├── .env.example
├── .gitignore
└── Dockerfile

TypeScript Server:

project-name/
├── src/
│   ├── index.ts
│   ├── server.ts
│   ├── config.ts
│   └── tools/
│       └── index.ts
├── tests/
│   └── tools.test.ts
├── package.json
├── tsconfig.json
├── jest.config.js
├── README.md
├── LICENSE
├── .env.example
├── .gitignore
└── Dockerfile

Step 3: Generate Configuration Files

Create all necessary configuration files:

Python (pyproject.toml):

• Use hatchling build system
• Set Python >= 3.11 requirement
• Include fastmcp or mcp SDK dependency
• Add dev dependencies (pytest, black, ruff)
• Configure entry point script

TypeScript (package.json + tsconfig.json):

• Set CommonJS module system
• Use @modelcontextprotocol/sdk
• Include zod for validation
• Add dev dependencies (typescript, jest, ts-jest)
• Configure build scripts

Step 4: Create Example Implementation

For Servers:

• Create example tool (e.g., echo, create_file)
• Create example resource (e.g., file:// resource)
• Create example prompt template
• Set up proper error handling
• Add input validation

For Clients:

• Create connection setup code
• Add tool listing/calling examples
• Add resource reading examples
• Implement error handling
• Add retry logic

Step 5: Set Up Testing

Python:

• Create pytest configuration
• Add conftest.py with shared fixtures
• Create example unit tests for tools
• Add integration test template

TypeScript:

• Create jest.config.js
• Add example unit tests
• Set up test helpers
• Add integration test template

Step 6: Create Documentation

Create comprehensive README.md with:

• Project description
• Features list
• Installation instructions
• Configuration guide
• Usage examples
• Development setup
• Testing instructions

Step 7: Add Development Tools

Create files:

• .gitignore (exclude node_modules, build, .env, etc.)
• .env.example (template for environment variables)
• Dockerfile (for containerization)
• LICENSE (with chosen license text)

Python additional:

• .python-version or pyproject.toml tool config for black, ruff

TypeScript additional:

• .prettierrc (code formatting)
• .eslintrc.json (linting)

Step 8: Initialize Git Repository

git init
git add .
git commit -m "Initial commit: Set up [project-name] MCP [server/client]"

Step 9: Provide Next Steps

Give the user clear instructions on:

1. Install dependencies:

   # Python
   pip install -e .[dev]
   
   # TypeScript
   npm install
   

2. Configure environment:

   cp .env.example .env
   # Edit .env with your API keys
   

3. Run tests:

   # Python
   pytest
   
   # TypeScript
   npm test
   

4. Run development server:

   # Python
   python -m project_name
   
   # TypeScript
   npm run dev
   

5. For servers, test with MCP Inspector:

   # Python
   mcp-inspector python -m project_name
   
   # TypeScript
   mcp-inspector node build/index.js
   

6. For servers, add to Claude Desktop:

   • Edit ~/Library/Application Support/Claude/claude_desktop_config.json
   • Add server configuration
   • Restart Claude Desktop

Example Output

Created MCP Server project: my-github-tools

✓ Created project structure
✓ Generated pyproject.toml
✓ Created example tools (create_issue, list_repos)
✓ Set up pytest testing
✓ Created README.md
✓ Added .gitignore and .env.example
✓ Created Dockerfile
✓ Initialized git repository

Next steps:
1. cd my-github-tools
2. pip install -e .[dev]
3. cp .env.example .env
4. Edit .env and add your GITHUB_TOKEN
5. pytest  # Run tests
6. python -m my_github_tools  # Start server

To test with MCP Inspector:
mcp-inspector python -m my_github_tools

To add to Claude Desktop, edit:
~/Library/Application Support/Claude/claude_desktop_config.json

Add:
{
  "mcpServers": {
    "github-tools": {
      "command": "uvx",
      "args": ["my-github-tools"],
      "env": {
        "GITHUB_TOKEN": "your-token-here"
      }
    }
  }
}

Template Files

The command should create these template files with proper content:

Example Python Server Tool

from fastmcp import FastMCP

mcp = FastMCP("example-server")

@mcp.tool()
def echo(message: str) -> dict:
    """Echoes back the input message.

    Args:
        message: Message to echo

    Returns:
        dict with echoed message
    """
    return {
        "success": True,
        "message": message
    }

Example TypeScript Server Tool

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { Tool } from "@modelcontextprotocol/sdk/types.js";

const echoTool: Tool = {
  name: "echo",
  description: "Echoes back the input message",
  inputSchema: {
    type: "object",
    properties: {
      message: {
        type: "string",
        description: "Message to echo"
      }
    },
    required: ["message"]
  }
};

Success Criteria

• Project structure created
• All configuration files generated
• Example implementations added
• Tests set up and passing
• Documentation complete
• Git repository initialized
• User has clear next steps

This command sets up a production-ready MCP project foundation that follows best practices and is ready for development.