https://github.com/mariojgt/mcpfactory
Pick the tools you want, click build, download a ready-to-run MCP server. 32 integrations, browser-built, zero infra.
https://github.com/mariojgt/mcpfactory
anthropic claude claude-code claude-desktop mcp mcp-server mcp-tools model-context-protocol nextjs typescript
Last synced: 4 days ago
JSON representation
Pick the tools you want, click build, download a ready-to-run MCP server. 32 integrations, browser-built, zero infra.
- Host: GitHub
- URL: https://github.com/mariojgt/mcpfactory
- Owner: mariojgt
- Created: 2026-05-04T17:45:58.000Z (2 months ago)
- Default Branch: main
- Last Pushed: 2026-05-04T19:27:54.000Z (2 months ago)
- Last Synced: 2026-05-04T20:28:47.049Z (2 months ago)
- Topics: anthropic, claude, claude-code, claude-desktop, mcp, mcp-server, mcp-tools, model-context-protocol, nextjs, typescript
- Language: TypeScript
- Homepage: https://mariojgt.github.io/mcpfactory
- Size: 396 KB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# MCP Factory
**Pick the tools you want, click build, download a ready-to-run MCP server.**
A static, browser-built dashboard that assembles custom **Model Context Protocol** servers from a curated catalog of integrations — Stripe, GitHub, Slack, Notion, Linear, PostgreSQL, OpenAI, Gmail, YouTube, Anthropic, and 22 more. The build runs entirely in your browser. No backend, no accounts, no infra.
Every download includes a CLI that wires the server into Claude Code, Claude Desktop, VSCode, or Cursor in one command.
---
## Highlights
- **32 tool catalog · 187 MCP operations** — Stripe, GitHub, Slack, Notion, Linear, PostgreSQL, Cloudflare, AWS S3, Sentry, Discord, Figma, Brave Search, Anthropic API, Replicate, FFmpeg, Remotion, Google Calendar, X/Twitter, Vercel, generic HTTP/Fetch escape hatch, browser/Puppeteer, Gmail, YouTube, LinkedIn, Vimeo, ElevenLabs, fal.ai, OpenAI, Mailtrap, PDF tools, Google Maps, Thumbnail Studio.
- **Live inspector + curl bridge** — like ngrok + Postman for MCP. The wrapper proxies every client request, shows it in a real-time dashboard at `localhost:7474`, AND exposes an HTTP bridge so you can fire tool calls from curl, scripts, or the dashboard's built-in playground. Replay any past call, copy as curl, edit & resend. Logs to `mcpfactory.log.jsonl` + `.txt`.
- **One-command client wiring** — `npx mcpfactory connect claude-code` writes the right config in the right place. Targets: Claude Code (project + user), Claude Desktop (mac/win/linux), VSCode, Cursor.
- **OAuth helper** — `npx mcpfactory auth google-youtube` opens the browser, captures the redirect, writes refresh tokens to `.env`. Supported: YouTube, Gmail, Calendar, LinkedIn, X (PKCE).
- **Read-only mode** — every operation is tagged `safe / write / destructive`. Toggle `--read-only` at build time or `MCPFACTORY_READ_ONLY=1` at runtime to disable mutating tools.
- **OpenAPI import** — `npx tsx scripts/openapi-import.ts ` generates a working tool from any OpenAPI 3.x spec (verified against the Petstore: 19 operations from one URL).
- **Build customization** — custom server name, sub-selection of operations, lockfile (`mcpfactory.lock.json`) + `npx mcpfactory upgrade` to refresh.
- **Framework helpers** — `withProgress` (MCP `notifications/progress`), `cached` (TTL memoizer), `McpToolError` (typed errors with retry hints), `wrapHandler` (consistent envelope).
- **Tested** — per-tool smoke harness boots each generated server via real JSON-RPC. CI runs the whole catalog on every PR.
## Try it
```bash
npm install
npm run dev # http://localhost:3000
# In another terminal — build a test zip and verify it boots
npx tsx scripts/build-from-fs.ts stripe,github,fetch test-builds
cd test-builds/mcp-stripe-github-fetch
npm install
npx mcpfactory # interactive menu
```
## curl bridge
Every running inspector exposes an HTTP API at the dashboard port (default `7474`):
| Endpoint | Method | Body |
|---|---|---|
| `/api/tools` | GET | — — returns the live `tools/list` |
| `/api/call` | POST | `{ "name": "", "arguments": {...} }` — fires a `tools/call` |
| `/api/raw` | POST | `{ "method": "...", "params": {...} }` — arbitrary JSON-RPC |
| `/api/state` | GET | — — recent events ring buffer |
```bash
# Start the wrapper (auto-spawns the MCP server)
npx mcpfactory inspect --open # also opens the browser dashboard
# In another terminal — call any tool
curl -sX POST http://localhost:7474/api/call \
-H 'content-type: application/json' \
-d '{"name":"http_get","arguments":{"url":"https://api.github.com/zen"}}'
# Or the friendlier CLI
npx mcpfactory call http_get '{"url":"https://api.github.com/zen"}'
npx mcpfactory call stripe_get_balance
```
In the dashboard, click **▶ NEW REQUEST** for the playground form (tool dropdown + JSON args + send), or click any past call to **Replay** / **Edit & resend** / **Copy as curl**.
## How it works
```
Browser dashboard Generated build
┌────────────────────┐ ┌──────────────────────┐
│ pick tools │ ─────────▶ │ custom-mcp.zip │
│ click BUILD │ JSZip │ · src/, bin/ │
│ (no backend) │ │ · .env.example │
└────────────────────┘ │ · mcpfactory CLI │
└──────────────────────┘
│
▼
npm install && npx mcpfactory connect claude-code
│
▼
Claude Code uses your tools
```
The build runs entirely client-side. The dashboard fetches:
- `/manifest.json` — tool catalog metadata
- `/tool-source/...` — each selected tool's source files
- `/skeleton/...` — templates rendered into every build (package.json, src/index.ts, README, the CLI)
JSZip assembles them in the browser, your browser downloads the result.
## CLI commands (shipped in every build)
| Command | What it does |
|---|---|
| `npx mcpfactory` | Interactive menu |
| `npx mcpfactory env` | Walk through `.env` setup with prompts |
| `npx mcpfactory auth ` | OAuth flow (`google-youtube`, `google-gmail`, `google-calendar`, `linkedin`, `twitter`) |
| `npx mcpfactory connect [--inspect]` | Wire into Claude Code/Desktop, VSCode, Cursor |
| `npx mcpfactory inspect [--port N] [--open]` | Run the inspector standalone |
| `npx mcpfactory call [json-args]` | Fire a tool through the running inspector (the curl bridge) |
| `npx mcpfactory logs [--json]` | Tail `mcpfactory.log.txt` (or `.jsonl`) |
| `npx mcpfactory upgrade` | Show build manifest + how to refresh against latest catalog |
| `npx mcpfactory doctor` | Check env vars + integration paths |
| `npx mcpfactory start` | Run the MCP server (no inspector) |
## Repo layout
```
mcpfactory/
├── app/ Next.js dashboard
├── components/ Neo-brutalist React components
├── lib/
│ ├── manifest.ts Typed catalog (32 tools, 9 categories)
│ ├── builder.ts In-browser zip pipeline (JSZip + Promise.all)
│ ├── auth-type.ts Auth-level inference (oauth/api-key/none)
│ └── types.ts Tool / SafetyLevel / BuildLock interfaces
│
├── public/
│ ├── tool-source/ Tool source served as static assets
│ │ ├── tools/_framework.ts Shared helpers (withProgress, cached, errors, wrap)
│ │ ├── tools/.ts Per-tool API wrapper
│ │ └── register/.ts MCP tool registration with Zod schemas
│ └── skeleton/ Templates rendered into every build
│ └── bin/
│ ├── mcpfactory.mjs CLI (env / auth / connect / inspect / logs / upgrade / doctor)
│ ├── inspect-wrapper.mjs Live inspector (HTTP + SSE + JSONL/TXT logs)
│ └── oauth-helper.mjs OAuth helper (localhost callback, PKCE for X)
│
├── scripts/
│ ├── build-from-fs.ts CI-friendly local builder
│ ├── smoke-test.ts Per-tool smoke runs via real MCP protocol
│ ├── openapi-import.ts Generate tools from any OpenAPI 3.x spec
│ └── test-build.ts Live-server build (mirrors the browser builder)
│
├── .github/workflows/
│ ├── ci.yml Typecheck + sharded smoke tests on PR
│ └── pages.yml Auto-deploy dashboard to GitHub Pages
│
└── next.config.mjs Static export (output: 'export')
```
## Adding a new tool
Two paths.
**Hand-written** (full control):
1. Drop your tool source into `public/tool-source/tools/.ts` and matching `public/tool-source/register/.ts` (must export `registerTools(server)`).
2. Add a typed entry to `lib/manifest.ts` with `name`, `category`, `files`, `imports`, `registerCalls`, `deps`, `env`, optional `safety` map.
3. Run `npx tsx scripts/smoke-test.ts ` to verify it boots.
**From OpenAPI** (force multiplier):
```bash
npx tsx scripts/openapi-import.ts https://api.example.com/openapi.json \
--id example --name "Example API" --auth bearer --env EXAMPLE_TOKEN
```
This generates the tool, register, and a manifest entry. Tweak as needed.
## Production build
```bash
npm run build # static export to ./out/
```
Push to `main` → the included GitHub Action deploys `out/` to Pages.
For deployment under a subpath (e.g. `user.github.io/mcpfactory`), set:
```bash
NEXT_PUBLIC_BASE_PATH=/mcpfactory npm run build
```
The CI workflow auto-detects the repo name and sets this for you.
## Stack
| Piece | Tech |
|---|---|
| Dashboard | Next.js 14 + React 18 + TypeScript + Tailwind |
| Zip building | JSZip, in-browser |
| Generated server | TypeScript + `tsx` + `@modelcontextprotocol/sdk` |
| Shipped CLIs | Node.js (zero deps — built-ins only) |
| Inspector | Node `http` + Server-Sent Events |
| Hosting | GitHub Pages (static) |
## License
MIT.