---
description: Initialize new MCP server or client project
argument-hint: 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

```bash
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:**
   ```bash
   # Python
   pip install -e .[dev]

   # TypeScript
   npm install
   ```

2. **Configure environment:**
   ```bash
   cp .env.example .env
   # Edit .env with your API keys
   ```

3. **Run tests:**
   ```bash
   # Python
   pytest

   # TypeScript
   npm test
   ```

4. **Run development server:**
   ```bash
   # Python
   python -m project_name

   # TypeScript
   npm run dev
   ```

5. **For servers, test with MCP Inspector:**
   ```bash
   # 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

```python
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

```typescript
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.