Forem: Ricardo Rodrigues

# How I Built the MCP Composer — And Why It Was the Most Requested Feature at MCPNest

Ricardo Rodrigues — Sun, 19 Apr 2026 00:20:51 +0000

I launched MCPNest on April 4th, 2026. Within 48 hours, the most common question in my DMs wasn't "how do I find servers" or "why isn't my server listed."

It was: "How do I install multiple servers at once?"

That question became the MCP Composer.

The Problem No One Was Talking About

When people discover MCP servers, they don't install one. They install five. A developer setting up Claude for serious work typically wants:

A GitHub server (read repos, create issues, review PRs)
A database server (query Postgres or SQLite)
A file system server (read and write local files)
A documentation server (pull live docs from any library)
A search server (web or internal search)

That's five separate servers. Five separate JSON blocks. Five separate edits to claude_desktop_config.json.

The official config format looks like this:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "..." }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]
    }
  }
}

Writing this by hand is error-prone. A missing comma breaks everything. A wrong argument crashes Claude on startup. And when something goes wrong, the error messages are cryptic.

I watched people spend 30-45 minutes on something that should take 30 seconds. Platform engineers who manage CI/CD pipelines every day were struggling with a JSON config file.

That was the moment I decided to build the Composer.

Where the Idea Came From

I'm a Platform Engineer at a bank. During the day, I manage infrastructure tooling — the kind of work where you spend a lot of time thinking about developer experience. Why does it take a new engineer three days to set up their local environment? Why are there seventeen steps in the onboarding doc when there should be one?

When I started building MCPNest, I knew the discovery problem was obvious — everyone could see there was no central registry for MCP servers. But the installation problem was the hidden one.

The gap I saw was this: even if you found the right servers on MCPNest, you still had to manually construct the JSON config, copy it into the right file on your machine, restart Claude, and hope nothing broke.

That's too many steps. Too much friction between "I want this tool" and "this tool is running."

The Composer was my answer to that friction.

What the MCP Composer Does

The MCP Composer (available at mcpnest.io/compose) lets you build a complete multi-server MCP configuration in under 30 seconds — visually, without touching JSON.

Here's how it works:

Step 1: Search and add servers
You search the MCPNest catalogue of 7,561+ servers and add any combination to your config. Each server is shown with its compatibility, required arguments, and any environment variables it needs.

Step 2: Configure each server
For servers that need arguments (like a database URL, a file path, or an API key), the Composer shows you exactly what's needed. You fill in the values once. No looking up documentation.

Step 3: Choose your client
Select your target: Claude Desktop, Cursor, Windsurf, or VS Code. The Composer generates the exact config format for each client — they're slightly different, and getting the format wrong means nothing works.

Step 4: Copy or download
The complete config JSON is ready to paste. Or you can use Bundle Sharing to generate a link that anyone can use to replicate your exact setup in one click.

The Six Problems the Composer Solves

1. JSON syntax errors
The single biggest cause of "why isn't my MCP server working" is a malformed JSON config. A trailing comma, a missing bracket, wrong quote type — any of these breaks the entire file. The Composer generates syntactically valid JSON every time.

2. Wrong config format per client
Claude Desktop, Cursor, Windsurf, and VS Code each have slightly different config formats. Claude Desktop uses claude_desktop_config.json in one location on Mac, another on Windows. Cursor has its own format. The Composer knows all of them and generates the right one.

3. Missing required arguments
Many MCP servers require arguments — a database connection string, a file path, an API token. When you install manually, you often miss these and the server fails silently. The Composer shows every required argument upfront.

4. Multi-server conflicts
When you have ten servers in your config, one bad entry can prevent all of them from loading. The Composer validates the full config before you copy it, catching conflicts before they cause problems.

5. Knowledge barrier
Not everyone knows what npx -y does or why some servers use command: "node" and others use command: "npx". The Composer abstracts this — you see server names, not command syntax.

6. Sharing and replication
If you've built a good MCP stack, sharing it with your team means sending a JSON blob in Slack and hoping they paste it correctly. With Bundle Sharing, you share one link. They click it, they get your full config.

How to Use the MCP Composer

Go to mcpnest.io/compose. Here's a real example — building a developer stack from scratch:

Adding GitHub:
Search for "github", select github-mcp-server (official, 28,700+ stars). The Composer shows you need one environment variable: GITHUB_PERSONAL_ACCESS_TOKEN. Enter your token. Done.

Adding Postgres:
Search for "postgres", select the official server. The Composer asks for a connection string: postgresql://username:password@localhost:5432/mydb. Enter it. Done.

Adding Context7:
Search for "context7", add it. No configuration needed — it works immediately with no arguments. The Composer handles the command automatically.

Generating the config:
Switch to "Claude Desktop" tab. Click "Copy config". Paste into claude_desktop_config.json. Restart Claude.

Total time: under two minutes for a three-server setup that would have taken 20-30 minutes manually.

Bundle Sharing: The Feature Within the Feature

After I shipped the Composer, something unexpected happened. People started using it not just for themselves — but to share their stacks with others.

A developer would compose their perfect setup, generate a bundle link, and post it on Reddit or Twitter: "Here's my MCP stack for backend development." Others would click the link, get the full config ready to paste, and be up and running in seconds.

This became Bundle Sharing — a dedicated feature built on top of the Composer. You can browse shared bundles at mcpnest.io/bundle-sharing, or create your own with the "Share bundle" button in the Composer.

For teams, this is particularly powerful. A platform engineer sets up the approved MCP stack for their company, generates a bundle link, and shares it in the engineering onboarding doc. Every new hire gets the same setup, correctly configured, in one click.

What's Next for the Composer

The Composer currently handles local MCP servers — the ones you run with npx or node on your machine.

The next evolution is the Gateway, launching June 16, 2026. Instead of each developer running servers locally with their own config, the Gateway gives every workspace a single authenticated URL. One URL replaces the entire config. One click deploys approved servers to your whole team.

The Composer was the first step in making MCP servers accessible. The Gateway is the step that makes them governable.

Try It

The MCP Composer is free, requires no account, and works with Claude Desktop, Cursor, Windsurf, and VS Code.

mcpnest.io/compose

If you have a stack you love, generate a bundle and share it. I'd love to see what people are building.

And if something doesn't work — if a server config is wrong, if a client format is off, if the Composer is missing a server you need — email me: malasartes@mcpnest.io

Ricardo Rodrigues is the founder of MCPNest and a Platform Engineer at BCP in Porto, Portugal. MCPNest is the marketplace and governance layer for MCP servers — 7,561+ servers indexed, with Enterprise workspaces and a Gateway launching June 2026.

Tags: MCP, Model Context Protocol, Claude Desktop, Cursor, AI Tools, Developer Tools, MCP Composer

MCPNest Enterprise: The Private MCP Registry Your Team Has Been Missing

Ricardo Rodrigues — Thu, 16 Apr 2026 16:55:42 +0000

If you're using Claude, Cursor, or Windsurf with MCP servers, you've probably hit this wall: you find a great server, configure it locally, and then spend the next hour explaining to your colleagues how to do the same. JSON configs in Slack messages. "Did you add the right environment variable?" Version mismatches between machines. Someone installs the wrong server. IT has no idea what AI tools are running on company infrastructure.

MCPNest Enterprise solves this.

What Is MCPNest Enterprise?

MCPNest (mcpnest.io) is the marketplace for MCP servers — 7,561+ indexed, one-click install for Claude Desktop, Cursor, and Windsurf. Enterprise is the layer built on top of it for teams that need to manage MCP servers at scale, with governance, auditability, and control.

Think of it as the npm private registry for your team's MCP servers. Or Docker Hub with access control. The same idea: your team gets a curated, approved set of tools — without anyone editing JSON files manually.

The Core: Private Workspace

Every Enterprise workspace is a private environment that only your team can access. You create it, invite your colleagues, and from that point forward you have a single source of truth for which MCP servers your team uses.

No more "which version are you on?" No more "where's the config file for that?"

What lives inside a workspace:

Private server registry — add any MCP server (remote endpoint or local config) to your workspace. It stays internal and is never exposed publicly.
One registry URL — a single authenticated endpoint that your team points their Claude Desktop, Cursor, or Windsurf config to. One change on the server side, everyone gets it.
Version control per server — publish versions (v1.0.0, v1.1.0), track what changed, roll back if something breaks.
Audit log — every action is logged: who added a server, who published a version, who invited a member, when.
Health monitoring — the workspace runs health checks on every remote server. You know immediately when something is degraded or down, before your team starts filing bug reports.

Team Management

Enterprise workspaces have three roles: Owner, Admin, and Member.

The owner has full control. Admins can add servers, publish versions, and invite members. Members can install and use what's been approved for them — nothing more.

This matters for enterprise adoption. The platform engineer sets up the workspace and curates the approved servers. Developers self-serve within those guardrails. IT can see the audit log. Everyone wins.

Inviting a colleague is one email address. They get access immediately if they have an MCPNest account. Remove them just as easily — access is revoked instantly.

The Registry Endpoint

This is the most important technical feature.

Every workspace gets a unique authenticated URL:

https://mcpnest.io/api/registry/YOUR_WORKSPACE_TOKEN

Your team adds this to their Claude Desktop config once:

{
  "mcpServers": {
    "mcpnest-registry": {
      "command": "npx",
      "args": ["mcpnest-registry-client", "--url", "https://mcpnest.io/api/registry/YOUR_TOKEN"]
    }
  }
}

From that point forward, every server you add to the workspace is automatically available to everyone on the team. No individual config changes. No manual distribution. The registry is the single source of truth, and it updates centrally.

Version Control

MCP servers evolve. Endpoints change. Configs need updating. Without version control, you're back to the Slack message problem — "hey everyone, update your config to use the new endpoint."

With MCPNest Enterprise, you publish a new version to the workspace. Set the version number, write a changelog entry, update the install config if needed. Everyone on the team gets the update automatically through the registry endpoint.

If the new version breaks something, you can see exactly what changed and when. The audit log has the full history.

Health Monitoring

Every workspace has a live health dashboard showing which servers are Healthy, Degraded, or Down.

Health checks run automatically every 60 minutes against every remote endpoint in your workspace. If a server goes degraded — timeout, authentication failure, unexpected response — you see it in the dashboard immediately. Before your developers start wondering why Claude isn't responding to tool calls.

You can also trigger a manual health check at any time.

Audit Log

Every action in a workspace is logged with the user, the action type, the timestamp, and any relevant details.

Workspace created
Server added
Version published
Member invited
Member removed
Health check run

This isn't just for debugging. It's for compliance. Enterprise teams need to know what AI tools are running on their infrastructure and who approved them. The audit log gives you that.

The Customisable Dashboard

The workspace overview is designed to show what matters to your team, not a generic set of metrics.

You get five KPI cards — Servers, Members, Installs, Events, Remote — and a grid of widgets you can toggle on and off: the server list, health overview, activity feed, registry endpoint, team members, and quick actions to MCPNest tools.

Your workspace, your layout. Preferences are saved per workspace.

The dashboard also supports light and dark mode — persisted in your browser across all workspace pages.

What's Coming

Enterprise is the foundation. What's being built on top of it:

MCP Gateway (launching June 2026) — one URL per workspace, with routing, authentication, and logging for every tool call. The difference between the current registry and the Gateway is observability: with the Gateway, you see every tool invocation, every parameter, every response. Full auditability at the protocol level.

Invite emails via Resend — when you invite a team member, they receive a proper onboarding email.

GitHub sync — link a server to a GitHub repository and the workspace automatically picks up new releases.

Why This Matters

MCP is the standard that's emerging for how AI agents connect to tools. Every serious AI-powered development team will eventually need to manage a set of MCP servers — which ones are approved, which versions are running, who has access to what.

Right now, most teams are doing this manually. JSON configs, documentation wikis, Slack messages. That doesn't scale past five people.

MCPNest Enterprise is the infrastructure layer that makes MCP adoption manageable at team scale. The same way npm private registries made Node.js dependency management manageable for enterprise teams.

Get Started

MCPNest Enterprise is available at mcpnest.io

Create a workspace, add your first server, and share the registry URL with your team.

If you're building a team AI tooling stack and want to talk, reach out at malasartes@mcpnest.io.

Ricardo Rodrigues is the founder of MCPNest and a Platform Engineer at BCP. MCPNest is built in Porto, Portugal.

MCPNest - I built an MCP server marketplace in 7 days.

Ricardo Rodrigues — Tue, 14 Apr 2026 22:46:59 +0000

I'm a Platform Engineer at a bank in Porto, Portugal.

On 3 of April I had an idea. Today it's a live product with 7,554 servers, partnerships with Railpush, Grafana and other coming.

Here's the full story.

The problem

The MCP (Model Context Protocol) ecosystem was exploding. Every week a new server appeared on GitHub, got 500 stars, and disappeared into the void.

Developers wanting to extend Claude, Cursor, or Windsurf had to dig through GitHub repos, Reddit posts, and scattered READMEs.

There was no discovery layer. No App Store for MCP.

The plan

Build the npm registry for MCP servers. Fast.

The criteria: buildable in days, real market timing.
MCPNest won.

What I built

Starting from zero, in two weeks:

Discovery
7,554+ MCP servers indexed from the official Anthropic registry and GitHub. Search by name, category, client compatibility. Quality Score A–F. Security badges — Verified, No Auth, Local Process, Remote.

Install
One-click install configs for Claude Desktop, Cursor, Windsurf, and VS Code. Copy one JSON snippet and you're done.

Bundle Sharing
Create a named bundle of multiple MCP servers and share it as a single link. Someone clicks it, gets the combined config for all servers at once. Useful for teams that want to share a standard MCP setup without going through the full Enterprise tier.

MCP Composer
Build your full multi-server config visually. Select servers, fill in your keys, copy once.

MCP Generator ← the one I'm most proud of
Describe what you want in plain english. Claude writes the full TypeScript MCP server — tool schema, error handling, stdio transport — plus the install config. From idea to published server in under a minute.

Collections
Curated starter packs. Install a full stack in one config.

Enterprise Workspace
This is the one I'm betting on long term.

A private MCP registry for teams. The idea came from a conversation with an AI leader at a large enterprise who said: "IT and security won't let us install third-party MCP. We just need the recipe to build it ourselves."
What's live:

Private registry with a single URL — your whole team points their config to it
Version control — publish v1.1 and every team member gets the updated config immediately, no manual updates
GitHub sync — link a repo and pull the latest version with one click
Health monitoring — hourly cron checks all remote server endpoints, updates UP/DOWN status automatically
Audit log — every action tracked: who added what, when, from where
Team management — owner, admin, and member roles
Invite by email — add team members who already have an MCPNest account

The GTM strategy is bottom-up, like Slack. Individual enterprise employees start using it via open source. They build their own configs, use the Composer, share bundles with colleagues. When IT notices, the Enterprise tier gives them the governance layer they need — SSO, audit logs, private registry, version control.

Credential Manager
Store API keys per server. The biggest friction point in MCP tooling — solved.

Publisher Analytics
30-day install charts, client breakdown, weekly performance. Know what's working.

Reviews + Ratings
The first MCP marketplace with community reviews.

The stack

Next.js 16 with Turbopack
Supabase (database + auth)
Vercel (hosting)
Stripe (payments)
FastAPI crawler on Railway
Built almost entirely in Claude sessions

The honest part

Features are the easy part. Distribution is hard.

650 visitors a week is not enough. The product is good. The challenge now is getting people to find it.

If you're building with MCP — mcpnest.io

If you publish MCP servers — list yours

Solo founder. Platform engineer by day. Building as fast as I can.