NEWVectors or files. Pick a path.Start →
    Back to All Lists

    Best MCP Servers for AI Agents in 2026

    A hands-on comparison of the top Model Context Protocol (MCP) servers that give AI agents access to external tools and data. We evaluated modality coverage, tool richness, setup complexity, and how well each server integrates with popular agent frameworks like Claude, Cursor, and LangChain.

    Last tested: June 19, 2026
    14 tools evaluated

    Skip the research? Mixpeek runs MCP servers for AI agents on your own data — extraction, indexing, and search in one platform.

    Start free

    Quick Answer

    The best overall option in this category is Mixpeek MCP Server, especially for agents that need to see, hear, and search media, not just read text. The rankings below compare each tool by strengths, limitations, pricing, and fit for production use.

    Skip the comparison? Mixpeek runs MCP servers for AI agents on your own data: extraction, indexing, and search in one platform.

    How We Evaluated

    Tool Richness

    30%

    Number and depth of tools exposed to the agent, does the server offer read-only lookups, or full create/update/search/delete operations with structured inputs?

    Data Coverage

    25%

    What types of data the server makes accessible: text, structured records, images, video, audio, code, or combinations. Multimodal servers score higher because agents encounter diverse data in production.

    Setup & Integration

    25%

    Time-to-first-tool-call: how many steps from install to a working agent session. Includes SDK availability, config format, auth flow, and compatibility with Claude Desktop, Cursor, Windsurf, and VS Code.

    Production Readiness

    20%

    Auth, rate limiting, error handling, logging, and whether the server can run in a containerized or self-hosted environment for enterprise use.

    Overview

    The Model Context Protocol has become the standard way to give AI agents access to external tools and data, much like REST became the standard for web APIs. The ecosystem reorganized sharply during 2025 and early 2026: Anthropic moved most of its original first-party reference servers (GitHub, Slack, PostgreSQL, Brave Search, Puppeteer, Google Drive, and others) into a separate servers-archived repository and handed ownership to the vendors themselves, leaving only seven reference servers actively maintained upstream (Everything, Fetch, Filesystem, Git, Memory, Sequential Thinking, and Time). The practical takeaway is that the maintained version of most popular servers now lives in a vendor or community repo, not the old @modelcontextprotocol/server-* npm packages. We tested each server by connecting it to Claude Desktop and running real-world agent tasks: code editing, database queries, web search, media processing, and team communication. The other key finding is that most MCP servers are still text-only, returning strings and JSON but unable to process images, video, or audio. For agents that need multimodal perception, the options narrow dramatically. This guide reflects the current ownership and packages as of June 2026, and ranks servers by tool richness, data coverage, setup friction, and production readiness.
    1

    Mixpeek MCP Server

    Our Pick
    Try MVS

    MCP server that gives AI agents multimodal perception, the ability to search, retrieve, and understand video, images, audio, and documents through natural-language tool calls. Agents can ingest media into buckets, run feature extraction pipelines, search across modalities, and retrieve structured results, all without leaving the agent loop.

    What Sets It Apart

    The only MCP server with full multimodal perception, agents can ingest, search, and understand video, images, audio, and documents through a single server, not just read text files.

    Strengths

    • +Full multimodal coverage: video, image, audio, PDF, and text in one server
    • +Agents can trigger ingestion, extraction, and search, not just read-only lookups
    • +Works with Claude Desktop, Cursor, Windsurf, Cline, and any MCP-compatible client
    • +Self-hostable for air-gapped or compliance-heavy environments
    • +Backed by production infrastructure handling face detection, logo matching, transcription, and embedding generation

    Limitations

    • -Requires a Mixpeek account and API key for the hosted version
    • -Multimodal pipelines add latency compared to text-only MCP servers
    • -Smaller install base than filesystem or database MCP servers

    Real-World Use Cases

    • Video analysis agents that search surveillance footage for specific objects, faces, or events using natural language
    • Content moderation pipelines where agents ingest user-uploaded media and flag policy violations automatically
    • Research agents that search across a multimedia knowledge base of PDFs, recordings, and images in a single query
    • E-commerce agents that find visually similar products by searching image embeddings via MCP tool calls

    Choose This When

    When your agent needs to process or search media, video surveillance, content moderation, multimedia research, visual search, or any workflow that involves non-text data.

    Skip This If

    When your agent only works with text, code, or structured data, simpler MCP servers will be faster and require no API key. Also avoid if sub-100ms latency is critical, since multimodal processing adds overhead.

    Integration Example

    // claude_desktop_config.json (mcp.json)
    {
      "mcpServers": {
        "mixpeek": {
          "command": "python",
          "args": ["-m", "mixpeek_mcp"],
          "env": {
            "MIXPEEK_API_KEY": "your_api_key",
            "MIXPEEK_NAMESPACE": "your_namespace"
          }
        }
      }
    }
    
    // Install first: pip install mixpeek-mcp  (also ships as Docker and remote HTTP+SSE)
    
    // Agent can now call tools like:
    // - search({ query: "red car in parking lot", modalities: ["video", "image"] })
    // - classify({ file: "/tmp/clip.mp4", taxonomy: "iab_v3" })
    // - extract({ document_id: "abc123", features: ["faces", "text"] })
    Free tier with 1,000 credits/month; usage-based at $0.001/credit after; self-hosted licensing available
    Best for: Agents that need to see, hear, and search media, not just read text
    Start free
    2

    Filesystem MCP Server (Anthropic)

    Reference MCP server from Anthropic that gives agents sandboxed read/write access to local files and directories. The most widely installed MCP server because it ships with Claude Desktop and solves the most common agent need: reading and editing code and documents on disk.

    What Sets It Apart

    Zero-config local file access with sandboxed directory permissions, the simplest and most widely deployed MCP server, shipping built-in with Claude Desktop.

    Strengths

    • +Ships built-in with Claude Desktop, zero config for local use
    • +Sandboxed directory access prevents agents from touching files outside allowed paths
    • +Fast and lightweight, no external API calls or network dependency
    • +Well-documented reference implementation useful for learning the MCP protocol

    Limitations

    • -Text-only: cannot process images, audio, or video files meaningfully
    • -Local-only by default, no cloud storage integration without custom wrappers
    • -No search capability beyond filename matching
    • -Limited to file CRUD, no semantic understanding of content

    Real-World Use Cases

    • Code editing agents that read, modify, and create source files across a project directory
    • Document processing workflows where agents read local markdown, JSON, or config files
    • Local script automation where agents need to read input files and write output files
    • Learning and prototyping MCP integrations using the simplest possible server implementation

    Choose This When

    When your agent needs to read and write local files, code, documents, configs, and you want the fastest setup with no API keys or external services required.

    Skip This If

    When your agent needs to search file contents semantically, process media files, or access cloud storage. The filesystem server is text-only and local-only.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "filesystem": {
          "command": "npx",
          "args": [
            "@modelcontextprotocol/server-filesystem",
            "/Users/you/projects",
            "/Users/you/documents"
          ]
        }
      }
    }
    
    // Agent can now:
    // - Read files: read_file({ path: "/Users/you/projects/app/src/index.ts" })
    // - Write files: write_file({ path: "/Users/you/projects/app/README.md", content: "..." })
    // - List dirs: list_directory({ path: "/Users/you/projects/app/src" })
    Free and open source (MIT license)
    Best for: Code editing agents and local document workflows where text files are the primary data
    Visit Website
    3

    PostgreSQL MCP Server

    MCP server that connects agents to PostgreSQL databases, allowing natural-language queries against structured data. Agents can explore schemas, run read-only SQL, and inspect table relationships without the user writing queries manually. Note: the original Anthropic reference server was archived in 2025, so the maintained options today are community forks and the official Postgres-vendor servers (Supabase and Neon both ship their own MCP servers).

    What Sets It Apart

    Schema-aware database access that lets agents explore table structures before querying, reducing SQL errors and enabling agents to answer data questions without the user knowing SQL.

    Strengths

    • +Natural-language to SQL lets agents answer data questions without manual query writing
    • +Schema introspection tools help agents understand database structure before querying
    • +Read-only mode by default prevents accidental data mutations
    • +Works with any PostgreSQL-compatible database including CockroachDB, Supabase, and Neon

    Limitations

    • -Original Anthropic reference server is archived; use a vendor or community-maintained fork
    • -Structured data only, with no support for unstructured media, documents, or embeddings
    • -SQL generation can produce incorrect queries on complex schemas without guardrails
    • -Connection string management requires care in multi-tenant setups

    Real-World Use Cases

    • Business intelligence agents that answer questions like 'what were last month's top 10 customers by revenue' from a production database
    • Database exploration for new team members, agents describe table schemas and relationships conversationally
    • Ad-hoc reporting where agents generate SQL queries from natural language and return formatted results
    • Data validation agents that check for anomalies or inconsistencies in database records

    Choose This When

    When your agent needs to answer questions from structured data in PostgreSQL, Supabase, Neon, or CockroachDB databases.

    Skip This If

    When you need write operations, when your data is unstructured (documents, media), or when you need to query non-PostgreSQL databases.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "postgres": {
          "command": "npx",
          "args": [
            "@modelcontextprotocol/server-postgres",
            "postgresql://user:pass@localhost:5432/mydb"
          ]
        }
      }
    }
    
    // Agent can now:
    // - Explore schema: list_tables(), describe_table({ table: "orders" })
    // - Run queries: query({ sql: "SELECT customer, SUM(amount) FROM orders GROUP BY 1 ORDER BY 2 DESC LIMIT 10" })
    Free and open source (MIT license)
    Best for: Data analysis agents that need to query relational databases conversationally
    Visit Website
    4

    Brave Search MCP Server

    MCP server that gives agents access to Brave Search, enabling real-time web search, news, image, video, and local business lookups. The maintained server is now Brave's own @brave/brave-search-mcp-server (the old @modelcontextprotocol/server-brave-search reference version was archived). Useful for agents that need to answer questions about current events, find documentation, or research topics beyond their training data.

    What Sets It Apart

    Privacy-focused real-time web search with global, local, news, image, and video tools in one server, now maintained directly by Brave.

    Strengths

    • +Real-time web search fills the knowledge gap for questions beyond agent training cutoff
    • +Six tools in the official server: web, local, news, image, video, and AI summarizer
    • +Privacy-focused: Brave does not track or profile search queries
    • +Now vendor-maintained by Brave, with both stdio and HTTP transports

    Limitations

    • -Search quality trails Google for niche or technical queries
    • -Requires a Brave Search API key (free tier available but rate-limited)
    • -No deep content extraction, so it returns snippets rather than full page text
    • -Returns search result metadata rather than processing media files themselves

    Real-World Use Cases

    • Research agents that need to verify facts, find current prices, or check recent news beyond their training data
    • Customer support agents that search documentation and knowledge bases in real time
    • Local business search for agents building travel itineraries or finding nearby services
    • Competitive analysis agents that search for recent product launches, pricing changes, or press releases

    Choose This When

    When your agent needs to answer questions about current events, find documentation, or look up information that may have changed since the model's training cutoff.

    Skip This If

    When you need deep content extraction (full page text, not just snippets) or when search quality on niche technical topics is critical, since Google's quality is higher there.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "brave-search": {
          "command": "npx",
          "args": ["-y", "@brave/brave-search-mcp-server"],
          "env": {
            "BRAVE_API_KEY": "your-brave-api-key"
          }
        }
      }
    }
    
    // Agent can now:
    // - Web search: brave_web_search({ query: "latest Claude model release date" })
    // - Local search: brave_local_search({ query: "Italian restaurants near Times Square" })
    // - News, image, and video search are also exposed as separate tools
    Free tier: 2,000 queries/month; paid plans from $5/month for higher volume
    Best for: Agents that need current information from the web to answer user questions
    Visit Website
    5

    GitHub MCP Server

    MCP server that connects agents to the GitHub API for repository management, issue tracking, pull request workflows, and code search. GitHub now maintains the official server itself at github/github-mcp-server (a Go implementation distributed as a Docker image and a hosted remote server), having taken over from the deprecated @modelcontextprotocol/server-github npm package. There is also a fully hosted remote server you can connect to without running anything locally.

    What Sets It Apart

    Official, GitHub-maintained read-write access to the GitHub API, with the most complete software-development tool coverage and both self-hosted Docker and hosted remote options for the entire code-to-PR workflow.

    Strengths

    • +Comprehensive GitHub coverage: repos, issues, PRs, branches, commits, and code search
    • +Agents can create PRs, comment on issues, and review code for full workflow automation
    • +Official, vendor-maintained by GitHub, with both Docker and hosted remote options
    • +Supports both GitHub.com and GitHub Enterprise Server

    Limitations

    • -GitHub-specific, so it does not work with GitLab, Bitbucket, or other forges
    • -Token scope management is complex for organizations with many repos
    • -Rate limits apply: 5,000 requests/hour for authenticated users
    • -No media understanding, so images and binaries in repos are treated as opaque files

    Real-World Use Cases

    • Automated code review agents that read PR diffs, comment on issues, and suggest improvements
    • Issue triage agents that label, assign, and prioritize incoming GitHub issues based on content
    • Release management agents that create branches, tag releases, and generate changelogs
    • Code search agents that find relevant code examples, API usage patterns, or security vulnerabilities across repositories

    Choose This When

    When your agent needs to interact with GitHub repositories, searching code, managing issues, creating PRs, or automating development workflows.

    Skip This If

    When you use GitLab or Bitbucket (GitHub-specific), when you need fine-grained token scope management across many repos, or when you need to understand media files in repositories.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "github": {
          "command": "docker",
          "args": [
            "run", "-i", "--rm",
            "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
          ],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_personal_access_token"
          }
        }
      }
    }
    
    // Or connect to the hosted remote server at https://api.githubcopilot.com/mcp/
    
    // Agent can now:
    // - Search code: search_code({ query: "useState error handling", repo: "org/app" })
    // - Create PR: create_pull_request({ repo: "org/app", title: "Fix auth bug", head: "fix/auth", base: "main" })
    // - Comment on issue: add_issue_comment({ repo: "org/app", issue: 42, body: "Investigating..." })
    Free and open source; requires a GitHub personal access token (free to create)
    Best for: Developer agents that manage code, issues, and pull requests as part of their workflow
    Visit Website
    6

    Slack MCP Server

    MCP server for Slack workspace integration, giving agents the ability to read channels, search messages, post updates, and manage threads. The original Anthropic reference server was archived in February 2026, so the maintained options today are community servers (the widely-used korotovsky/slack-mcp-server supports DMs, group DMs, and smart history fetch with no extra permission scopes). Useful for agents that need to participate in team communication or pull context from Slack conversations.

    What Sets It Apart

    Full Slack workspace integration with message search, threaded conversations, and rich message formatting, the standard way to give agents access to team communication context.

    Strengths

    • +Full read/write access to channels, threads, and direct messages
    • +Message search lets agents find relevant past conversations for context
    • +Can post structured messages with blocks, attachments, and formatting
    • +Active community forks add stdio, SSE, and HTTP transports

    Limitations

    • -Original Anthropic reference server is archived; pick a maintained community fork
    • -Requires Slack app creation and OAuth setup, more involved than file or DB servers
    • -Message history access depends on Slack plan (free plans limit retention)
    • -No support for Slack Huddles, Clips (video), or Canvas documents

    Real-World Use Cases

    • Standup bots that read team channels and summarize daily activity for managers
    • Incident response agents that search for related past incidents in Slack and post status updates
    • Customer support agents that pull context from internal Slack discussions to enrich ticket responses
    • Project management agents that post automated progress updates and pull team decisions from threads

    Choose This When

    When your agent needs to read team conversations for context, post updates to channels, or search Slack message history as part of its workflow.

    Skip This If

    When you need access to Slack Huddles, Clips, or Canvas documents, these are not supported. Also avoid for large workspaces where rate limits will bottleneck search-heavy agents.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "slack": {
          "command": "npx",
          "args": ["-y", "slack-mcp-server@latest", "--transport", "stdio"],
          "env": {
            "SLACK_MCP_XOXB_TOKEN": "xoxb-your-bot-token"
          }
        }
      }
    }
    
    // Agent can now:
    // - Search: search_messages({ query: "deployment issue", channel: "#engineering" })
    // - Post: post_message({ channel: "#updates", text: "Deploy complete. All checks green." })
    // - Read thread: get_thread({ channel: "C0123", ts: "1234567890.123456" })
    Free and open source; Slack API access is free but workspace plan affects data availability
    Best for: Agents that need to read team context from Slack or post automated updates
    Visit Website
    7

    Playwright MCP Server (Microsoft)

    MCP server that gives agents browser automation capabilities. Microsoft's Playwright MCP is now the de facto standard here, after Anthropic's original Puppeteer reference server was archived in 2025. It drives Chromium, Firefox, and WebKit and, by default, uses accessibility-tree snapshots rather than screenshots, which makes agent actions faster and more deterministic. Agents can navigate, click, type, fill forms, extract content, and optionally capture screenshots.

    What Sets It Apart

    Cross-browser automation via accessibility-tree snapshots, which gives agents faster and more deterministic interaction with JavaScript-rendered web applications than screenshot-based servers.

    Strengths

    • +Accessibility-tree snapshots are faster and more deterministic than pixel screenshots
    • +Cross-browser: drives Chromium, Firefox, and WebKit from one server
    • +Handles JavaScript-rendered pages that static HTTP requests cannot access
    • +Vendor-maintained by Microsoft with frequent releases

    Limitations

    • -Slower than direct API calls, since each page load adds latency
    • -Resource-heavy: a headless browser consumes significant memory and CPU
    • -Fragile: page structure changes can break selectors and automation steps
    • -Anthropic's older Puppeteer reference server is archived; do not start new projects on it

    Real-World Use Cases

    • Web scraping agents that extract data from JavaScript-rendered pages that static HTTP cannot access
    • QA testing agents that navigate web applications, fill forms, and verify rendered output
    • Screenshot-based monitoring agents that capture visual state of dashboards and detect layout regressions
    • Form automation agents that fill and submit multi-step web forms on behalf of users

    Choose This When

    When your agent needs to interact with web pages that lack APIs, including filling forms, clicking buttons, extracting rendered content, or capturing screenshots for visual inspection.

    Skip This If

    When the target has a proper API, since direct API calls are faster and more reliable. Also avoid for high-throughput workloads where a headless browser's resource consumption is prohibitive.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "playwright": {
          "command": "npx",
          "args": ["@playwright/mcp@latest"]
        }
      }
    }
    
    // Agent can now:
    // - Navigate: browser_navigate({ url: "https://example.com/dashboard" })
    // - Snapshot: browser_snapshot() // returns the accessibility tree
    // - Click: browser_click({ element: "Submit button", ref: "..." })
    // - Run JS: browser_evaluate({ function: "() => document.querySelector('h1').textContent" })
    Free and open source (Apache 2.0 license)
    Best for: Agents that need to interact with web applications that lack APIs
    Visit Website
    8

    Qdrant MCP Server

    MCP server that connects agents to Qdrant vector databases for semantic search over embeddings. Agents can search for similar documents, manage collections, and retrieve nearest-neighbor results using natural-language queries that get embedded on the fly.

    What Sets It Apart

    Native vector similarity search with metadata filtering, the standard way to give agents RAG capabilities over a pre-built embedding knowledge base.

    Strengths

    • +Semantic search over pre-computed embeddings gives agents retrieval-augmented generation capability
    • +Collection management tools let agents create and configure vector indexes
    • +Supports filtering by payload metadata alongside vector similarity
    • +Works with Qdrant Cloud and self-hosted Qdrant instances

    Limitations

    • -Requires embeddings to be pre-computed and loaded, no built-in ingestion or feature extraction
    • -Text-embedding focused: no native video, audio, or image processing
    • -Agents must understand embedding concepts to use the server effectively
    • -Query quality depends entirely on the embedding model used upstream

    Real-World Use Cases

    • RAG-powered support agents that search a knowledge base of product documentation to answer customer questions
    • Code search agents that find semantically similar code snippets across a codebase using embedding similarity
    • Research agents that search academic paper embeddings to find relevant prior work on a topic
    • Recommendation agents that find similar items based on embedding proximity with metadata filtering

    Choose This When

    When your agent needs semantic search over a pre-computed embedding collection, knowledge bases, documentation, code, or product catalogs stored in Qdrant.

    Skip This If

    When you need the agent to ingest and embed new data (Qdrant MCP is search-only, not an ingestion pipeline). Also avoid for multimodal search, it is text-embedding focused.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "qdrant": {
          "command": "npx",
          "args": ["mcp-server-qdrant"],
          "env": {
            "QDRANT_URL": "http://localhost:6333",
            "QDRANT_API_KEY": "your-api-key",
            "COLLECTION_NAME": "knowledge_base"
          }
        }
      }
    }
    
    // Agent can now:
    // - Search: qdrant_search({ query: "how to configure auth", limit: 5 })
    // - Filter: qdrant_search({ query: "deployment guide", filter: { category: "devops" }, limit: 3 })
    Free and open source; Qdrant Cloud has a free tier with 1 GB storage
    Best for: RAG agents that need to search a pre-built knowledge base of text embeddings
    Visit Website
    9

    Notion MCP Server

    Notion's official MCP server (makenotion/notion-mcp-server, published as @notionhq/notion-mcp-server) lets agents read, create, and update pages, databases, and blocks. Notion ships two flavors: a hosted OAuth-based remote server and the open-source local server via npm. Gives agents access to organizational knowledge stored in Notion wikis and project trackers.

    What Sets It Apart

    Full read-write access to Notion's page, database, and block API, the standard way to give agents access to organizational knowledge and project management stored in Notion.

    Strengths

    • +Official, Notion-maintained, with both hosted remote and local npm options
    • +Read and write access to Notion pages, databases, and blocks
    • +Database querying with filters and sorts mirrors Notion's native API
    • +Broad client support: Claude Desktop, Cursor, VS Code, and others

    Limitations

    • -Notion API rate limits (around 3 requests/second) can bottleneck agent workflows
    • -Complex nested block structures make page creation verbose
    • -No support for Notion AI features, comments, or real-time collaboration
    • -Media attachments in Notion pages are returned as URLs, not processed

    Real-World Use Cases

    • Documentation agents that read Notion wikis for context and create structured summaries of meetings or decisions
    • Project management agents that update Notion databases with task status, blockers, and progress notes
    • Onboarding agents that pull company policies and procedures from Notion to answer new hire questions
    • Knowledge base agents that search Notion pages for answers before falling back to web search

    Choose This When

    When your organization uses Notion as its primary knowledge base or project tracker and agents need to read context or document their work there.

    Skip This If

    When you need high-throughput access (Notion's 3 req/s rate limit is restrictive), when media in Notion pages needs to be processed (URLs only, no content extraction), or when you use a different wiki/PM tool.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "notion": {
          "command": "npx",
          "args": ["-y", "@notionhq/notion-mcp-server"],
          "env": {
            "NOTION_TOKEN": "ntn_your_integration_token"
          }
        }
      }
    }
    
    // Agent can now:
    // - Search: notion_search({ query: "Q1 roadmap", filter: { type: "page" } })
    // - Read page: notion_get_page({ page_id: "abc123" })
    // - Query DB: notion_query_database({ database_id: "def456", filter: { status: "In Progress" } })
    Free and open source; Notion API access requires a Notion integration (free to create)
    Best for: Agents that use Notion as their organization's knowledge base or project tracker
    Visit Website
    10

    Memory MCP Server (Anthropic)

    Reference MCP server that gives agents persistent memory using a local knowledge graph. Agents can store entities, relationships, and observations across conversations, enabling long-term context that survives session boundaries.

    What Sets It Apart

    Persistent local knowledge graph that gives agents memory across sessions, the simplest way to make agents remember past interactions without external databases or API calls.

    Strengths

    • +Persistent memory across conversations, agents remember past interactions
    • +Knowledge graph structure supports entities, relationships, and observations
    • +Local storage means no external API calls or data leaving the machine
    • +Simple mental model: agents create, read, and relate entities naturally

    Limitations

    • -Local JSON file storage does not scale for large knowledge bases
    • -No semantic search, retrieval is exact-match on entity names and types
    • -No built-in conflict resolution when agents store contradictory observations
    • -Graph queries are limited: no traversal, aggregation, or complex relationship filters

    Real-World Use Cases

    • Personal assistant agents that remember user preferences, past requests, and ongoing projects across sessions
    • Research agents that build a knowledge graph of people, organizations, and relationships as they investigate topics
    • Development agents that track architectural decisions, tech debt, and project history over time
    • Customer-facing agents that remember past interactions and preferences for personalized responses

    Choose This When

    When your agent needs to remember context across conversations, user preferences, project state, past decisions, and you want a lightweight local solution with no external dependencies.

    Skip This If

    When you need semantic search over memory (retrieval is exact-match only), when the knowledge base will grow large (JSON file storage does not scale), or when you need conflict resolution for contradictory information.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "memory": {
          "command": "npx",
          "args": ["@modelcontextprotocol/server-memory"]
        }
      }
    }
    
    // Agent can now:
    // - Store: create_entity({ name: "Ethan", type: "person", observations: ["prefers dark mode", "works on Mixpeek"] })
    // - Relate: create_relation({ from: "Ethan", to: "Mixpeek", type: "works_at" })
    // - Recall: search_entities({ query: "Ethan" })
    Free and open source (MIT license)
    Best for: Agents that need to remember user preferences, project context, or past decisions across sessions
    Visit Website
    11

    Google Drive MCP Server

    MCP server that connects agents to Google Drive for reading, searching, and managing files across a user's Drive. Agents can search documents by name or content, read file contents, and navigate folder structures. The original Anthropic reference server was archived in May 2025 (it had an OAuth token-refresh bug); Google now offers an official Drive MCP server through the Drive API, and several maintained community forks exist. Useful for agents that need access to organizational documents stored in Google Workspace.

    What Sets It Apart

    Native Google Drive and Google Workspace integration, the only MCP server that can search and read Google Docs, Sheets, and Slides content directly.

    Strengths

    • +Search across Google Drive files by name, content, and metadata
    • +Read Google Docs, Sheets, and Slides content programmatically
    • +Navigate folder hierarchies and shared drives
    • +OAuth authentication aligns with Google Workspace security policies

    Limitations

    • -Original Anthropic reference server is archived; use Google's official server or a maintained fork
    • -Read-only for most file types, with limited write/create capabilities
    • -Cannot process media files (images, video) stored in Drive, returning metadata only
    • -OAuth setup is more complex than API key-based servers

    Real-World Use Cases

    • Knowledge retrieval agents that search Google Drive for relevant documents, memos, and spreadsheets
    • Meeting prep agents that find and summarize related documents before calendar events
    • Compliance agents that search shared drives for documents matching specific criteria or keywords

    Choose This When

    When your organization stores documents in Google Drive and agents need to search for and read them as part of their workflow.

    Skip This If

    When you need to write or create files in Drive (limited support), process media stored in Drive, or when OAuth setup complexity is a blocker for your team.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "gdrive": {
          "command": "npx",
          "args": ["-y", "@isaacphi/mcp-gdrive"],
          "env": {
            "CLIENT_ID": "your-client-id.apps.googleusercontent.com",
            "CLIENT_SECRET": "your-client-secret",
            "GDRIVE_CREDS_DIR": "/path/to/creds"
          }
        }
      }
    }
    
    // Agent can now:
    // - Search: gdrive_search({ query: "Q1 planning doc" })
    // - Read: gdrive_read_file({ file_id: "1abc..." })
    // - List: gdrive_list_files({ folder_id: "root", page_size: 20 })
    Free and open source; requires a Google Cloud project with the Drive API enabled (free tier available)
    Best for: Agents that need to search and read organizational documents stored in Google Drive or Shared Drives
    Visit Website
    12

    Sentry MCP Server

    MCP server that connects agents to Sentry for error monitoring and issue management. Agents can search for errors, view stack traces, query issue trends, and manage issue status, turning agents into first-responders for production errors.

    What Sets It Apart

    Direct Sentry integration that turns agents into first-responders for production errors, read stack traces, diagnose issues, and manage error status without leaving the agent conversation.

    Strengths

    • +Search and filter Sentry issues by project, error type, frequency, and status
    • +View full stack traces and error context without leaving the agent conversation
    • +Resolve, ignore, or assign issues directly through agent tool calls
    • +Track error trends and regressions over time

    Limitations

    • -Sentry-specific, does not work with Datadog, PagerDuty, or other monitoring tools
    • -Requires Sentry auth token with appropriate project access
    • -No direct code fix capability, agents can diagnose but must use other tools to implement fixes
    • -Limited to error monitoring, no metrics, logs, or trace data

    Real-World Use Cases

    • On-call agents that automatically triage new Sentry errors, read stack traces, and suggest fixes
    • Bug investigation agents that correlate Sentry errors with recent code changes via GitHub MCP
    • Sprint planning agents that pull error trends and open issues to inform prioritization decisions

    Choose This When

    When you use Sentry for error monitoring and want agents to triage, diagnose, or manage production errors as part of a development or on-call workflow.

    Skip This If

    When you use a different monitoring tool (Datadog, PagerDuty), when you need metrics or logs (Sentry MCP is error-focused), or when agents need to fix code directly (pair with filesystem or GitHub MCP).

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "sentry": {
          "command": "npx",
          "args": ["@sentry/mcp-server"],
          "env": {
            "SENTRY_AUTH_TOKEN": "sntrys_your_auth_token",
            "SENTRY_ORG": "your-org-slug"
          }
        }
      }
    }
    
    // Agent can now:
    // - Search: sentry_search_issues({ query: "is:unresolved level:error", project: "api" })
    // - View: sentry_get_issue({ issue_id: "12345" }) // includes stack trace
    // - Resolve: sentry_update_issue({ issue_id: "12345", status: "resolved" })
    Free and open source; requires a Sentry account (free tier available with 5K events/mo)
    Best for: Developer agents that triage, diagnose, and manage production errors as part of an on-call workflow
    Visit Website
    13

    Stripe MCP Server

    MCP server that gives agents access to the Stripe API for payment management, subscription handling, and financial data queries. Agents can look up customers, check payment statuses, create invoices, and manage subscriptions through natural-language tool calls.

    What Sets It Apart

    Official Stripe integration with full read-write API access, the only MCP server that lets agents manage payments, subscriptions, and invoices in production.

    Strengths

    • +Full Stripe API coverage: customers, payments, subscriptions, invoices, and products
    • +Agents can create and manage resources, not just read them
    • +Handles complex financial queries like subscription MRR and churn analysis
    • +Official Stripe integration with production-grade auth handling

    Limitations

    • -Stripe-specific, does not work with other payment processors
    • -Financial operations carry risk, agents can create real charges and invoices
    • -Requires restricted Stripe API key with appropriate permission scoping
    • -Complex Stripe objects (subscriptions with trials, proration) can confuse agents

    Real-World Use Cases

    • Customer support agents that look up payment history and subscription status to resolve billing disputes
    • Finance agents that generate invoice summaries, analyze MRR trends, and flag failed payments
    • Sales agents that create quotes, subscriptions, and promo codes through conversational interaction

    Choose This When

    When your agent needs to interact with Stripe, looking up customers, checking payments, managing subscriptions, or creating invoices as part of support or finance workflows.

    Skip This If

    When you use a different payment processor, when the risk of agents creating real financial transactions is unacceptable, or when you cannot scope API key permissions tightly enough.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "stripe": {
          "command": "npx",
          "args": ["@stripe/mcp"],
          "env": {
            "STRIPE_SECRET_KEY": "sk_live_your_restricted_key"
          }
        }
      }
    }
    
    // Agent can now:
    // - Look up: stripe_get_customer({ email: "[email protected]" })
    // - Check: stripe_list_payments({ customer: "cus_abc", limit: 5 })
    // - Create: stripe_create_invoice({ customer: "cus_abc", items: [{ price: "price_xyz" }] })
    Free and open source; requires a Stripe account (standard Stripe processing fees apply to operations)
    Best for: Support and finance agents that need to look up payments, manage subscriptions, or create invoices
    Visit Website
    14

    Linear MCP Server

    MCP server that connects agents to Linear for issue tracking, project management, and engineering workflow automation. Linear now runs an official hosted remote server at mcp.linear.app (the earlier community jerhadf/linear-mcp-server is deprecated and its README points users to the official one). Agents can create issues, update statuses, search backlogs, and manage cycles, making it the standard way to integrate agents into Linear-based development workflows.

    What Sets It Apart

    Official, Linear-hosted remote MCP server for engineering workflow automation, giving agents OAuth-authenticated read-write access to issues, projects, and cycles with no local process to run.

    Strengths

    • +Official hosted remote server with OAuth, so there is nothing to run locally
    • +Full Linear coverage: issues, projects, cycles, labels, and team management
    • +Agents can create, update, and search issues with natural-language commands
    • +Streamable HTTP transport following the authenticated remote MCP spec

    Limitations

    • -Linear-specific, so it does not work with Jira, Asana, or other PM tools
    • -Hosted remote model means you depend on Linear's MCP endpoint availability
    • -No support for Linear Triage or Inbox features via MCP
    • -Complex issue relationships (sub-issues, blocking) can be verbose to manage

    Real-World Use Cases

    • Automated issue creation from error monitoring, Sentry alerts become Linear issues with full context
    • Sprint planning agents that analyze backlog velocity and suggest issue prioritization for upcoming cycles
    • Standup automation agents that read recent Linear activity and generate team progress summaries

    Choose This When

    When your team uses Linear for project management and you want agents to create issues from errors, triage backlogs, or automate sprint planning.

    Skip This If

    When you use Jira, Asana, or another PM tool. Also avoid if you need Triage or Inbox features, which are not exposed via the MCP server.

    Integration Example

    // claude_desktop_config.json
    {
      "mcpServers": {
        "linear": {
          "command": "npx",
          "args": ["-y", "mcp-remote", "https://mcp.linear.app/mcp"]
        }
      }
    }
    
    // On first run, mcp-remote opens an OAuth flow in your browser to authorize Linear.
    
    // Agent can now:
    // - Create: linear_create_issue({ title: "Fix auth timeout", team: "ENG", priority: 2 })
    // - Search: linear_search_issues({ query: "auth bug", status: "In Progress" })
    // - Update: linear_update_issue({ id: "ENG-42", status: "Done" })
    Free; requires a Linear account (free tier available for small teams)
    Best for: Engineering teams that use Linear and want agents to create, triage, and manage issues automatically
    Visit Website
    Managed Mixpeek

    Put MCP servers for AI agents to work

    Connect a bucket and Mixpeek runs the whole MCP servers for AI agents pipeline for you: extraction, indexing, and search over your own objects. No models to wire up, nothing to host.

    Start with Managed
    MVS · bring your own

    Already have vectors?

    Keep your embeddings on your own cloud and run dense, sparse, and BM25 search directly on object storage. First 1M vectors free.

    Start with MVS

    Frequently Asked Questions

    What is an MCP server and how does it work?

    A Model Context Protocol (MCP) server is a lightweight process that exposes tools, resources, and prompts to AI agents over a standardized JSON-RPC protocol. The agent's host application (like Claude Desktop or Cursor) connects to one or more MCP servers and presents their tools to the language model. When the model decides to use a tool, the host routes the call to the appropriate server, which executes it and returns the result. This decouples the agent from its integrations: you can add a Slack server, a database server, and a multimodal search server without changing the agent's code.

    How do I install and connect an MCP server?

    Most MCP servers install via npx or pip and run as a local process. In Claude Desktop, you add a server entry to your claude_desktop_config.json with the command to start it (e.g., 'npx mixpeek-mcp' or 'npx @modelcontextprotocol/server-filesystem /path/to/allowed/dir'). In Cursor and Windsurf, there are built-in MCP server configuration panels. The agent host starts the server process automatically and connects via stdio or SSE. No port management or networking required for local servers.

    Can I use multiple MCP servers at the same time?

    Yes. MCP is designed for composition. An agent can connect to a filesystem server, a database server, a search server, and a communication server simultaneously. The host merges all available tools into a single tool list that the model can choose from. This is the core advantage of MCP over custom function-calling implementations: you assemble capabilities from independent servers rather than building one monolithic integration layer.

    What is the difference between an MCP server and a LangChain tool?

    A LangChain tool is a Python function registered with a LangChain agent. It runs in-process, is tightly coupled to the LangChain framework, and requires Python. An MCP server is a standalone process that communicates over a standard protocol. It can be written in any language, used by any MCP-compatible host (Claude, Cursor, custom agents), and composed with other servers. MCP servers are more like microservices; LangChain tools are more like library functions. You can use both: several MCP servers also offer LangChain tool wrappers.

    Do MCP servers work with OpenAI agents or only Claude?

    MCP was created by Anthropic but the protocol is open and adopted by multiple vendors. OpenAI added MCP support to its Agents SDK in March 2025. Google's ADK supports MCP. Microsoft's Copilot Studio supports MCP. Most MCP servers work with any compliant host. The ecosystem has converged on MCP as the standard agent-tool protocol, similar to how REST became the standard for web APIs.

    How do MCP servers handle authentication and security?

    Authentication varies by server. Local servers (filesystem, memory) rely on OS-level permissions and sandboxed directory access. Cloud-connected servers (GitHub, Slack, Notion) use API keys or OAuth tokens configured at setup. For enterprise use, look for servers that support environment variable injection for secrets, run in containers for isolation, and provide audit logs of tool calls. The MCP specification includes an authorization framework, but implementation maturity varies across servers.

    Can MCP servers handle images, video, and audio, or just text?

    Most MCP servers today are text-oriented: they return strings, JSON, or structured data. A few servers handle media natively. Mixpeek's MCP server is the most comprehensive for multimodal data: agents can search video, classify images against IAB taxonomies, detect faces and logos, extract metadata from documents, and retrieve frame-level results with confidence scores. The Playwright server can capture screenshots but cannot interpret them on its own. As vision-capable models become standard, expect more MCP servers to add multimodal inputs and outputs. See the Mixpeek MCP connector at /connectors/mcp-server for the current tool list.

    Why are some popular MCP servers now in a different repo than the docs show?

    Anthropic reorganized its reference servers during 2025 and early 2026. It kept seven servers maintained upstream (Everything, Fetch, Filesystem, Git, Memory, Sequential Thinking, and Time) and moved the rest into a servers-archived repository, handing ownership to the vendors. GitHub now maintains its own server at github/github-mcp-server, Notion publishes @notionhq/notion-mcp-server, Brave ships @brave/brave-search-mcp-server, Linear and Stripe run official hosted remote servers, and the Slack and Puppeteer reference servers were archived in favor of community and Microsoft Playwright alternatives. If you find an old @modelcontextprotocol/server-* package, check whether a maintained vendor version exists before relying on it.

    See how Mixpeek handles this

    Purpose-built for mcp servers for ai agents — not bolted on.

    Agentic RAG

    Mixpeek's dedicated page for this capability — architecture, benchmarks, and how it works.

    Explore Agentic RAG

    Talk to a Mixpeek engineer — free

    30 minutes. Bring your use case and we'll tell you exactly what would work and what wouldn't.

    Schedule a Free Call

    Explore Other Curated Lists

    infrastructure

    Best Vector Databases for Images

    A practical guide to vector databases optimized for image similarity search. We benchmarked query latency, indexing speed, and recall across millions of image embeddings.

    10 tools rankedView List
    infrastructure

    Best RAG Frameworks & Platforms

    A practical comparison of frameworks and platforms for building Retrieval-Augmented Generation applications. We tested each on multi-document QA, citation accuracy, and multimodal RAG scenarios.

    10 tools rankedView List
    infrastructure

    Best Open Source ML Pipeline Frameworks

    A comparison of open-source frameworks for building, orchestrating, and deploying machine learning pipelines. Evaluated on flexibility, scalability, and production readiness for real-world ML workflows.

    10 tools rankedView List