convez.ai
MCP ServerIntegração & APIsIntermediário
Markgatcha

Universal MCP Toolkit

Markgatcha/universal-mcp-toolkit

Monorepo de MCP servers prontos para produção com CLI unificada

Ver no GitHub
BomPluginScore · de 0 a 100

Monorepo canônico de código aberto com 28 servidores MCP prontos para produção. Oferece CLI unificada para instalação, configuração, execução e diagnóstico de integrações com GitHub, Slack, Notion, bancos de dados, plataformas em nuvem e APIs. Implementação de referência para ecossistema MCP com suporte a Stdio e HTTP+SSE.

Instalação

$npx convez-ai Markgatcha/universal-mcp-toolkit

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
16
Forks
2
Acompanhando
3
Saúde
100%
Último commit
há 1 semana
Versão
v1.7.0
Issues abertas
1
Contribuidores
3

Casos de uso

  • Integrar Claude Desktop com GitHub, Slack e Notion de forma padronizada
  • Implementar servidores MCP customizados seguindo arquitetura de referência
  • Configurar múltiplas integrações em um único lugar sem fragmentação

Veredito

Projeto sólido que endereça um problema real no ecossistema MCP: fragmentação e falta de padrões. 28 servers com arquitetura consistente, CLI bem pensada e suporte a produção. Recomendado como base para quem quer MCP sério sem reinventar a roda.

README

A tradução para o português deste README ainda está na fila.

universal-mcp-toolkit

CI License: MIT TypeScript pnpm npm npm downloads universal-mcp-toolkit MCP server PRs Welcome Available on CodeGuilds

The canonical open-source monorepo for production-ready Model Context Protocol servers.

If you have ever wanted one place to find great MCP servers for GitHub, Slack, Notion, databases, cloud platforms, research sources, and local files without stitching together a dozen half-finished repos, this is it.

⚡ Quick Start

The fastest way to get going:

# See all 28 available servers
npx universal-mcp-toolkit list

# Interactive setup — pick your servers, choose transport, write config
npx universal-mcp-toolkit install

# Generate a Claude Desktop config snippet
npx universal-mcp-toolkit config --server github slack filesystem --target claude-desktop

# Run a server locally
npx universal-mcp-toolkit run github --transport stdio

# Check your environment before debugging
npx universal-mcp-toolkit doctor github

For a guided setup walkthrough, open docs/getting-started.html.

Or install globally:

npm install -g universal-mcp-toolkit
umt list

Why this exists

The MCP ecosystem is exploding, but the developer experience is still fragmented.

  • Most repos solve one narrow integration.
  • Many servers stop at a demo-quality tool or two.
  • Transport support, auth handling, docs, and packaging are wildly inconsistent.
  • There is no obvious reference implementation that shows how a serious MCP monorepo should feel.

universal-mcp-toolkit fixes that with one opinionated, high-quality Turborepo:

  • 27 production-focused MCP servers
  • One shared strict-mode TypeScript core
  • One polished CLI for install, config, run, and diagnostics
  • Consistent Zod validation, structured errors, and pino logging
  • Stdio plus HTTP+SSE support across the toolkit
  • Discovery-friendly .well-known/mcp-server.json server cards

What makes this worth starring

  • Real developer utility right now
  • Great default ergonomics for Claude Desktop, Cursor, and local workflows
  • A single architecture you can learn once and extend everywhere
  • Strong package hygiene with exports maps, keywords, build scripts, and test hooks
  • A repo designed to be both a product and a reference implementation

The short version

CategoryWhat you get
Core runtime@universal-mcp-toolkit/core with typed tool registration, env loading, Zod validation, pino logging, stdio and HTTP+SSE runtime bootstrapping
Unified CLIuniversal-mcp-toolkit with list, config, install, run, and doctor
Collaboration serversGitHub, Notion, Slack, Linear, Jira, Discord, Trello
Productivity serversGoogle Calendar, Google Drive
Media and commerce serversSpotify, Stripe
Data serversPostgreSQL, MongoDB, Redis, Supabase, Airtable
Platform serversVercel, Cloudflare Workers, Docker, npm Registry
Research and local serversHacker News, arXiv, FileSystem
Memory serverMemOS local persistent memory

Experimental companion packages under the @contextcore/* scope currently include Notion, Slack, Playwright, and OpenAI variants used for a separate publish line and testing lane.

Comparison

OptionBreadthDX qualityShared architectureHost config helpDocumentation polish
universal-mcp-toolkit27 servers in one monorepoHighYesYesHigh
Single-service MCP reposNarrowVariesNoRarelyVaries
Personal one-off scriptsVery narrowLowNoNoUsually none

Supported servers

ServerFocusPrimary required env
GitHubRepositories, pull requests, workflows, searchGITHUB_TOKEN
NotionPages, databases, structured docsNOTION_TOKEN
SlackChannels, history, messagingSLACK_BOT_TOKEN
LinearIssue triage and planningLINEAR_API_KEY
JiraTickets, workflow transitions, incident triageJIRA_BASE_URL, JIRA_EMAIL, JIRA_API_TOKEN
Google CalendarCalendars, events, meeting workflowsGOOGLE_CALENDAR_ACCESS_TOKEN
Google DriveSearch, metadata, exportsGOOGLE_DRIVE_ACCESS_TOKEN
SpotifyPlayback, search, playlistsSPOTIFY_ACCESS_TOKEN
StripeCustomers, invoices, subscriptionsSTRIPE_SECRET_KEY
PostgreSQLTables, schema inspection, guarded queriesPOSTGRESQL_URL
MongoDBCollections, document reads, aggregationMONGODB_URI
RedisKeys, TTLs, cache diagnosticsREDIS_URL
SupabaseTables, storage, project accessSUPABASE_URL, SUPABASE_KEY
VercelProjects, deployments, environmentsVERCEL_TOKEN
Cloudflare WorkersWorkers, routes, edge rolloutsCLOUDFLARE_API_TOKEN, CLOUDFLARE_ACCOUNT_ID
DockerContainers, images, daemon statenone required
npm RegistrySearch, metadata, versions, dist-tagsnone required
Hacker NewsTop stories, search, threadsnone required
arXivPaper search and reading listsnone required
FileSystemSafe local file search, reads, writesFILESYSTEM_ROOTS
MemOSLocal-first persistent memory over MCPnone required
DiscordGuilds, channels, messages, membersDISCORD_BOT_TOKEN
AirtableTables, records, CRUD operationsAIRTABLE_API_KEY, AIRTABLE_BASE_ID
TrelloBoards, lists, cards, archivingTRELLO_API_KEY, TRELLO_TOKEN
PlaywrightBrowser automation and web scrapingPLAYWRIGHT_BROWSERS_PATH (optional)
OpenAIChat completions, embeddings, and model queriesOPENAI_API_KEY

Some servers also expose optional tuning variables such as POSTGRESQL_ALLOW_WRITES, REDIS_ALLOW_WRITES, MONGODB_ALLOW_WRITE_PIPELINES, VERCEL_TEAM_ID, or FILESYSTEM_MAX_READ_BYTES. The root .env.example includes the most useful knobs.

Repository layout

universal-mcp-toolkit/
├─ packages/
│  ├─ core/
│  └─ cli/
├─ docs/
│  ├─ index.html
│  └─ getting-started.html
├─ servers/
│  ├─ github/
│  ├─ notion/
│  ├─ slack/
│  ├─ linear/
│  ├─ jira/
│  ├─ google-calendar/
│  ├─ google-drive/
│  ├─ spotify/
│  ├─ stripe/
│  ├─ postgresql/
│  ├─ mongodb/
│  ├─ redis/
│  ├─ supabase/
│  ├─ vercel/
│  ├─ cloudflare-workers/
│  ├─ docker/
│  ├─ npm-registry/
│  ├─ hackernews/
│  ├─ arxiv/
│  ├─ discord/
│  ├─ airtable/
│  ├─ trello/
│  └─ filesystem/
├─ turbo.json
├─ pnpm-workspace.yaml
└─ README.md

Quick start

Clone and install

git clone https://github.com/Markgatcha/universal-mcp-toolkit.git
cd universal-mcp-toolkit
corepack pnpm install

Build the workspace

corepack pnpm build

Explore what is available

corepack pnpm --filter universal-mcp-toolkit exec umt list

Generate a host config snippet

corepack pnpm --filter universal-mcp-toolkit exec umt config --server github slack filesystem --target claude-desktop --mode workspace

Run a server locally

corepack pnpm --filter universal-mcp-toolkit exec umt run github --transport stdio

Check your environment

corepack pnpm --filter universal-mcp-toolkit exec umt doctor github

CLI experience

The CLI is designed to feel like a real product, not a pile of scripts.

umt list

See every available server, grouped by category with required environment variables and descriptions.

umt config

Generate ready-to-paste JSON for Claude Desktop, Cursor, or any MCP-compatible host config flow.

umt install

Run an interactive setup flow, choose servers, choose npx or workspace mode, write the result to disk, and save the profile for later reference.

umt run

Launch any built workspace server locally with stdio or HTTP+SSE transport.

The --supervise flag enables crash-loop detection and automatic restarts:

umt run github --transport stdio --supervise

If the server crashes 5 times within 60 seconds it stops retrying. Logs are written to the state directory under logs/<serverId>.log and can be tailed with umt logs <serverId>.

umt doctor

Check build output, config state, and required environment variables before you waste time debugging a missing token or missing dist file.

New in v1.1.0+

CommandWhat it does
umt statusShow currently running umt server processes and their PIDs
umt logs <server>Tail the log file for a specific server
umt test <server>Run a live end-to-end MCP handshake test against a server
umt conformance [server]Check registry config and live stdio handshakes where local build output exists
umt search <query>Search available servers by name, description, and tags
umt initInteractive setup wizard for new users
umt updateCheck npm for a newer version of the CLI and optionally install it
umt upgradeCheck npm for newer versions of individual server packages
umt exportExport install profiles to a portable JSON file (no secrets included)
umt export-configExport current server config in a specific client format
umt linkLink a local MemOS/ContextCore SQLite memory database
umt profile create <name>Create a new named profile with interactive wizard
umt profile show [name]Show profile configuration details
umt profile export <name>Export a named profile to a JSON file
umt profile import <path>Import a profile from a JSON file

Configuration examples

Claude Desktop

Paste a generated snippet into your Claude Desktop config file. On Windows, that is commonly:

%APPDATA%\Claude\claude_desktop_config.json

On macOS, use ~/Library/Application Support/Claude/claude_desktop_config.json. On Linux, use ~/.config/Claude/claude_desktop_config.json.

The JSON examples below use literal placeholders like ${GITHUB_TOKEN}. Replace them with real values before pasting into your host config.

Example:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@universal-mcp-toolkit/server-github", "--transport", "stdio"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@universal-mcp-toolkit/server-filesystem", "--transport", "stdio"],
      "env": {
        "FILESYSTEM_ROOTS": "${FILESYSTEM_ROOTS}"
      }
    }
  }
}

Cursor

Generate the same mcpServers snippet and place it into the MCP config file you use for Cursor. The CLI keeps the format host-friendly and consistent, so the same generated JSON works well as a reusable snippet:

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@universal-mcp-toolkit/server-slack", "--transport", "stdio"],
      "env": {
        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}"
      }
    },
    "linear": {
      "command": "npx",
      "args": ["-y", "@universal-mcp-toolkit/server-linear", "--transport", "stdio"],
      "env": {
        "LINEAR_API_KEY": "${LINEAR_API_KEY}"
      }
    }
  }
}

Transport model

Every server in the toolkit is designed around the same transport story:

  • stdio for local child-process integrations
  • HTTP+SSE for remote or browser-adjacent integrations
  • discovery metadata exposed through .well-known/mcp-server.json

The shared core handles runtime bootstrapping, logging, env loading, and tool registration so every server behaves consistently.

Core package

@universal-mcp-toolkit/core is the part you will want to study if you are building your own MCP servers.

It includes:

  • ToolkitServer base class
  • defineTool<TInput, TOutput> helper
  • loadEnv() for strict configuration validation
  • HttpServiceClient for typed fetch-based integrations
  • createServerCard() for discovery metadata
  • parseRuntimeOptions() and runToolkitServer() for stdio and HTTP+SSE launch flows
  • pino logging configured for stderr-safe server operation

Engineering standards

  • TypeScript strict mode across the workspace
  • Zod schemas for input and output validation
  • Explicit structured errors for config, validation, and upstream failures
  • Consistent package manifests with exports maps and keywords
  • Server cards under .well-known/
  • Turborepo orchestration for build, typecheck, test, and clean flows

Release philosophy

This repo is meant to be the reference implementation developers point to when they ask:

  • What should a serious MCP monorepo look like?
  • How should server packages be documented and discovered?
  • How do you keep 20 integrations consistent without turning the codebase into a mess?

The answer should be: clone this repo, run the CLI, read the core package, and adapt the parts you need.

Development workflow

corepack pnpm install
corepack pnpm build
corepack pnpm typecheck
corepack pnpm test

Bun (also supported)

bun install
bun run build
bun run packages/cli/dist/index.js --version

Use Turbo filters when you only want to work on one package:

corepack pnpm --filter @universal-mcp-toolkit/core build
corepack pnpm --filter universal-mcp-toolkit typecheck
corepack pnpm --filter @universal-mcp-toolkit/server-github test

If you only want the onboarding path, start with docs/getting-started.html.

Package highlights

packages/core

Shared runtime primitives and strict abstractions for server authors.

packages/cli

The operator console for listing, configuring, installing, running, and diagnosing the entire toolkit.

servers/*

27 independently publishable MCP server packages that all share the same operational shape.

Roadmap direction

The monorepo is intentionally structured so it can grow without losing coherence.

  • Add more servers without inventing a new architecture every time
  • Improve server cards as discovery standards evolve
  • Expand host config templates as more MCP clients standardize their formats
  • Deepen smoke and contract tests across transports

Community

Please read CODE_OF_CONDUCT.md before participating in issues, pull requests, reviews, or discussions. The project aims to stay both technically rigorous and welcoming to contributors at every experience level.

Persistent Memory

Pair universal-mcp-toolkit with MemOS for persistent, graph-based memory across agent sessions.

# Add persistent memory to your MCP agents
pip install memos
npm install @mem-os/sdk

# Generate a ready-to-paste MemOS MCP config
npx universal-mcp-toolkit link memos --db-path ~/.memos/memos.db

MemOS acts as the memory layer for your MCP stack — every tool call, result, and context your agent produces can be stored, retrieved, and searched across restarts and sessions. The MemOS MCP adapter runs through npx -y @mem-os/sdk mcp.

LayerToolRole
Transport & Toolsuniversal-mcp-toolkitMCP protocol, server registry, tool routing
Memory & PersistenceMemOSGraph-based persistent memory across sessions
LLM InferenceOllama / any LLMLocal model execution

⭐ Star History

Star History Chart


💬 Used By the Community

Building something with universal-mcp-toolkit? We'd love to know.

Open a Discussion and tell us:

  • What you're building
  • Which servers you're using
  • Any integrations or workflows you've set up

You might get featured here.

Known uses

  • Claude Desktop + GitHub + FileSystem — local dev assistant that reads repos and writes to disk
  • Cursor + PostgreSQL + Supabase — database-aware AI code completion
  • Paired with MemOS — persistent agent memory across sessions

📦 Show & Tell

If you've created a custom server, workflow, or integration using this toolkit as a base, open a PR to add it to the Wiki or start a Discussion. The best examples will be highlighted in the README.


License

MIT — see LICENSE for full terms.

Ver o original no GitHub

Bom para

Relacionados