DEV Community: CuratedMCP

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.

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.

Supabase MCP Server: Query your database and manage auth through Claude

curatedmcp — Tue, 02 Jun 2026 10:34:05 +0000

Supabase MCP Server: Query your database and manage auth through Claude

The Supabase MCP Server is the official bridge between AI agents and your Supabase project. Instead of switching between Claude and your dashboard, you can now ask your AI assistant to query tables, create schemas, manage authentication, deploy Edge Functions, and handle storage—all through natural language. It's the kind of integration that saves context switching and turns your AI into a genuine database assistant.

What It Does

This MCP server unlocks direct database access for Claude, Cursor, and other AI agents. You can execute SQL queries, create or alter tables, manage Row Level Security policies, invoke Edge Functions, inspect database performance, and generate TypeScript types from your schema—without leaving your chat interface.

The server handles the full Supabase stack: PostgreSQL databases, authentication user management, Edge Function deployment, and storage bucket operations. It also lets you manage environment variables and project settings programmatically. Because it's maintained by the Supabase team directly, it stays aligned with new platform features as they ship.

The most practical benefit? You can describe what you want in plain English—"Add a users table with email and name columns, then set up RLS so users only see their own data"—and let Claude handle the SQL and configuration.

How to Install

npx -y @supabase/mcp-server-supabase@latest

Add to your Claude Desktop claude_desktop_config.json:

{
  "mcpServers": {
    "supabase-mcp-server": {
      "command": "npx -y @supabase/mcp-server-supabase@latest",
      "env": {
        "SUPABASE_ACCESS_TOKEN": "your-access-token-here",
        "SUPABASE_PROJECT_REFERENCE_ID": "your-project-id-here"
      }
    }
  }
}

Generate your access token at app.supabase.com → Account → Access Tokens.

Real-World Use Cases

Rapid schema iteration: Ask Claude to design your database schema, create tables with appropriate indexes, and set up RLS policies—then review and deploy in seconds.
Debugging performance issues: Query slow-running queries, inspect index coverage, and get Claude's suggestions for optimization without leaving your terminal.
Automating auth workflows: Have Claude list authentication users, update provider settings, or generate migration scripts for user management without manual API calls.

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

MCP Ecosystem Week 23: The Platform Integrations Are Winning

curatedmcp — Mon, 01 Jun 2026 10:34:11 +0000

MCP Ecosystem Week 23: The Platform Integrations Are Winning

The MCP marketplace is consolidating around a clear winner: official integrations with the platforms developers already use every day. This week saw zero new server additions, but that's not a sign of stagnation—it's a sign the ecosystem is maturing. The action isn't in quantity anymore; it's in the refinement and adoption of existing tools that solve real problems at scale.

This Week in MCP

No new servers launched this week, but the 70 verified servers in the catalog continue to accumulate views and integrations. The slowdown in new releases likely reflects a natural plateau as the ecosystem consolidates around proven use cases. Quality is outpacing novelty.

The real story is usage: the top five servers are pulling massive page views, indicating that developers are actively evaluating, integrating, and building on these tools. If you're building an MCP server, the bar for entry is now higher—existing solutions have significant network effects and developer mindshare.

Trending Servers

GitHub Copilot MCP (98,006 views) continues to dominate, and there's a simple reason: it bridges two worlds developers live in every day. Code intelligence and context-aware completions are table stakes for modern development, and being able to pipe that into any MCP client massively expands its utility. The view count reflects serious adoption interest.

OpenAI MCP (87,001 views) sits comfortably in second place, and it's easy to see why. Developers want a single interface to GPT-4o, DALL-E, Whisper, and embeddings without juggling multiple APIs. An official integration removes friction and builds confidence. This is the integration playbook: make the hard thing easy, ship officially, and let adoption follow.

Figma MCP (82,004 views) rounds out the top three and signals something important: design-to-code workflows are increasingly central to AI-assisted development. Being able to pull design tokens, components, and file data directly into your AI coding agent eliminates context switching. This is where tooling is heading—fewer handoffs, more integration.

What's notable about the top three is that they're all official partnerships with major platforms. GitHub, OpenAI, and Figma have all prioritized MCP as a strategic integration point. That's a strong signal about the protocol's legitimacy and trajectory.

Quick Take

The "free vs. paid" divide hasn't materialized yet—all 70 verified servers are free. That's unusual for a nascent ecosystem and suggests the MCP marketplace is still in a phase where proving value comes before monetization. The servers generating 80K+ views aren't charging for access; they're building moats through quality, reliability, and official status. Watch for the first major paid integration to test whether developers will pay premium for specialized tools once the baseline is saturated with free options. Until then, if you're building an MCP server, free is table stakes.

Browse all 70 verified servers at CuratedMCP.

Notion MCP Server: Give Your AI Agent Native Access to Your Team's Knowledge Base

curatedmcp — Mon, 01 Jun 2026 10:34:06 +0000

Notion MCP Server: Give Your AI Agent Native Access to Your Team's Knowledge Base

When your AI agent can read and write directly to Notion, your workflow changes. Instead of copying documentation into chat, you query your workspace natively. Instead of manual updates, Claude writes to your databases. The Notion MCP Server bridges that gap — connecting AI agents like Claude and Cursor to your entire Notion workspace with full read-write-search capabilities.

What It Does

The Notion MCP Server lets your AI agent interact with Notion as a native tool. Create and update pages on the fly. Query databases with filters. Search your entire workspace. Add blocks (text, code, tables, callouts). Manage database schemas. Handle nested hierarchies. Read and write comments.

This unlocks concrete capabilities: Your agent can fetch documentation context without you pasting it in. It can generate meeting notes directly into your team database. It can search for related records before suggesting updates. It can generate code snippets into a shared code database. It can audit your workspace structure or migrate content between databases.

For teams storing knowledge in Notion—which is most teams—this is transformative. Your AI doesn't operate in isolation anymore. It operates inside your actual system of record.

How to Install

Install via npx:

npx -y @notionhq/notion-mcp-server

Configure for Claude Desktop by adding this to your claude_desktop_config.json:

{
  "mcpServers": {
    "notion-mcp-server": {
      "command": "npx -y @notionhq/notion-mcp-server",
      "env": {
        "NOTION_API_KEY": "your-notion-integration-token-here"
      }
    }
  }
}

You'll need a Notion Integration Token from notion.so/my-integrations. Add that integration to any pages or databases you want your agent to access.

Real-World Use Cases

Auto-populate project databases: Ask Claude to read sprint notes, extract tasks, and write new database entries with status, assignee, and due date—all in Notion.
Search-augmented code generation: Your agent queries your team's code snippets database, finds relevant examples, then generates new code in context of what your team actually uses.
Documentation from context: Claude reads scattered meeting notes and docs from your workspace, then generates a consolidated knowledge base entry directly into Notion.

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