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.
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
Mixpeek MCP Server
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 — PDFs, recordings, 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
{
"mcpServers": {
"mixpeek": {
"command": "npx",
"args": ["mixpeek-mcp"],
"env": {
"MIXPEEK_API_KEY": "your-api-key"
}
}
}
}
// Agent can now call tools like:
// - mixpeek_search({ query: "red car in parking lot", modality: "video" })
// - mixpeek_ingest({ bucket: "surveillance", file: "/tmp/clip.mp4" })
// - mixpeek_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.
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
- -Structured data only — no support for unstructured media, documents, or embeddings
- -SQL generation can produce incorrect queries on complex schemas without guardrails
- -No write operations in default config — limits use in workflow automation
- -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 and local business lookups. 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 both global and local search capabilities — the standard way to give agents access to current information beyond their training data.
Strengths
- +Real-time web search fills the knowledge gap for questions beyond agent training cutoff
- +Local search capability for finding businesses, restaurants, and services by location
- +Privacy-focused: Brave does not track or profile search queries
- +Simple single-tool interface keeps agent prompts clean
Limitations
- -Text results only — cannot search for or return images, video, or audio content
- -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 — returns snippets, not full page content
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), image/video search, or when search quality on niche technical topics is critical (Google's quality is higher).
Integration Example
// claude_desktop_config.json
{
"mcpServers": {
"brave-search": {
"command": "npx",
"args": ["@anthropic/mcp-server-brave-search"],
"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" })GitHub MCP Server
MCP server that connects agents to the GitHub API for repository management, issue tracking, pull request workflows, and code search. Enables agents to participate in software development workflows directly.
Full read-write access to the GitHub API — the most complete software development MCP server, enabling agents to participate in 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 — full workflow automation
- +Supports both GitHub.com and GitHub Enterprise Server
- +Well-maintained by the MCP community with frequent updates
Limitations
- -GitHub-specific — 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 — treats images and binaries in repos 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": "npx",
"args": ["@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "ghp_your_personal_access_token"
}
}
}
}
// 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. 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
- +Supports Slack's OAuth flow for secure workspace authentication
Limitations
- -Requires Slack app creation and OAuth setup — more involved than file or DB servers
- -Message history access depends on Slack plan (free plans limit to 90 days)
- -No support for Slack Huddles, Clips (video), or Canvas documents
- -Rate limits can bottleneck agents that need to search large workspaces
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": ["@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-your-bot-token",
"SLACK_TEAM_ID": "T0123456789"
}
}
}
}
// 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" })Puppeteer MCP Server
MCP server that gives agents browser automation capabilities through Puppeteer. Agents can navigate web pages, take screenshots, fill forms, click buttons, and extract content from rendered pages — useful when APIs are unavailable or when visual inspection is needed.
Full headless browser automation via MCP — the only way to give agents interactive access to JavaScript-rendered web applications without building custom scrapers.
Strengths
- +Full browser automation: navigate, click, type, screenshot, and extract page content
- +Handles JavaScript-rendered pages that static HTTP requests cannot access
- +Screenshot capability gives agents visual context for debugging web UIs
- +Can run headless for server environments or headed for debugging
Limitations
- -Slow compared to direct API calls — each page load adds seconds of latency
- -Resource-heavy: headless Chrome consumes significant memory and CPU
- -Fragile: page structure changes break selectors and automation scripts
- -Screenshots are returned as base64 but most agents cannot interpret them well without vision models
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 — filling forms, clicking buttons, extracting rendered content, or taking screenshots for visual inspection.
Skip This If
When the target has a proper API (use direct API calls instead — faster and more reliable). Also avoid for high-throughput workloads where headless Chrome's resource consumption is prohibitive.
Integration Example
// claude_desktop_config.json
{
"mcpServers": {
"puppeteer": {
"command": "npx",
"args": ["@modelcontextprotocol/server-puppeteer"]
}
}
}
// Agent can now:
// - Navigate: puppeteer_navigate({ url: "https://example.com/dashboard" })
// - Screenshot: puppeteer_screenshot() // returns base64 image
// - Click: puppeteer_click({ selector: "#submit-button" })
// - Extract: puppeteer_evaluate({ script: "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
MCP server for Notion workspace integration, allowing agents to read, create, and update pages, databases, and blocks. 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
- +Read and write access to Notion pages, databases, and blocks
- +Database querying with filters and sorts mirrors Notion's native API
- +Can create structured pages from templates for consistent agent output
- +Useful for agents that need to document their work or read project context
Limitations
- -Notion API rate limits (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": ["@modelcontextprotocol/server-notion"],
"env": {
"NOTION_API_KEY": "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 for documents by name or content, read file contents, and navigate folder structures — 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
- -Read-only for most file types — limited write/create capabilities
- -Google API rate limits (300 requests per minute per user) can constrain heavy use
- -Cannot process media files (images, video) stored in Drive — returns 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": ["@anthropic/mcp-server-gdrive"],
"env": {
"GOOGLE_CLIENT_ID": "your-client-id.apps.googleusercontent.com",
"GOOGLE_CLIENT_SECRET": "your-client-secret"
}
}
}
}
// 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. Agents can create issues, update statuses, search backlogs, and manage cycles — making it the standard way to integrate agents into Linear-based development workflows.
Native Linear integration for engineering workflow automation — the standard way to give agents read-write access to issues, projects, and cycles in Linear-based teams.
Strengths
- +Full Linear API coverage: issues, projects, cycles, labels, and team management
- +Agents can create, update, and search issues with natural-language commands
- +Cycle and project management tools for sprint planning and backlog grooming
- +GraphQL-based Linear API provides efficient, flexible data retrieval
Limitations
- -Linear-specific — does not work with Jira, Asana, or other project management tools
- -Requires Linear API key with workspace access
- -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": ["linear-mcp-server"],
"env": {
"LINEAR_API_KEY": "lin_api_your_key"
}
}
}
}
// 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" })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 ingest video, search by visual similarity, detect faces and logos, transcribe audio, and retrieve frame-level results. The Puppeteer server can take screenshots but cannot interpret them. As vision-capable models become standard, expect more MCP servers to add multimodal inputs and outputs.
Ready to Get Started with Mixpeek?
See why teams choose Mixpeek for multimodal AI. Book a demo to explore how our platform can transform your data workflows.
Explore Other Curated Lists
Best Multimodal AI APIs
A hands-on comparison of the top multimodal AI APIs for processing text, images, video, and audio through a single integration. We evaluated latency, modality coverage, retrieval quality, and developer experience.
Best Video Search Tools
We tested the leading video search and understanding platforms on real-world content libraries. This guide covers visual search, scene detection, transcript-based retrieval, and action recognition.
Best AI Content Moderation Tools
We evaluated content moderation platforms across image, video, text, and audio moderation. This guide covers accuracy, latency, customization, and compliance features for trust and safety teams.