Key takeaways

Install mcp-creator-typescript, add it to your AI assistant, and describe what you want in plain English
It scaffolds, builds, publishes to npm, and creates a GitHub repo: all conversationally
Supports paid servers, remote hosted servers, and the @mcp_marketplace/license SDK out of the box

What is mcp-creator-typescript?

mcp-creator-typescript is an MCP server that helps you build other MCP servers in TypeScript. 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 package.json, configuring tsup, writing boilerplate server code, and running build commands: you just talk to your AI assistant.

"Build me a TypeScript MCP server that checks stock prices"

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

Looking for Python instead? See the Python MCP Creator guide. New to MCP? Start with How to build an MCP server.

Install and setup

1. Add it to your AI assistant

Terminal

claude mcp add mcp-creator-typescript -- npx

No global install needed. npx downloads and runs it automatically.

2. First-time setup

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

Node.js 18+: required
npm: for building and publishing
git: for version control
GitHub CLI: for creating repos (brew install gh, then gh auth login)
npm auth: for publishing (npm login)

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-typescript creates a complete project:

my-mcp-server/
├── package.json            # Package metadata, dependencies, scripts
├── tsconfig.json           # TypeScript configuration
├── tsup.config.ts          # Build configuration (tsup bundler)
├── README.md               # npm listing with install + config instructions
├── .gitignore
├── src/
│   ├── index.ts            # MCP server with all tools registered
│   └── tools/
│       └── my-tool.ts      # Tool implementation (one file per tool)
└── tests/
    └── my-tool.test.ts     # Test stubs (vitest)

The project runs immediately with placeholder data. You fill in your real API calls and business logic in the tool files.

The tools

mcp-creator-typescript exposes 10 tools to your AI assistant:

Tool	What it does
`get_creator_profile`	Loads your persistent profile (setup state, project history)
`update_creator_profile`	Saves profile updates (npm/GitHub username, projects)
`check_setup`	Verifies Node.js, npm, git, gh, and npm auth are installed
`check_npm_name`	Checks if a package name is available on npm
`scaffold_server`	Generates a complete TypeScript MCP server project
`add_tool`	Adds a new tool to an existing project
`build_package`	Runs `npm run build` (tsup) to create the distributable
`publish_package`	Runs `npm publish` to push to npm
`setup_github`	Creates a GitHub repo and pushes code
`generate_launchguide`	Generates LAUNCHGUIDE.md for marketplace submission

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 a TypeScript MCP server that gets weather data for any city"

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

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

Result: Your server is live on npm, 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-typescript creates:

src/tools/get-forecast.ts: tool implementation with typed parameters
tests/get-forecast.test.ts: test stub
Updates src/index.ts to register the new tool

No manual wiring needed.

Paid servers

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

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.

For the freemium model (some tools free, some gated), see the free vs pro guide.

Remote hosted servers

Add hosting="remote" to scaffold a server that runs on your infrastructure instead of the user's machine:

scaffold_server(
    package_name="my-remote-mcp",
    description="A remote hosted MCP server",
    tools=[...],
    hosting="remote"
)

This generates a project with Streamable HTTP transport, a Dockerfile for containerized 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 npm, and unlikely to collide with existing packages.

Fill in tool logic first: The generated project runs with placeholder data. Your real work happens in src/tools/: 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 npm.

Next steps

How to build an MCP server: the full manual TypeScript 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
Python MCP Creator guide: the Python companion for building Python MCP servers
How to publish your MCP server to PyPI: publishing Python servers to PyPI
Submit to MCP Marketplace: get your server listed and discoverable

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