Key takeaways

Install mcp-creator-python, add it to your AI assistant, and describe what you want in plain English
It scaffolds, builds, publishes to PyPI, and creates a GitHub repo: all conversationally
Supports paid servers, freemium models, and remote hosted servers out of the box

What is mcp-creator (Python)?

Looking for TypeScript? See the TypeScript MCP Creator guide.

mcp-creator-python is an MCP server that helps you build other MCP servers in Python. Install it once, add it to your AI assistant, and describe what you want to build in plain English. It handles the scaffolding, packaging, publishing, and GitHub setup for you.

Instead of manually setting up pyproject.toml, figuring out the src layout, writing boilerplate server code, and running build commands: you just talk to your AI assistant.

"Build me an MCP server that checks stock prices"

Your assistant uses mcp-creator-python's tools to generate a complete, publishable Python MCP project.

New to building MCP servers? See How to build an MCP server for the manual TypeScript approach, or read on to use the automated Python path.

Install and setup

1. Install the package

pip install mcp-creator-python

2. Add it to your AI assistant

Terminal

claude mcp add mcp-creator-python -- mcp-creator-python

3. First-time setup

The first time you use mcp-creator-python, it checks what you have installed and walks you through anything missing:

Python 3.11+: required
uv: for building and publishing (pip install uv or brew install uv)
git: for version control
GitHub CLI: for creating repos (brew install gh, then gh auth login)
PyPI API token: for publishing (see how to get one)

Once setup is done, it is done forever. Every future project skips straight to "what do you want to build?"

What it generates

When you scaffold a new server, mcp-creator-python creates a complete project:

my-mcp-server/
├── pyproject.toml          # Package metadata, dependencies, entry point
├── README.md               # PyPI listing with install + config instructions
├── .gitignore
├── LAUNCHGUIDE.md          # MCP Marketplace submission checklist
├── src/
│   └── my_mcp_server/
│       ├── __init__.py
│       ├── server.py       # MCP server with all tools registered
│       ├── tools/
│       │   ├── __init__.py
│       │   └── my_tool.py  # Tool implementation (one file per tool)
│       └── services/
│           ├── __init__.py
│           └── my_service.py  # Business logic stubs
└── tests/
    └── test_my_tool.py     # Test stubs for each tool

The project runs immediately with placeholder data. You fill in your real API calls and business logic in the services/ folder.

The tools

mcp-creator-python exposes 7 tools to your AI assistant:

Tool	What it does
`check_setup`	Verifies Python, uv, git, gh, and PyPI token are installed
`check_pypi_name`	Checks if a package name is available on PyPI
`scaffold_server`	Generates a complete MCP server project
`add_tool`	Adds a new tool to an existing project
`build_package`	Runs `uv build` to create the distributable package
`publish_package`	Runs `uv publish` to push to PyPI
`create_github_repo`	Creates a GitHub repo and pushes code

You never call these tools directly. Your AI assistant decides which to use based on what you ask for.

Walkthrough: building a weather MCP

Here is what a typical session looks like:

You: "Build me an MCP server that gets weather data for any city"

Your AI assistant (using mcp-creator-python):

Checks your setup: everything is installed
Checks weather-mcp on PyPI: name is available
Scaffolds the project with a get_weather tool
You fill in the weather API call in services/weather_service.py
Builds the package with uv build
Publishes to PyPI with uv publish
Creates a GitHub repo and pushes code
Generates a LAUNCHGUIDE.md for marketplace submission

Result: Your server is live on PyPI, on GitHub, and ready to submit to MCP Marketplace. Total time: a few minutes.

Adding tools to an existing project

Already have a scaffolded project and want to add more tools? Just ask:

"Add a get_forecast tool that returns a 5-day forecast"

mcp-creator-python creates:

tools/get_forecast.py: tool implementation
services/forecast_service.py: business logic stub
tests/test_get_forecast.py: test stub
Updates server.py to register the new tool

No manual wiring needed.

Paid and remote servers

mcp-creator-python can scaffold servers with monetization built in:

Paid local server

scaffold_server(
    package_name="my-paid-mcp",
    tools=[...],
    paid=true
)

Adds mcp-marketplace-license to dependencies, wires license verification into every tool, and includes setup instructions in the README. Learn more in How to monetize your MCP server.

Gate specific tools only (freemium)

scaffold_server(
    package_name="my-freemium-mcp",
    tools=[...],
    paid=true,
    paid_tools=["pro_tool_1", "pro_tool_2"]
)

Free tools work for everyone. Pro tools require a license key. Read the free vs pro guide for strategy tips.

Remote hosted server

scaffold_server(
    package_name="my-remote-mcp",
    tools=[...],
    hosting="remote"
)

Generates an HTTP server with SSE transport instead of stdio, includes a Dockerfile for deployment, and a README with remote config examples. See the remote MCP server guide for deployment options.

Tips

Name your package with -mcp: Names like weather-mcp or finance-mcp are clear, searchable on PyPI, and unlikely to collide with existing packages.

Fill in services first: The generated project runs with placeholder data. Your real work happens in the services/ folder: that is where your API calls, database queries, and business logic go.

Use the LAUNCHGUIDE: Every scaffolded project includes a LAUNCHGUIDE.md with a checklist for submitting to MCP Marketplace. Follow it to make sure your listing is complete.

Test locally before publishing: Add the server to your Claude Desktop or Claude Code config and test your tools before publishing to PyPI.

Next steps

How to publish your MCP server to PyPI: the full manual process if you want to understand what is happening under the hood
How to monetize your MCP server: license keys, remote hosting, and the freemium model
How to build an MCP server: the TypeScript SDK approach for Node.js developers
Submit to MCP Marketplace: get your server listed and discoverable

MCP Creator for Python: build and publish MCP servers with AI