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.
Skip the research? Mixpeek runs MCP servers for AI agents on your own data — extraction, indexing, and search in one platform.
Start freeQuick 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.
Mixpeek MCP Server
Best for agents that need to see, hear, and search media, not just read text.
Filesystem MCP Server (Anthropic)
Best for code editing agents and local document workflows where text files are the primary data.
PostgreSQL MCP Server
Best for data analysis agents that need to query relational databases conversationally.
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
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
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
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
Auth, rate limiting, error handling, logging, and whether the server can run in a containerized or self-hosted environment for enterprise use.
Overview
Jump to
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.
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"] })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.
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" })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).
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" })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.
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 toolsGitHub 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.
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..." })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.
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" })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.
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" })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.
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 })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.
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" } })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.
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" })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.
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 })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.
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" })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.
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" }] })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.
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" })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 ManagedAlready 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 MVSFrequently 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.
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.
Explore Other Curated Lists
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.
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.
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.