MCP Forge

MCP-Forge is a scaffolding tool for quickly creating MCP server projects, providing project structure generation, sample code, and testing tools, and supporting two transport modes, SSE and stdio.

Developer tools Education and learning tools #Scaffolding tool #MCP service #Project generation #Python development .Python

rating : 2.5 points

downloads : 19

update time : 2025-04-23

What is MCP-Forge?

MCP-Forge is a tool that helps developers quickly set up MCP (Model Context Protocol) server projects. It can automatically generate a complete project with a standard directory structure, sample code, and necessary configurations, allowing developers to immediately start building their own MCP server functions.

How to use MCP-Forge?

Just run a simple command, and MCP-Forge will create a new project with all the necessary files and configurations. After creation, you can directly run the server or start adding your own tools and resources.

Applicable scenarios

Suitable for developers who need to quickly start MCP server projects, especially teams that want to follow a standard structure and reduce initial configuration work.

Main features

Project scaffoldingAutomatically generate a complete Python project structure, including standard directories and basic files

Example toolsBuilt - in multiple example tools (such as number addition, date calculation, etc.) to help developers quickly understand

Multiple transport mode supportSupports two communication modes, SSE (HTTP) and stdio, to adapt to different usage scenarios

Pydantic model supportUse Pydantic to define clear input and output data structures

Advantages and limitations

Advantages

Quickly start a new project and reduce repetitive configuration work

Standardized project structure for easy team collaboration

Built - in sample code to reduce the learning curve

Support multiple communication modes to adapt to different scenarios

Limitations

Early version, the API may change

Currently mainly targeted at the Python technology stack

Need to be familiar with the MCP protocol to make full use of it

How to use

Install MCP-Forge

Install the MCP-Forge tool using pip or uv

Create a new project

Run the new command to create a new project and specify the project name

Enter the project directory

Navigate to the newly created project directory

Install dependencies

Use uv to install the dependencies required by the project

Run the server

Select the SSE or stdio mode to run the server

Usage examples

Create a customized server projectDevelopers need to create an MCP server specifically for handling mathematical operations

Rapid prototype developmentThe team needs to quickly verify an MCP server concept

Frequently Asked Questions

Which Python versions does MCP-Forge support?

How to add custom tools to the generated project?

What's the difference between SSE mode and stdio mode?

Can the directory structure be modified after the project is generated?

Related resources

MCP official documentation

Official specifications and documentation of the Model Context Protocol

MCP-Forge source code

GitHub repository of MCP-Forge

Pydantic documentation

Official documentation of the Pydantic data validation library

uv documentation

Documentation of the uv fast Python package installer

🚀 MCP-Forge

MCP-Forge is a scaffolding tool for quickly setting up new MCP (Model Context Protocol) server projects. It generates a well-structured project with sample tools, resources, and testing utilities, allowing you to focus on building the server's functionality.

🚀 Quick Start

MCP-Forge is a scaffolding tool that enables you to rapidly set up new MCP (Model Context Protocol) server projects. It creates a well - structured project, including sample tools, resources, and testing utilities, so you can concentrate on developing the server's functionality.

⚠️ Important Note

This is an early version of MCP - Forge. The API, generated structure, and features may change as the MCP ecosystem evolves. Feedback and contributions are welcome!

🌟 Support Development

If you find this project useful, please consider supporting its development through donations:

Your support will help maintain and improve this project!

✨ Features

Generate a complete Python project structure for MCP servers.
Provide a unified server entry point and select SSE and stdio transport modes via the --mode parameter.
Include sample tools (AddNumbers, DateDifference, etc.) and resources (HelloWorld, UserProfile).
Use Pydantic models to define clear input/output architectures.
Use uv for dependency management and task running.

📦 Installation

It is recommended to use uvx (from uv), which handles temporary environments:

# Ensure uv is installed
uvx mcp-forge --help

Alternatively, you can install it globally or use pip in a dedicated environment:

pip install mcp-forge
mcp-forge --help

💻 Usage Examples

Basic Usage

Create a New Project

To create a new MCP server project, run the following command:

mcp-forge new my-awesome-server
cd my-awesome-server

Start the Server

To start the server, execute the following command:

uv run python -m my_awesome_server.server --mode=sse

Or, if you have entered the project directory:

my-awesome-server --mode=sse  # Run in SSE mode (HTTP service on 0.0.0.0:6969)
my-awesome-server --mode=stdio # Run in stdio mode

Advanced Usage

Project Structure

The generated project structure is as follows:

my_awesome_server/
├── server.py             # Main server file
├── tools/               # Custom tools directory
│   └── __init__.py      # Tools initialization file
├── resources/           # Resources directory
│   └── __init__.py      # Resources initialization file
└── requirements.txt     # Project dependency management file

📚 Documentation

The Model Context Protocol (MCP) is a specification for implementing communication between language models (or other clients) and external tools/services (servers). It defines how servers expose tools and resources in a standard way.

For more information, visit MCP official documentation.