DEV Community: curatedmcp

Spec-Driven Development Renamed an Old Problem. It Didn't Solve It. tags: ai, productivity, discuss, open source

curatedmcp — Sun, 21 Jun 2026 23:22:35 +0000

TL;DR: Spec Kit, OpenSpec, BMAD, Kiro — all of it is built on the assumption that a spec can stay the source of truth. It can't, for the same reason design docs and wikis never stayed current either. I think the interesting unsolved problem in this space isn't "more rigorous specs," it's "specs that don't require a human to remember to update them." Curious if people running these in production agree.

The pitch everyone's making right now

Spec-driven development has become the default answer to "AI agents write plausible-looking code that's subtly wrong." The idea: stop prompting, write a structured spec, let the agent execute against it, review the diff. GitHub Spec Kit has 90K+ stars and /speckit.specify → /speckit.plan → /speckit.tasks → /speckit.implement is basically a known workflow at this point. OpenSpec does the same thing lighter, with delta specs and openspec validate --strict. BMAD goes the other direction and simulates a full 12-agent team. AWS built an entire IDE (Kiro) around the idea. Tessl raised $125M on it.

It's not hype for no reason — it works better than raw prompting for a lot of real cases. But I've been going deep on this for the last few weeks, reading every practitioner write-up I can find instead of just the vendor pages, and one problem keeps showing up that none of these tools actually solve.

The problem: keeping the spec true is the same problem we've had since READMEs

We've tried to keep documentation in sync with code for 20+ years — design docs, architecture wikis, READMEs. It's never worked, for a boring reason: editing the code is fast and gets you something shipped, editing the doc is slow and gets you nothing visible. When a team is moving, the doc loses every time.

SDD just gives the same artifact a new name and calls it "the source of truth." But the asymmetry is identical. You're three tasks into a spec, the agent hits a constraint nobody documented, fixes it inline, ships it — and the spec still describes the old plan. Multiple people running this in production describe specs drifting within days, not months. None of the major frameworks have a real answer for this beyond "discipline" — which is exactly the thing that's failed every previous time we asked for it.

Even the premise has a real critique

Kent Beck's objection (picked up by Martin Fowler in January) is worth sitting with: most SDD write-ups assume you write the whole spec before implementation starts, which quietly assumes you won't learn anything during implementation that should change the spec. That's a strange assumption to build a methodology on — it's the opposite of the feedback-loop principle XP was built around. Fowler's point was that AI should speed up the feedback loop, not become an excuse to front-load more upfront documentation. ThoughtWorks' Radar flagged basically the same risk: heavy upfront specs trending toward big-bang releases, which is the exact failure mode agile exists to prevent.

A spec can pass every check and still be wrong

One account that stuck with me: a dev ran a real multi-month project fully spec-driven. Thorough specs, the agent built exactly what was specified, every acceptance criterion passed. The system was still wrong, because the spec couldn't capture the tacit, runtime, cross-system knowledge that only shows up once you're actually building. He changed one infra decision mid-project and the entire downstream spec graph broke, because everything after that point had silently inherited an assumption that no longer held.

And independently — Scott Logic ran a real SDD workflow against a real project and got: ~10x slower, more ceremony, same number of bugs as their normal process. I don't think that means SDD is useless. I think it means the rigor itself isn't the bottleneck people assume it is.

What I think is actually underexplored

Not another framework asking teams to write more documents more carefully. Something closer to: infer and update the spec from what the code and the running system actually do, the same way you'd treat generated docs or a lockfile — maintained automatically, not maintained by someone remembering to do it.

I don't have a working version of this, and I'm not sure it's even tractable at the granularity you'd need for it to be useful (anyone who's tried to auto-generate accurate architecture diagrams from a real codebase knows how that usually goes). I'm putting this out mostly because I'd rather find out it's a dead end from people who've actually hit this wall than after building something.

Genuinely curious, if you're running any of these in prod:

Does your spec survive past week 2-3, or does it quietly become aspirational?
When it drifts, what's the actual trigger — a missed edge case, a changed dependency, a scope call nobody backported into the spec?
Has anyone tried generating/updating specs from code or telemetry instead of writing them forward? Did it work, or did it just produce noise?
If you've used openspec validate --strict or Spec Kit's constitution model in anger — where did it actually hold up, and where did it just add ceremony?

Not pitching anything here, genuinely trying to figure out if this is a real gap or if I'm missing a tool/pattern that already handles it.

The 2026–2030 EU E-Invoicing Mandate: A Developer's Guide

curatedmcp — Thu, 18 Jun 2026 22:37:21 +0000

Between 2024 and 2030, emailing a PDF invoice to another EU business stops being legal in
most member states. Structured, machine-readable e-invoicing becomes mandatory — country by
country, on different dates, in different file formats, all derived from a single European
standard. If your software touches European revenue, this is the kind of change that quietly
breaks production the day an invoice fails for a major client.

Here's the vendor-neutral map: what's coming, when, and what it means for the people who have
to build for it.

Why this is happening now

The EU loses an estimated €93 billion a year to VAT fraud, much of it through the simplest
trick there is: invoices that exist on one side of a transaction but not the other. Paper and
PDF invoices are invisible to tax authorities until an audit, sometimes years later.

The fix governments converged on is structured e-invoicing with near-real-time reporting —
the invoice becomes a machine-readable document the tax administration can see as it's issued.
Italy proved the model: after mandating e-invoicing through its Sistema di Interscambio (SdI)
in 2019, it recovered billions in previously-lost VAT. Every other member state took notice.

ViDA: the EU-wide backstop of 2030

VAT in the Digital Age (ViDA), adopted in 2025, makes the patchwork coherent:

From 2030, structured e-invoicing based on EN 16931 becomes the default for intra-EU B2B, paired with Digital Reporting Requirements (DRR).
Member states no longer need EU permission to impose domestic mandates — which is exactly why so many are moving now, ahead of 2030.
Existing national systems must converge toward the EN 16931 baseline.

The practical takeaway: 2030 is the backstop, but the real work happens in 2026–2028, when
the largest economies switch on their domestic mandates.

EN 16931: the one standard underneath all of them

This is the single most important thing to understand. EN 16931 defines the semantic data
model of an electronic invoice — what fields exist, what they mean, and the business rules
(the BR-* and BR-CO-* constraints) every compliant invoice must satisfy.

Every national format is a CIUS (Core Invoice Usage Specification) — a country-specific
profile layered on top of EN 16931. FatturaPA, RO e-Factura, XRechnung, Factur-X, Peppol BIS,
KSeF: different syntaxes (UBL XML, UN/CEFACT CII, hybrid PDF/XML), but the same semantic core
and the same business rules underneath.

Country-by-country deadlines

Country	When	Scope	Format
🇮🇹 Italy	Live (since 2019)	B2B + B2C via SdI	FatturaPA (XML)
🇷🇴 Romania	Live (2024)	B2B mandatory	RO e-Factura (UBL / CIUS-RO)
🇵🇱 Poland	2026 (phased)	B2B via KSeF	FA(3) structured XML
🇧🇪 Belgium	Jan 2026	B2B mandatory	Peppol BIS 3.0 (UBL)
🇫🇷 France	2026–2027 (phased)	B2B receive + e-reporting	Factur-X / UBL / CII
🇩🇪 Germany	2025–2028 (phased)	B2B receive → send	XRechnung / ZUGFeRD
🇪🇸 Spain	2026–2027 (expected)	B2B (Crea y Crece)	Facturae / UBL / EDIFACT
🇪🇺 EU-wide	2030 (ViDA)	Cross-border B2B + DRR	EN 16931 baseline

Most mandates are phased by company size (large taxpayers first) and many begin with a
receive obligation before a send one. Planning anchors, not legal advice — always confirm
against the relevant tax authority.

What actually breaks in production

Teams that have already migrated report the same failure modes:

VAT category logic (BR-CO rules). The most common rejections. Tax category, rate, exemption reason codes and the totals derived from them must be internally consistent — systems that "round to make it balance" fail here.
Mandatory identifiers. Missing CustomizationID, buyer/seller VAT IDs, or a scheme code that doesn't match the country profile.
Calculation drift. Line totals, document totals and tax subtotals must reconcile to the cent. Floating-point math produces off-by-a-cent rejections at scale.
Code list violations. Currency, country, unit-of-measure and payment-means codes must come from the official EN 16931 code lists, not free text.
Syntax vs. semantics confusion. An invoice can be valid XML and still be an invalid invoice. XSD checks the shape; only the Schematron business rules check whether it's a lawful EN 16931 document.

The migration checklist

Map your countries. List every member state you invoice and its mandate date.
Pick your syntax per country. UBL 2.1 covers most; add CII / hybrid where required.
Validate against EN 16931 first. Get the semantic core right before national CIUS rules.
Automate validation in CI and at the API boundary. Reject bad invoices before they reach a tax authority, not after.
Plan for the network layer. Many mandates route through Peppol or a national platform (SdI, KSeF, Chorus Pro). Validation is necessary but separate from transport.
Keep audit trails. DRR means you must show what you sent and when.

Where validation fits

Validation is the one piece every team needs regardless of country, platform, or accounting
system — and it's exactly the piece that's easy to get subtly wrong. I'm building
InvoiceHub, a developer-first REST API that runs the official CEN
EN 16931 Schematron (the same rules the tax authorities use) and returns precise, rule-level
results — including which BR-* rule failed and why. One HTTP call, a free tier, instant key.

Full guide with the contents above lives here: https://invoicehub.dev/whitepaper

If you've dealt with Peppol or national tax APIs in Germany, France, Spain, Poland, Belgium, or
Italy — how are you handling the fragmentation? Curious what's working.

Redis MCP: Give Your AI Agent Full Access to Redis — Strings, Lists, Hashes, Queues, and Real-Time Pub/Sub

curatedmcp — Sat, 13 Jun 2026 10:52:22 +0000

Redis MCP: Give Your AI Agent Full Access to Redis — Strings, Lists, Hashes, Queues, and Real-Time Pub/Sub

What It Does

Redis MCP bridges AI agents and Redis, letting Claude, Cursor, and other AI tools read and write to your Redis instance using natural language. Instead of manually writing Redis commands, you can ask your AI agent to "get the user session for ID 42" or "add this job to the processing queue" — and it handles the Redis operations.

The server supports the full Redis API: strings with TTL, lists (perfect for queues), hashes for structured data, sets for unique collections, and sorted sets for leaderboards. You also get key inspection, transactions, Lua scripting, and pub/sub messaging. Works with Redis, Redis Cluster, Sentinel, and managed services like Upstash, AWS ElastiCache, and Azure Cache.

Why this matters: AI agents can now manage application state, handle rate limits, orchestrate job queues, and subscribe to real-time channels — all without you writing boilerplate code.

How to Install

uvx mcp-server-redis

Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "redis-mcp": {
      "command": "uvx mcp-server-redis",
      "env": {
        "REDIS_URL": "redis://localhost:6379"
      }
    }
  }
}

Point REDIS_URL to your Redis instance. Restart Claude Desktop and you're live.

Real-World Use Cases

Session & Cache Debugging: Ask Claude to fetch and inspect cached user sessions, clear stale keys, or check TTL expiry — useful when troubleshooting auth or personalization bugs.
Queue Management: Have your AI agent monitor job queues (LPUSH/RPOP), move failed jobs to a retry list, or peek at pending tasks without touching production code.
Rate Limit Enforcement: Build dynamic rate limiters where the agent increments counters with TTL, checks thresholds, and reports back — all in one conversation.

Full install guides for Claude Desktop, Cursor, Windsurf, and more at CuratedMCP.

Anthropic Claude MCP: Build Multi-Agent Workflows Inside Claude

curatedmcp — Thu, 11 Jun 2026 10:26:40 +0000

Anthropic Claude MCP: Build Multi-Agent Workflows Inside Claude

What It Does

The Anthropic Claude MCP server lets you invoke Claude models as tools from within another Claude session—turning a single agent into a coordinated multi-agent system. Instead of routing between separate API calls or third-party services, you can now nest Claude instances with specialized roles, each running its own system prompt, temperature settings, and model choice.

This unlocks clean architectural patterns: an orchestrator Claude that breaks down complex tasks, delegates to a Haiku instance for quick triage, spins up Opus for deep reasoning on specific subtasks, and chains results back together—all without leaving your conversation.

The server supports Haiku, Sonnet, and Opus, giving you granular control over speed-vs-capability tradeoffs. Built-in prompt caching keeps token costs reasonable when reusing the same system prompts across multiple calls. You get full parameter control: temperature, max_tokens, and streaming support for long-form outputs.

How to Install

npx -y @anthropic-ai/mcp

Add to your Claude Desktop config:

{
  "mcpServers": {
    "anthropic-claude-mcp": {
      "command": "npx -y @anthropic-ai/mcp"
    }
  }
}

Once installed, Claude gains access to the Claude call tool and can invoke sub-agents directly within the conversation.

Real-World Use Cases

Code review + refactoring pipeline: Main Claude generates initial code, then spins up a second Claude with a "code critic" system prompt to review for bugs, performance, and style—both running in parallel, results merged back for refinement.
Legal document analysis: Route contract review to a Claude instance with legal domain expertise (via system prompt), while the orchestrator handles document triage, summarization, and risk flagging—specialised personas for specialized tasks.
Parallel research and synthesis: Split a research task across multiple Claude calls (market analysis, competitive landscape, technical deep-dive) running simultaneously, then have the main agent synthesize findings into a cohesive report.

Full install guides for Claude Desktop, Cursor, Windsurf, and more at CuratedMCP.

I scanned my laptop for shadow MCP servers

curatedmcp — Wed, 10 Jun 2026 15:14:29 +0000

I run a curated MCP catalog, and the most common thing I hear from security
folks is: "we have no idea what MCP servers our engineers have installed."

MCP configs are scattered across every AI client — ~/.claude.json,
.mcp.json, ~/.cursor/mcp.json, Windsurf's mcp_config.json, VS Code's
mcp.json, Gemini's settings.json. Each server in those files is software
that can read files, hold API tokens in plaintext, and reach the network.
Server-side AI gateways never see any of it, because it runs on laptops.

So: a single command that finds all of them and flags the risky ones.

npx -y @curatedmcp/auditor

It scans the known config locations for Claude Code, Claude Desktop,
Cursor, Windsurf, Copilot/VS Code, and Gemini CLI; checks each server
against a risk-classified catalog; and flags credential-in-env,
filesystem/keychain access, network egress, and "shadow" servers that
appear in no catalog at all. Exits non-zero on high-risk findings, so you
can run it in CI or a pre-commit hook.

Privacy: the scan runs entirely locally and prints to your terminal.
There's an optional shareable web report (it asks first, or --share),
which uploads server names + risk flags only — never commands, args, env
values, or paths. The server-side schema rejects payloads that carry
them. --offline skips all network calls including the catalog fetch.

MIT licensed, ~600 lines of TypeScript, no dependencies beyond chalk:
https://github.com/oneprofile-dev/mcp-auditor

Would love feedback on:

Config locations I'm missing (JetBrains? Zed? Cline?)
Whether the risk heuristics are too noisy or too quiet
What an org-wide version of this should report

Sam
curatedmcp.com/scan

OpenAI MCP: Use GPT-4o, DALL-E, and Whisper Directly in Claude or Cursor

curatedmcp — Wed, 10 Jun 2026 10:18:52 +0000

OpenAI MCP: Use GPT-4o, DALL-E, and Whisper Directly in Claude or Cursor

The official OpenAI MCP server connects any MCP-compatible AI client to OpenAI's full model suite. Instead of switching between tools, you can now orchestrate GPT-4o, DALL-E 3, Whisper, and embeddings directly from Claude, Cursor, or Windsurf.

What It Does

This server exposes OpenAI's APIs as tools your AI agent can call natively. You get:

Chat completions with GPT-4o, o1, and o3-mini
Image generation via DALL-E 3
Audio transcription with Whisper
Text embeddings for semantic search and RAG
Content moderation checks
Batch processing for high-volume requests
Full function-calling support and streaming responses

The practical upside: deploy Claude as your orchestrator while delegating specialized tasks to OpenAI's best-in-class models. Need an image? Call DALL-E. Need voice transcription? Use Whisper. Need embeddings for a knowledge base? Generate them on the fly—all without leaving your MCP workflow.

How to Install

npx -y @openai/mcp

Then add to your Claude Desktop claude_desktop_config.json:

{
  "mcpServers": {
    "openai-mcp": {
      "command": "npx -y @openai/mcp",
      "env": {
        "OPENAI_API_KEY": "sk-your-key-here"
      }
    }
  }
}

Restart Claude Desktop and the tools appear in your tool palette.

Real-World Use Cases

Multi-model workflows: Have Claude reason through a problem, then hand off image generation to DALL-E 3 without context switching. Perfect for design reviews or content pipelines.
Voice-to-text processing: Transcribe audio with Whisper inside a Cursor workflow, then pass the transcript to Claude for summarization or action item extraction—all in one agent flow.
RAG pipelines: Generate embeddings and semantic search over your docs directly from Claude, eliminating the need for separate embedding services. Build intelligent search without leaving your IDE.

All endpoints are supported with full API compatibility, so you're not limited to a subset. Setup takes minutes; the payoff is a unified AI toolkit without tool-switching overhead.

Full install guides for Claude Desktop, Cursor, Windsurf, and more at CuratedMCP.

MCP Ecosystem Week 24: Why Your Allowlist Needs to Account for Cross-IDE Policy Drift

curatedmcp — Mon, 08 Jun 2026 10:41:09 +0000

MCP Ecosystem Week 24: Why Your Allowlist Needs to Account for Cross-IDE Policy Drift

The MCP marketplace continues to mature, with developer adoption clustering around official integrations and structural tooling. This week's new review adds another option for codebase navigation, while the most-viewed servers reveal a pattern: developers are reaching for broad, multi-tool connectors first, which means your allowlist strategy needs to account for how policies cascade across Claude Code, Cursor, Windsurf, and GitHub Copilot simultaneously.

This Week in MCP

mcp-repo-graph (view) entered the catalog this week as a free, risk-classified server designed to give AI coding assistants structural memory of any codebase. Instead of asking an LLM to infer dependencies or module relationships, repo-graph surfaces the actual graph — imports, exports, class hierarchies, function calls.

For platform teams: this is a low-risk allowlist candidate if your concern is accuracy over data exfiltration. It doesn't phone home, doesn't require external auth, and runs locally. The governance question isn't "should we block this?" but rather "do we need repo-graph and GitHub MCP?" Both provide code context, but at different abstraction levels. If your developers are already hitting GitHub MCP for repo structure, repo-graph might be redundant. If they're working across multiple languages or private monorepos where GitHub's API is insufficient, it's a solid addition.

On the Radar

The five most-viewed servers this week paint a clear picture: GitHub Copilot MCP (98k views), OpenAI MCP (87k views), and Figma MCP (82k views) dominate because they're official, trusted, and solve a specific problem — they bring external tool intelligence into the AI coding workflow rather than asking developers to context-switch.

GitHub Copilot MCP and GitHub MCP both surface repository intelligence, but they operate at different scopes. Copilot's implementation prioritizes code completions and explanations; the raw GitHub MCP goes deeper into issue and workflow management. Before you allowlist both, audit which endpoints your developers actually need. Both require GitHub PATs (Personal Access Tokens), which means your audit logs need to track which scopes are being requested — a common blind spot.

OpenAI MCP is the wild card. It gives developers direct access to GPT-4o, DALL-E, and Whisper from inside their coding environment. That's powerful and dangerous. You need to understand: Does it respect your OpenAI org's API key scope? Does it log every request? If you're running Claude Code or Cursor at scale, OpenAI MCP could balloon your token spend and create audit gaps if requests aren't traced back to individual developers.

Anthropic Claude MCP — nesting Claude inside Claude — looks like a nice-to-have but creates a risk: if a developer spins up a Claude sub-agent for a reasoning task, you've now got an unconstrained LLM instance running inside your allowed workflow. That's a supply-chain risk if the sub-agent takes actions based on untrusted input.

Governance Take

Here's the hard truth: most teams allowlisting MCP servers aren't enforcing the same policy across all four IDEs. You'll approve GitHub MCP for Cursor, but Windsurf users will pull a third-party GitHub integration that does 80% of what you blocked. Meanwhile, your audit logs show only Cursor usage.

The second problem is token cost sprawl. Each MCP server — especially the official integrations — adds latency and token overhead. A developer running GitHub MCP + Figma MCP + Claude MCP in parallel is inflating their token bill by 40–70% before they write a single line of code. If you're not metering this, you're flying blind on AI coding tool ROI.

Action items for this week:

Map which MCP servers are actually running across your IDE fleet — not what your policy says, what's actually deployed.
Before approving any new integration (especially OpenAI MCP), get a token-cost baseline. TokenShield can help cut that overhead locally, but you need to measure first.
Treat GitHub PAT scopes like you treat IAM roles — minimum viable access, per-developer audit logs.

Govern MCP usage across your team with CuratedMCP — or scan your own stack free at https://curatedmcp.com/auditor.

Anthropic Claude MCP: Run Claude as a Sub-Agent Inside Claude

curatedmcp — Sun, 07 Jun 2026 10:40:58 +0000

Anthropic Claude MCP: Run Claude as a Sub-Agent Inside Claude

When you're building with Claude, sometimes you need specialized reasoning happening in parallel or in sequence. The Anthropic Claude MCP server lets you nest Claude models within a Claude session—turning your AI agent into an orchestrator that delegates to specialized sub-agents.

What It Does

This MCP server exposes Claude Haiku, Sonnet, and Opus as callable tools. You can invoke any Claude model from within your current Claude session, pass custom system prompts to shape behavior, and control parameters like temperature and token limits. The real power emerges in multi-agent workflows: use a fast Haiku for triage, Opus for deep reasoning, or spin up parallel Claude instances to tackle different parts of a problem simultaneously.

Think of it as building agent teams. One Claude orchestrates; others critique, refine, specialize. You get prompt caching baked in, so repeated calls cost less. Chain multiple models in a single workflow. Define personas—a legal Claude, a code Claude, a writing Claude—all working inside the same session.

How to Install

npx -y @anthropic-ai/mcp

Add it to your Claude Desktop config:

{
  "mcpServers": {
    "anthropic-claude-mcp": {
      "command": "npx -y @anthropic-ai/mcp"
    }
  }
}

Set your ANTHROPIC_API_KEY environment variable, and Claude gains access to sub-agent capabilities immediately.

Real-World Use Cases

Code review pipelines in Cursor: Commit your code, have Claude Opus analyze it for architecture issues while Claude Haiku flags syntax problems in parallel. Merge results into a single report without context-switching tools.
Content critique loops: Write a draft with one Claude, immediately route it to a specialized editor persona (another Claude instance) with system instructions focused on tone and clarity. The main Claude synthesizes feedback without waiting for you to restart.
Structured data extraction at scale: Feed documents to multiple Claude instances working on different sections simultaneously. Use Haiku for quick categorization, escalate edge cases to Opus. Aggregate results in your main session.

Full install guides for Claude Desktop, Cursor, Windsurf, and more at CuratedMCP.

Perplexity MCP: Ground Your AI Agent in Real-Time Web Research with Citations

curatedmcp — Sat, 06 Jun 2026 10:27:56 +0000

Perplexity MCP: Ground Your AI Agent in Real-Time Web Research with Citations

Building AI agents that hallucinate facts is the problem Perplexity MCP solves. Instead of letting Claude or Cursor make up answers, this server gives your AI agent direct access to Perplexity's search engine—returning synthesized, cited answers backed by real sources.

What It Does

Perplexity MCP bridges the gap between raw web search and intelligent synthesis. When you connect it to Claude or Cursor, your agent gains the ability to answer questions by actually researching the web, not guessing.

Key capabilities:

Real-time web grounding — answers pull from current information, not training data
Source citations — every answer includes direct URLs, so you know where claims come from
Academic mode — tap scholarly papers and research journals for rigorous answers
Pro search — multi-step reasoning for complex questions requiring synthesis across multiple sources
Image and news search — specialized modes for visual research or breaking news
Follow-up question support — agents can drill deeper without losing context

This is fundamentally different from passing raw search results to your agent. Perplexity doesn't return a list of ten links—it returns a coherent answer built from those sources. For research, fact-checking, market analysis, or any task where you need current, verifiable information, this matters.

How to Install

npx -y @perplexity/mcp

Add to your Claude Desktop configuration:

{
  "mcpServers": {
    "perplexity-mcp": {
      "command": "npx -y @perplexity/mcp",
      "env": {
        "PERPLEXITY_API_KEY": "your-api-key-here"
      }
    }
  }
}

Get your free API key at Perplexity's developer portal. Free tier includes 5 requests daily; Pro plans start at $20/month for unlimited searches.

Real-World Use Cases

Bug research while debugging — Agent searches GitHub issues, Stack Overflow, and recent discussions to find solutions without you context-switching out of your IDE
Market research reports — Build competitive analysis by having Claude research current pricing, feature sets, and recent announcements across multiple competitors, with citations for your findings
Fact-checking claims in code reviews — When reviewing PRs that reference performance benchmarks or library capabilities, your agent can verify claims against current documentation and recent blog posts

Full install guides for Claude Desktop, Cursor, Windsurf, and more at CuratedMCP.

Docker MCP: Control Your Entire Docker Environment Through Natural Language

curatedmcp — Fri, 05 Jun 2026 10:37:31 +0000

Docker MCP: Control Your Entire Docker Environment Through Natural Language

Managing Docker from the command line is powerful, but it's context-switching hell when you're deep in development or debugging. Docker MCP bridges that gap by giving AI agents like Claude, Cursor, and Windsurf direct access to your Docker environment—so you can orchestrate containers, images, volumes, and compose stacks without leaving your editor or chat window.

Built and maintained by Docker itself, this official MCP server connects to your local Docker socket. No remote credentials, no API keys, no security theater. Just native Docker control through natural conversation.

What It Does

Docker MCP unlocks container management as a first-class AI capability. Ask Claude to start your entire stack, inspect resource usage, stream logs, or build images—and it executes directly against your Docker daemon.

The server handles the full Docker lifecycle: list and filter containers, start/stop/remove them, build images from Dockerfiles, manage volumes and networks, run docker-compose commands, and even execute commands inside running containers. You get real-time log streaming, health inspection, and resource monitoring. Push and pull from Docker Hub or private registries without manually authenticating.

This means your AI agent can reason about your infrastructure, debug deployment issues, provision local environments, and iterate on container configs—all in the context of your current task.

How to Install

npx -y @docker/mcp-server

Add to your Claude Desktop config:

{
  "mcpServers": {
    "docker-mcp": {
      "command": "npx -y @docker/mcp-server"
    }
  }
}

Same approach works for Cursor and Windsurf. Restart your AI agent and you're live.

Real-World Use Cases

Local development loops: "Start postgres and redis from my compose file, then run my migrations" — orchestrate your entire dev environment in one natural-language step instead of juggling multiple terminals.
Debugging in production-like environments: "Show me the last 10 minutes of logs from the api container and tell me if we're hitting memory limits" — diagnose issues without SSH sessions or external monitoring dashboards.
CI/CD-like workflows locally: "Build a new image from the current directory, tag it v2.1, and push it to my private registry" — test deployment automation locally before committing.

Full install guides for Claude Desktop, Cursor, Windsurf, and more at CuratedMCP.

Sequential Thinking MCP: Break Down Hard Problems Into Solvable Steps

curatedmcp — Thu, 04 Jun 2026 10:37:30 +0000

Sequential Thinking MCP: Break Down Hard Problems Into Solvable Steps

When you ask Claude a complex question in a single shot, you often get a surface-level answer. Sequential Thinking MCP changes that by giving your AI agent a structured framework for multi-step reasoning — similar to how you'd work through a whiteboard problem with a colleague.

This server lets Claude (or Cursor, Windsurf, or any MCP-compatible agent) decompose complex problems into manageable pieces, explore multiple solution paths, revise thinking based on new insights, and track reasoning chains across steps. It's pure reasoning enhancement with no external API dependency — just better problem-solving built into your agent.

What It Does

Sequential Thinking MCP unlocks deeper reasoning for your AI agents by providing tools to think iteratively rather than reflexively. Instead of generating an answer once, your agent can:

Break problems into steps — decompose architecture decisions, debugging challenges, or design problems into logical sequences
Explore alternatives — branch thinking to compare multiple approaches (trade-offs, pros/cons, risk mitigation)
Refine dynamically — revise conclusions as new information emerges during analysis
Chain reasoning — maintain context across multiple thinking steps for coherent, thorough solutions

This is invaluable for tasks that require careful analysis: security reviews, distributed systems debugging, schema design with competing constraints, and any problem where a rushed answer costs you later.

How to Install

npx -y @modelcontextprotocol/server-sequential-thinking

Add to your Claude Desktop configuration:

{
  "mcpServers": {
    "sequential-thinking-mcp": {
      "command": "npx -y @modelcontextprotocol/server-sequential-thinking"
    }
  }
}

Real-World Use Cases

Security architecture review — Ask Claude to analyze the security implications of your proposed system design, explore attack vectors step-by-step, and propose concrete mitigations with trade-offs clearly mapped.
Debugging distributed systems — Walk through why your services have intermittent failures by exploring timing assumptions, race conditions, and state consistency issues across multiple thinking steps.
Database schema design — Let Claude think through a complex domain model, explore normalization vs. denormalization trade-offs, and iterate on the schema based on access patterns and constraints you introduce mid-discussion.

Sequential Thinking is even more powerful paired with other MCP servers — combine it with GitHub MCP for thorough code reviews, or filesystem tools for detailed refactoring analysis.

Full install guides for Claude Desktop, Cursor, Windsurf, and more at CuratedMCP.

Context7 MCP: Stop Fighting Outdated AI Docs

curatedmcp — Wed, 03 Jun 2026 10:30:05 +0000

Context7 MCP: Stop Fighting Outdated AI Docs

Your AI coding assistant is confident. Too confident. It suggests a Next.js pattern that was deprecated two versions ago. It recommends a Supabase API that no longer exists. It confidently hallucinates because its training data is stale.

Context7 MCP solves this by injecting live, version-specific documentation directly into your AI's context window—before it answers your question. No more guessing which framework version your assistant is thinking about. No API keys. No friction.

What It Does

Context7 is an MCP server that fetches current documentation for thousands of libraries and frameworks, then feeds it to Claude, Cursor, or Windsurf in real time. Instead of relying on training data cutoffs, your AI assistant reads the actual docs—the version you're using—before generating code.

This unlocks a critical capability: AI that doesn't hallucinate about APIs. When you ask Claude how to set up authentication in Next.js 15, it reads Next.js 15's official docs, not guesses based on data from 2023. When you query React Server Components in Cursor, you get current patterns. When you ask Windsurf about Supabase's latest client, it has the real API in context.

The server caches popular libraries (React, Next.js, Vercel, Supabase, etc.) for instant responses and supports thousands more on-demand. It's lightweight, requires zero authentication, and works with any MCP-compatible client.

How to Install

npx -y @upstash/context7-mcp@latest

For Claude Desktop, add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "context7-mcp": {
      "command": "npx -y @upstash/context7-mcp@latest"
    }
  }
}

Restart Claude Desktop. Context7 is now available as a tool in your context menu.

Real-World Use Cases

Migrating frameworks with confidence: Ask Claude to help upgrade your Next.js app to version 15. Context7 pulls the actual migration guide and current API docs, so Claude suggests real patterns, not deprecated ones.
Learning a new library fast: You're adopting Supabase for the first time. Ask Cursor for setup code. Instead of outdated examples, Cursor reads the current official docs and generates working code on the first try.
Code review with context: Paste legacy code into Windsurf and ask "is this pattern still recommended?" Windsurf fetches the current best practices for that framework and gives you an informed answer.

Full install guides for Claude Desktop, Cursor, Windsurf, and more at CuratedMCP.