AI & ML MCP Servers

Knowledge graph-based persistent memory system. Store and retrieve contextual information.

Exa's official MCP server connects AI assistants to a search engine purpose-built for AI, using neural embeddings to match on meaning rather than keywords so agents get clean, ready-to-use content instead of a page of blue links to re-parse. The default tool set covers web_search_exa for quick topical lookups and web_search_advanced_exa for full control over domains, date ranges, and content filters, plus specialized tools for code_search (searching real-world code and GitHub), company_research (building company profiles, competitor lists, and financials), crawling/web_fetch (pulling clean content from a specific URL), people_search and linkedin_search (public professional-profile lookups), and deep_researcher_start/check for long-running multi-step research tasks backed by Exa's Research API. The server is hosted at https://mcp.exa.ai/mcp — no local process to run — and connects via one-line setup in Cursor, VS Code, Claude Code, Claude Desktop (available as a native Connector), Codex, OpenCode, Windsurf, and Antigravity, authenticated with an EXA_API_KEY from the Exa dashboard. Tool exposure is tunable per client via a ?tools= query parameter on the endpoint URL, letting teams ship narrow, purpose-built configurations (e.g. company-research-only or LinkedIn-only agents) instead of exposing the full surface, and Exa ships ready-made Claude Skills/agent definitions for common patterns like company research and people search with built-in query-variation and token-isolation guidance.

Embeddings, vector search, document storage, and full-text search with the open-source AI application database.

Connect to Hugging Face Hub APIs - search spaces, papers, explore datasets and models.

Run large language models locally with Ollama. Pull models like Llama 3, Phi-3, and Gemma, execute prompts, and manage model library from AI assistants.

Universal LLM proxy and load balancer. Route requests across 100+ LLM providers (OpenAI, Anthropic, Gemini, Mistral) with a unified API and cost tracking.

Long-term memory layer for AI applications. Store and retrieve user preferences, conversation history, and entity facts with temporal reasoning and semantic search.

Personalized memory layer for AI. Automatically extract and store key information from conversations, enabling truly personalized AI assistant experiences.

AI-native browser automation MCP from Browserbase. Extract structured data, automate complex web interactions, and test websites with natural language instructions.

High-performance vector database MCP server for AI applications. Store and query vector embeddings for semantic search, RAG pipelines, and similarity matching. Connect your AI assistant directly to your Qdrant collections.

Firecrawl web scraping and crawling MCP server. Scrape any URL to clean markdown, crawl entire websites, extract structured data with LLM-powered schemas, and monitor web content changes via Firecrawl API.

E2B secure cloud sandbox MCP server. Execute Python, JavaScript, and R code in isolated sandbox environments, run data analysis scripts, generate matplotlib visualizations, and install packages dynamically via E2B SDK.

This is the same official elevenlabs/elevenlabs-mcp server viewed through its Conversational AI and agent-building toolset. Beyond one-off text-to-speech calls, the server lets an MCP client define a voice agent's persona, voice, and knowledge sources, then deploy it for interactive back-and-forth conversation rather than single audio clips — useful for building phone-style support bots, in-app voice assistants, or narrated demos entirely from natural-language prompts. It shares the same underlying tool surface as the core ElevenLabs server (text-to-speech, voice cloning, speech-to-text with speaker diarization, sound-effect and soundscape generation, vocal isolation) but is discovered separately by users searching specifically for agent/assistant workflows rather than raw audio generation. Requires Python's `uv` tool: install with `uvx elevenlabs-mcp` and set `ELEVENLABS_API_KEY` (free tier: 10k credits/month) in your MCP client config — there is no npm package, despite some third-party listings suggesting otherwise. Output handling is configurable via `ELEVENLABS_MCP_OUTPUT_MODE` (files, base64 MCP resources, or both), making it usable in both local desktop clients and containerized/serverless agent deployments. 1,450+ GitHub stars, actively maintained by ElevenLabs.

Microsoft MarkItDown document conversion MCP server. Converts 29+ formats to clean Markdown including PDFs, Word documents, PowerPoint presentations, Excel spreadsheets, HTML, images (with OCR), and audio files (via transcription). Perfect for feeding rich document content to AI workflows.

Official Anthropic Claude connector for Adobe Creative Cloud with 50+ tools across Photoshop, Premiere Pro, After Effects, Illustrator, Express, and more. Generate and edit images, cut video sequences, apply effects, manage layers, export assets, and automate repetitive production tasks across Creative Cloud apps — all from Claude.

Dynamic and reflective problem-solving through thought sequences.

Search, Query and interact with data in your Milvus Vector Database.

OpenAI does not publish a dedicated, first-party "MCP server" for its own API — a `openai/mcp-server` repo does not exist. Instead, OpenAI's official open-source contribution to the MCP ecosystem is on the client side: openai/openai-agents-python (27,000+ stars), a lightweight framework for building multi-agent workflows with the OpenAI API that ships native support for connecting to MCP servers as a tool source, letting an OpenAI-model-powered agent call out to any MCP server (filesystem, GitHub, databases, etc.) the same way a Claude-based agent would. In other words, OpenAI's MCP investment is "consume MCP tools from an OpenAI agent," not "expose OpenAI itself as an MCP server." Teams that specifically want to call OpenAI's chat, embeddings, or image-generation endpoints as MCP tools from Claude, Cursor, or another MCP client instead rely on small community-built wrapper servers around the OpenAI SDK, authenticated with an `OPENAI_API_KEY`, exposing tools like generate_completion, generate_embedding, or generate_image. Typical use of the Agents SDK side: build a Python agent that uses GPT models for reasoning while pulling live context through an MCP filesystem or web-search server. Update this entry if OpenAI ships a genuine first-party MCP server for its own API in the future.

Open-source tool for collaborative editing, versioning, evaluating, and releasing prompts.

The official ElevenLabs MCP server (elevenlabs/elevenlabs-mcp) connects AI assistants like Claude Desktop, Cursor, Windsurf, and OpenAI Agents directly to ElevenLabs' text-to-speech and audio-processing APIs. Once installed, an AI client can generate natural-sounding speech from text in dozens of voices and languages, clone a voice from a short audio sample, design and save new synthetic voices to a personal voice library, transcribe spoken audio with automatic speaker diarization, isolate vocals from background noise, and compose layered soundscapes (e.g. "a thunderstorm in a dense jungle with animals reacting") from a text prompt. It also exposes ElevenLabs' Conversational AI agent-creation tools, so a client can spin up a voice agent with a defined persona and have it answer questions in character. Install via PyPI/uv with `uvx elevenlabs-mcp` and an `ELEVENLABS_API_KEY` from the ElevenLabs dashboard — the free tier includes 10k credits/month, enough for testing. Optional environment variables (`ELEVENLABS_MCP_BASE_PATH`, `ELEVENLABS_MCP_OUTPUT_MODE`) control whether generated audio is saved to disk, returned as base64-encoded MCP resources for containerized/serverless environments, or both, and `ELEVENLABS_API_RESIDENCY` supports enterprise data-residency requirements. With 1,450+ GitHub stars, it is the most widely adopted way to give an AI coding assistant real audio-generation capabilities without hand-rolling API calls.

Retrieval from AWS Knowledge Base using Bedrock Agent Runtime.

Connect to data, AI tools & agents, and the rest of the Databricks platform using turnkey managed MCP servers.

The official Pinecone Developer MCP Server (pinecone-io/pinecone-mcp) connects coding assistants like Cursor, Claude Desktop, Windsurf, and the Gemini CLI directly to Pinecone's vector database platform. Once connected, an AI client can search live Pinecone documentation to answer setup and API questions accurately, recommend and configure index settings (dimension, metric, pod vs. serverless type) based on an application's embedding model and scale, generate code for common patterns like batch upserts, hybrid search, and metadata filtering, and — when a `PINECONE_API_KEY` is supplied — directly upsert and query vectors in a live index so a developer can test retrieval quality without leaving their editor. It targets developers building with Pinecone as part of their stack, distinct from Pinecone's separate Assistant MCP, which instead surfaces context from a hosted knowledge base for end-user-facing AI assistants. Install with `npx -y @pinecone-database/mcp` (requires Node.js 18+); without an API key the server still works for documentation search, but index management and querying require one from the Pinecone console. A community alternative, sirmews/mcp-pinecone (150+ stars), offers a lighter Python-based server focused purely on index read/write operations for teams that don't need the documentation-search or code-generation tooling.

Weaviate's Model Context Protocol support has moved from a separate add-on into the core Weaviate database itself: as of v1.37.1, every Weaviate instance ships a built-in MCP server that AI assistants like Claude Desktop, Cursor, and Windsurf can connect to directly, with no standalone process to install or maintain. Enabling it is a single environment variable, `MCP_SERVER_ENABLED=true`, on the Weaviate server; the MCP endpoint then listens on the same port as the existing REST API at `/v1/mcp`, reuses Weaviate's existing API-key authentication, and respects the same RBAC permissions already configured for the cluster — so there is no separate credential or trust boundary to manage. Exposed tools cover the core vector-database workflow an AI agent needs: `weaviate-collections-get-config` inspects collection schemas, `weaviate-tenants-list` enumerates tenants in multi-tenant collections, `weaviate-query-hybrid` runs combined vector-plus-keyword hybrid search, and `weaviate-objects-upsert` creates or updates objects. The earlier standalone Go implementation that used to live in the weaviate/mcp-server-weaviate repository is now deprecated and unmaintained — its git history is kept only for reference — so teams should configure MCP through the main weaviate/weaviate server rather than looking for a separate package to install. Full setup, environment variables, and per-tool RBAC permission mapping are documented at docs.weaviate.io/weaviate/configuration/mcp-server.

The official Qdrant MCP server (qdrant/mcp-server-qdrant) turns the Qdrant vector search engine into a semantic memory layer for AI assistants like Claude Desktop, Cursor, and Windsurf. Built on FastMCP, it exposes two core tools: `qdrant-store`, which embeds and saves a piece of text plus optional JSON metadata into a named Qdrant collection, and `qdrant-find`, which runs a semantic similarity search over a collection and returns the most relevant stored entries. Together they let an AI agent persist facts, code snippets, or past conversation context and recall them later by meaning rather than exact keywords — a lightweight long-term memory that survives across sessions. Configuration is entirely environment-variable driven: point `QDRANT_URL` and `QDRANT_API_KEY` at a Qdrant Cloud cluster or self-hosted instance, or use `QDRANT_LOCAL_PATH` to run against an embedded on-disk database with no server. `COLLECTION_NAME` sets a default collection, `EMBEDDING_MODEL` selects the FastEmbed sentence-transformer used to vectorize text (default sentence-transformers/all-MiniLM-L6-v2), and `QDRANT_READ_ONLY` disables the store tool for query-only deployments. Install with `uvx mcp-server-qdrant` (Python/PyPI) and choose stdio or SSE transport via the `--transport` flag. With 1,450+ GitHub stars it is the reference implementation for giving coding agents durable semantic memory.

The arXiv MCP Server bridges AI assistants to arXiv's research repository through the Model Context Protocol, letting Claude, Cursor, VS Code, and other MCP clients search, download, and read academic papers directly inside a conversation. The core workflow is search_papers → download_paper → read_paper: search_papers queries arXiv with boolean, category (cs.AI, cs.LG, cs.CL, cs.CV, stat.ML, quant-ph, and more), and date-range filters while automatically respecting arXiv's 3-second rate limit; download_paper fetches a paper by its arXiv ID (HTML first, PDF fallback) and stores it locally, returning content_length/next_start metadata so clients can safely page through very large papers; read_paper then returns the full text as markdown, with start/max_chars pagination for long documents. list_papers shows everything downloaded locally, and semantic_search searches across that local collection. The server also ships a "deep-paper-analysis" prompt that walks an assistant through executive summary, methodology, results, and future-research-direction analysis for a given paper ID. Install with `uv tool install arxiv-mcp-server` (NOT npm — an unrelated third-party package squats the same name on npm) or via the one-click Claude Desktop .mcpb bundle; a Streamable HTTP transport is available for server deployments. The README explicitly flags that arXiv paper content is untrusted external input and warns about prompt-injection risk (OWASP LLM01/AG01) when feeding raw paper text into agentic pipelines with tool access.

The Semantic Scholar MCP Server is a FastMCP-based Python server that connects Claude, Cursor, VS Code, and other MCP clients to the Semantic Scholar API — the Allen Institute for AI's corpus of 200M+ academic papers — so an assistant can search literature, trace citation networks, and pull author profiles directly inside a conversation instead of guessing from training data. On the paper side it exposes full-text and title-based search with advanced filtering, multi-strategy ranked search, single- and multi-paper recommendations, and efficient batch detail retrieval with customizable field selection. Its citation-analysis tools walk the citation graph in both directions — citations and references — with citation context and influence signals, which is what makes it a strong fit for literature-review and citation-tracing agents rather than one-off lookups. Author tools cover author search, profile details, publication history, and batch author retrieval. It works unauthenticated for light use, but setting a SEMANTIC_SCHOLAR_API_KEY environment variable raises rate limits for heavier workflows; the server handles rate-limit compliance, connection pooling, and graceful shutdown internally. Install with `pip install semantic-scholar-fastmcp` or run it with no install via `uvx semantic-scholar-fastmcp`, then point your client's config at the uvx command. A Smithery one-click install for Claude Desktop and a companion Claude Code skills bundle (expand-references, trace-citations, paper-triage) are also available. Requires Python 3.10+.

This Wolfram Alpha MCP server gives AI assistants a direct line to the Wolfram|Alpha computational knowledge engine, letting them run math, science, unit-conversion, and structured data queries and get back verified answers instead of guessing at arithmetic or facts. It wraps the Wolfram|Alpha API in an MCP-compliant interface with a modular architecture designed to be extended to additional Wolfram APIs and multi-client setups. Beyond the server itself, the project bundles an example MCP client built on Gemini via LangChain, plus an optional Gradio web UI for interacting with both Google AI and the Wolfram Alpha MCP server side by side — useful for testing queries before wiring the server into Claude Desktop, Cursor, or VS Code. Configuration requires a WOLFRAM_API_KEY (a free Wolfram|Alpha AppID) set via a .env file, and an optional GeminiAPI key if using the bundled LangChain client. Install by cloning the repo and running `pip install -r requirements.txt` (or `uv sync`), then point your MCP client at the packaged server.py entry point; a VS Code MCP config template and Docker build files for the client/UI are included in the repo. Because Wolfram|Alpha handles the actual computation server-side, this server is a strong fit for agentic workflows that need reliably correct math or unit conversions rather than LLM-generated approximations.

MiniMax MCP is MiniMax's official, first-party Model Context Protocol server for text-to-image generation, alongside video and audio generation — the highest-starred general-purpose image-generation MCP server on GitHub (1,500+ stars, MIT licensed, actively maintained), a strong signal for the broad "AI image generation MCP" search intent this page targets versus single-model options like Replicate Flux or Stability AI covered in their own dedicated entries elsewhere in this directory. The `text_to_image` tool generates images directly from a prompt; companion tools cover `generate_video` (with the MiniMax-Hailuo-02 model, configurable 6s/10s duration and 768P/1080P resolution), `music_generation` (prompt+lyrics to a full music track via the music-1.5 model), `text_to_audio` plus `voice_clone` and `voice_design` for custom TTS voices, and `query_video_generation` for polling async video jobs. Install via `uvx minimax-mcp -y` (Python/uv-based) with a `MINIMAX_API_KEY` from the MiniMax platform — note the API key and `MINIMAX_API_HOST` must match your account region (Global: api.minimax.io, Mainland China: api.minimaxi.com) or requests fail with an invalid-key error. Supports both stdio (local) and SSE (local or cloud-deployed) transport, with a `MINIMAX_API_RESOURCE_MODE` env var controlling whether generated assets are returned as a URL or downloaded to a local output path. A companion `MiniMax-MCP-JS` package offers an official JavaScript implementation for non-Python environments. Works with Claude Desktop, Cursor, Windsurf, and OpenAI Agents SDK clients — usage incurs MiniMax API costs per generation.

MCP for Replicate Flux Model is a TypeScript server built specifically around Replicate's Flux image-generation models, giving AI assistants a direct tool for generating customized images and SVG assets that match a project's coding vibe or design aesthetic. It streamlines AI-powered visual asset creation for developers — generating illustrations, icons, and mockups on demand from a text prompt without leaving the assistant conversation — using a Replicate API token for auth. Note this server is scoped to Flux image generation rather than Replicate's full model catalog; developers needing broader access to arbitrary Replicate models (video, audio, LLMs, etc.) should look at deepfates/mcp-replicate, a more general-purpose Replicate API server (currently archived but still functional as a reference implementation).

Stability AI has not published a first-party MCP server, but alesurli/mcp-stability-ai is an actively maintained community implementation (npm package `mcp-stability-ai`, MIT licensed, CI-tested) that wires Stability's v2beta image API into Claude Desktop for fully conversational generation and editing — no manual file-path juggling required. On the generation side it exposes three model tiers as separate tools: `generate_image_sd3` (Stable Diffusion 3.5, best overall quality with negative-prompt support, roughly $0.035–$0.065/image), `generate_image_core` (fast generation with built-in style presets, ~$0.03/image), and `generate_image_ultra` (highest photorealistic quality, ~$0.08/image). Editing tools cover the workflows a product or marketing team actually needs: `remove_background` for transparent-PNG cutouts, `replace_background` which swaps and relights a background for product-shot work, `inpaint` for prompt-driven masked-region edits, `search_and_replace` and `search_and_recolor` for maskless object swaps and recoloring by natural-language description, and `outpaint` to extend a canvas in any direction. The author built it specifically as a maintained Stability.ai bridge for people who want the API-based service inside a Claude conversation rather than running a local GPU stack like ComfyUI or Automatic1111 — it is explicitly positioned as a complement to, not a replacement for, those local-first tools. Requires a `STABILITY_API_KEY` from the Stability AI platform; install with `npx -y mcp-stability-ai` and add the key as an environment variable in the Claude Desktop config.

Anthropic does not publish a Model Context Protocol *server* for Claude — a `anthropics/mcp-server` repo does not exist, and Anthropic's own `anthropics/claude-ai-mcp` repo is just an issue tracker for reporting MCP-integration bugs in Claude Desktop and Claude Code, not an installable server. That is because Claude sits on the other side of the protocol: Claude Desktop, Claude Code, and the Claude API are MCP *hosts/clients* that connect OUT to the thousands of servers in this directory (filesystem, databases, GitHub, Slack, and so on) — Anthropic is also the steward of the MCP specification itself, publishing the protocol spec and reference SDKs/servers through the separate `modelcontextprotocol` GitHub org rather than shipping "Claude" as a callable tool server. If you want another AI agent to call Claude as a tool over MCP, no first-party server exists for that today; teams typically wrap the Anthropic Messages API in a small custom MCP server using the official Python/TypeScript SDK. This entry is kept for search/reference purposes — same resolution as the OpenAI, Codeium, and Gitpod entries in this directory, none of which have a first-party MCP server despite the search demand.

Cohere does not ship a dedicated, official Model Context Protocol server — a `cohere-ai/mcp-server` repo does not exist, and the handful of community MCP wrappers found for Cohere's chat/embed/rerank endpoints (e.g. thin single-file projects with zero to a few stars) are early, unmaintained, or unofficial. The closest first-party, actively maintained repo is cohere-ai/cohere-toolkit (3,000+ stars), Cohere's official open-source toolkit for building and deploying RAG and tool-use applications on top of the Cohere platform — it includes reference implementations for connecting retrieval, tool-calling, and agentic workflows to Cohere's Command models, which is the same groundwork any MCP wrapper for Cohere would need. Teams wanting an assistant to call Cohere directly today typically write a small custom MCP server around the Cohere Python or TypeScript SDK, exposing tools like generate_text, embed_documents, or rerank_results authenticated with a `CO_API_KEY`. Typical use once wired up: ask Claude to "embed these 50 support tickets and cluster them by topic" or "rerank these search results by relevance to the user's question," with the assistant calling Cohere's embed/rerank endpoints instead of a generic model. Update this entry if Cohere or a well-adopted community project ships a real dedicated MCP server.

There is no official `mistralai/mcp-server` repo — Mistral AI does not currently publish a first-party MCP server. The most complete real alternative is the community-maintained `mistral-mcp` package (Swih/mistral-mcp, MIT-licensed, published to npm), which exposes the full Mistral API surface as MCP tools, resources, and prompts rather than just chat completions. Unique tools include `mistral_ocr` (Document AI — structured text plus bounding-box annotations from any PDF or image), `voxtral_transcribe` (audio transcription with optional speaker diarization), `codestral_fim` (fill-in-the-middle code completion), and `workflow_execute`/`status`/`interact` for Temporal-backed durable, human-in-the-loop multi-step workflows. It ships four tool-exposure profiles via `MISTRAL_MCP_PROFILE` — `core` (12 tools, default, lean daily use), `admin` (41 tools, full API surface including embeddings, batch, classify, files, agents, TTS), `workflows` (7 tools, pipeline/connector focus), and `metier-docs` (13 tools, document-processing vertical) — plus French-first prompts and skills (meeting minutes, legal summaries, invoice reminders) aimed at European teams evaluating GDPR/DORA-sensitive AI stacks. Install with `npx -y mistral-mcp@latest` (or `claude mcp add mistral -- npx -y mistral-mcp@latest`) and a `MISTRAL_API_KEY`; a Claude Code plugin (`/plugin install mistral-mcp@swih-plugins`) auto-installs and prompts for the key. Typical use: ask Claude to "OCR this invoice PDF and extract the line items" or "transcribe this meeting recording with speaker labels" and the assistant calls straight into Mistral's Document AI and Voxtral models. It is community-built, not an official Mistral integration — nothing here changes Mistral's own data-handling terms.

The Perplexity MCP Server is the official server from Perplexity AI that brings real-time web search, reasoning, and deep research into any MCP-compatible client through the Perplexity Sonar API. Unlike scrapers or search-index wrappers, it taps Perplexity's own answer engine, so Claude gets grounded, citation-backed responses drawn from live web results. The server exposes four purpose-built tools: perplexity_search returns ranked web results with snippets for lightweight lookups; perplexity_ask provides general-purpose conversational answers with real-time search using the sonar-pro model, ideal for quick everyday questions; perplexity_research runs deep, comprehensive investigations with the sonar-deep-research model for thorough analysis and detailed reports; and perplexity_reason handles advanced problem-solving and multi-step analytical tasks with the sonar-reasoning-pro model, with an optional strip_thinking parameter to control chain-of-thought output. Authentication uses a single PERPLEXITY_API_KEY from the Perplexity API dashboard. Installation is a one-line npx command with the official @perplexity-ai/mcp-server package — add it to Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, or Codex, with a Docker image and HTTP transport also supported for server deployments. Because it is Perplexity's first-party implementation (2,300+ GitHub stars), the Perplexity MCP Server is the most reliable way to give an AI agent fresh, sourced answers — perfect for research assistants, fact-checking, and any workflow that needs current information the base model was never trained on.

The Tavily MCP server (tavily-ai/tavily-mcp) is the official, production-ready Model Context Protocol server for Tavily, a search API built specifically for AI agents and RAG pipelines rather than human browsing. It exposes four tools: tavily-search runs real-time web searches tuned for LLM consumption (returning clean, ranked, source-cited results instead of raw HTML), tavily-extract pulls the full clean content out of one or more specific URLs, tavily-map builds a structured map of a site's pages starting from a root URL, and tavily-crawl walks a site to gather content across many pages in a single call. Together these let an assistant answer "search for the latest changelog entries for library X and summarize the breaking changes" or "extract the pricing table from these three competitor pages" with grounded, up-to-date, citation-backed data instead of stale training knowledge. Authentication uses a single `TAVILY_API_KEY` from tavily.com (a generous free tier is available). You can run it locally with `npx -y tavily-mcp@latest` in your Claude Desktop, Cursor, Windsurf, or Cline config, or connect to Tavily's hosted remote server at mcp.tavily.com for a zero-install setup. Typical use: give a coding or research agent live web access so it can verify facts, read documentation it has never seen, and cite real sources — one of the most widely adopted search servers in the MCP ecosystem.

The You.com MCP Server (published as `@youdotcom-oss/mcp`) is a lightweight STDIO bridge that proxies MCP clients to You.com's hosted MCP endpoint at `https://api.you.com/mcp`, rather than running search logic locally — the actual retrieval and ranking happen on You.com's servers. It ships from You.com's own `youdotcom-oss` GitHub organization as part of their dx-toolkit monorepo, not the fabricated `you-com/mcp-server` repo sometimes cited elsewhere. Install by running `npx @youdotcom-oss/mcp` directly in your MCP client config, or add it as a dependency with `bun add @youdotcom-oss/mcp`; authentication requires a `YDC_API_KEY` environment variable, sent as a Bearer token to the hosted endpoint. By default the server exposes three tools: `you-search` for real-time web search grounded in You.com's independent index, `you-research` for deeper multi-step research queries that synthesize across several sources, and `you-contents` for fetching and extracting clean content from specific URLs. A fourth tool, `you-finance`, covers stock/market data but is opt-in only — it must be explicitly added via the `YDC_ALLOWED_TOOLS` environment variable (e.g. `YDC_ALLOWED_TOOLS=you-search,you-finance`) rather than being enabled by default. Typical use: an agent needs current information beyond its training cutoff — "search for the latest news on X" or "research competing products in this space and summarize the differences" — and calls You.com's search/research tools instead of relying on stale internal knowledge or a generic scraping fallback.

Enable AI agents to get structured data from unstructured web.

Next-generation platform empowering AI agents with scalable browser automation.

Codeium does not publish a Model Context Protocol server — a `codeium/mcp-server` repo does not exist, and a GitHub/npm sweep for one turns up nothing beyond unrelated demo and research repos. That is because Codeium's product direction went the other way: the company rebranded its flagship product to Windsurf, an AI-native code editor (parent org Exafunction) that acts as an MCP *client*, letting its built-in Cascade agent call out to external MCP servers (filesystem, databases, GitHub, etc.) the same way Claude Desktop or Cursor do — it does not expose Codeium/Windsurf itself as a tool server. Exafunction's public repos are IDE plugins (windsurf.vim, windsurf.nvim, CodeiumJetBrains, codeium.el) rather than an MCP integration. If you want an AI assistant to read from or control a Codeium/Windsurf workspace over MCP, no first-party or notable community server currently exists for that — this entry is kept for search/reference purposes and will be updated if Codeium ships one.

Tabnine does not publish a Model Context Protocol server — a `tabnine/mcp-server` repo does not exist, and neither GitHub nor npm turn up a real first-party or community MCP integration for it (searches surface only unrelated demo/config repos with 0-3 stars). Tabnine's public engineering effort (org: codota) is entirely IDE-plugin-shaped — clients for VS Code, JetBrains, Vim/Neovim, Sublime, Atom, and JupyterLab that wire Tabnine's completion models into each editor's native autocomplete UI, plus a separate PR-review agent (tabnine-pr-agent). None of these expose Tabnine as an MCP tool server that Claude, Cursor, or another MCP client could call into. This entry is kept for search/reference purposes and will be updated if Tabnine ships a genuine MCP server in the future.

The CodeRabbit MCP Server lets Claude and other MCP-capable coding agents pull CodeRabbit's AI code-review output directly into their working context and act on it programmatically, instead of a developer manually reading through GitHub PR comments. Tools cover the full review lifecycle: get_reviews retrieves every CodeRabbit review left on a given pull request, get_review_details returns the configuration and file list behind a specific review, get_comments extracts individual line-level comments together with CodeRabbit's AI-generated prompts and suggested fixes, get_comment_details digs into one comment's full context and example fix, and resolve_comment marks a comment addressed, won't-fix, or not-applicable so the PR thread stays in sync with what the agent actually did. A bundled /coderabbit-review slash command chains these into an automated "fetch, triage, and implement fixes" workflow, which is the main use case: point an agent at a PR that CodeRabbit has already reviewed and have it work through the suggestions autonomously. Installation is npx coderabbitai-mcp@latest with no local build step; the only required credential is a GitHub Personal Access Token (repo scope for private repos, public_repo for public ones) passed as GITHUB_PAT, since the server reads PR review data through GitHub's API rather than CodeRabbit's own API. This is a community integration, not published by CodeRabbit itself, and depends on a repository already having CodeRabbit reviews enabled.

Translate or rewrite text with DeepL's AI models.

Interact with the Intelligent Content Management platform through Box AI.

Production-ready RAG out of the box to search and retrieve data from your own documents.

RAG Search over your content powered by Inkeep.

Inspect traces, manage prompts, curate datasets, and run experiments with open-source AI observability.

Query and analyze your Opik logs, traces, prompts and telemetry data from your LLMs.

Connect to the Cartesia voice platform to perform text-to-speech, voice cloning.

Open Source data labeling platform.

Free open-source platform for building production-ready AI systems with RAG, evaluations, and fine-tuning.

Access OpenAI models, manage assistants, threads, and files through MCP. Use GPT-4o and o1 models as tools from other AI clients in a unified workflow.

Connect LangChain-powered workflows to MCP clients. Access vectorstores, chains, and agents built with LangChain through standardized MCP tooling.

Control JupyterLab notebooks from AI assistants. Execute cells, inspect variables, visualize outputs, and manage kernels programmatically.

Run 200+ open-source AI models via Together AI's inference API. Access Llama, Mistral, Qwen, and other top models with high throughput and low latency.

Ultra-fast LLM inference using Groq's LPU hardware. Access Llama 4, Mixtral, and other models at speeds up to 500 tokens/second via MCP.

Run quantized language models locally with llama.cpp. Highly optimized CPU inference for Llama, Mistral, Phi, and GGUF-format models.

Access Google's Gemini and other AI models via Vertex AI. Fine-tune models, run batch predictions, and manage ML pipelines with enterprise-grade security.

Deploy and manage ML models on AWS SageMaker. Run inference on endpoints, manage training jobs, track experiments, and use SageMaker Studio capabilities.

Data framework for LLM applications. Index documents, build RAG pipelines, query knowledge bases, and create multi-step agents over structured and unstructured data.

Multi-agent AI orchestration framework. Define crews of AI agents with specialized roles, tools, and tasks. Automate complex multi-step workflows.

Microsoft's multi-agent conversation framework MCP. Build agents that collaborate, code, debug, and solve problems through structured dialogue and tool use.

Access DeepSeek's reasoning and code models via MCP. Use DeepSeek-R1 for complex mathematical and coding problems with extended chain-of-thought reasoning.

Run Python functions in the cloud with Modal. Deploy serverless GPU workloads, schedule jobs, build ML pipelines, and access data lakes without infrastructure setup.

Knowledge graph-based memory for AI systems. Build structured knowledge from unstructured data, query entity relationships, and enhance AI with persistent context.

Fully managed RAG-as-a-service MCP. Index documents, PDFs, and data sources. Query knowledge bases with semantic search and structured extraction.

Yahoo's open-source AI search and serving engine MCP. Run vector search, lexical search, and structured search with ML model serving and real-time updates.

Generate and edit images with Adobe Firefly's generative AI. Create artwork, generate from text, remove backgrounds, and produce brand-safe creative assets.

AI-native vector database MCP server. Store and query embeddings at scale, perform semantic search, manage vector indexes, and build RAG pipelines using LanceDB's columnar storage engine.

AI-native vector database MCP integration. Perform semantic search, manage vector collections, import objects, and run GraphQL queries on your Weaviate instance from any MCP-compatible AI assistant.

Access 200+ open-source AI models via Together AI from your MCP workflow. Run inference on Llama, Mistral, Qwen, DeepSeek, and other cutting-edge models directly through your AI assistant. Ideal for AI-to-AI orchestration.

Mistral AI language model MCP server. Access Mistral's suite of models (Mistral Large, Mistral Small, Codestral) for text generation, code completion, and embeddings from within your MCP workflow.

Helicone LLM observability MCP server. Query your LLM request logs, analyze cost and latency trends, detect prompt regressions, and monitor AI application performance — all from your AI assistant.

LiveKit MCP server for real-time voice and video AI applications. Manage rooms, participants, and recordings. Build voice AI agents that can join calls, transcribe audio, and respond in real-time using MCP tools.

Perplexity AI search and research MCP server. Perform AI-powered web searches, get cited answers with real-time sources, conduct deep research queries, and access Perplexity Sonar models via Perplexity API.

Tavily AI-optimized search API MCP server. Perform real-time web searches designed for LLM reasoning, retrieve clean search results with context windows, and access topic-filtered news and research via Tavily Search API.

Access 200+ AI models through a single unified API via OpenRouter. Route requests to GPT-4o, Claude, Gemini, Llama, Mistral, and more with automatic fallbacks and cost optimization.

Connect to locally running LLMs via LM Studio. Run Llama, Mistral, Phi, Gemma, and hundreds of GGUF models on your own hardware with full privacy — no API keys required.

High-throughput LLM inference via vLLM. Run PagedAttention-optimized serving for open-source models at production scale with continuous batching and streaming support.

LangChain's LLM observability and evaluation platform. Trace, debug, and evaluate LLM application runs, compare prompts, and monitor production performance via LangSmith API.

Connect to Dify AI application platform. Build, test, and deploy LLM-powered workflows, RAG pipelines, and AI agents using Dify's visual orchestration interface via MCP.

Integrate with Flowise, the open-source drag-and-drop LLM flow builder. Execute chatflows, query vector stores, and manage AI pipelines built in Flowise's visual editor.

Voice AI platform via Vapi. Create voice assistants, manage phone calls, configure voice workflows, and analyze call transcripts through Vapi's API.

Visual LLM workflow builder via Langflow. Execute flows, query RAG pipelines, manage components, and integrate pre-built AI workflows from Langflow's open-source drag-and-drop interface.

Generate AI avatar videos with HeyGen. Create talking-head videos from text scripts, clone voices, translate videos into 40+ languages, and manage video projects.

Create AI-generated training and marketing videos with Synthesia. Generate realistic avatar videos from text, customize presenters, and export in multiple formats.

Generate and edit short AI videos with Pika. Create video clips from text prompts, animate images, and apply visual effects using Pika's generative video API.

Generate cinematic AI videos with Luma Dream Machine. Create photorealistic video clips from text descriptions, extend videos, and control camera movements.

Auto-generate and edit video captions with Captions AI. Add subtitles, translate captions to 28 languages, apply animated styles, and export SRT/VTT files.

Debug and monitor LLM applications with LangSmith. Trace LLM calls, evaluate outputs, manage datasets for testing, and track performance metrics across model versions.

Open-source LLM observability and evaluation with Arize Phoenix. Trace AI pipelines, evaluate retrieval quality, detect hallucinations, and monitor embedding drift.

Test and evaluate LLM prompts with Promptfoo. Run automated evaluations, compare model outputs, detect regressions, and find security vulnerabilities in AI applications.

Manage and evaluate LLM prompts with Humanloop. Version control prompts, collect human feedback, run A/B experiments, and monitor production AI model performance.

Deploy stateful AI agents with persistent memory using Letta (formerly MemGPT). Manage agent memory, create personas, and build multi-agent systems that remember across sessions.

Browse, use, and share prompts from LangChain Hub. Discover community prompts, pull templates into your applications, and publish your own prompt library entries.

Evaluate and monitor LLM applications with TruLens. Track groundedness, answer relevance, and context precision. Debug RAG pipelines and detect hallucinations in production.

LLM testing framework MCP integration. Run automated evaluations on LLM outputs, measure hallucination rates, check factual accuracy, and CI/CD integration for AI quality gates.

Access Weights & Biases (wandb) experiment tracking and ML platform. Query runs, compare experiments, retrieve metrics, manage artifacts, and analyze ML training data.

Transcribe audio and video files using AssemblyAI's speech-to-text API. Supports speaker diarization, auto-chapters, sentiment analysis, entity detection, and real-time transcription.

Real-time and batch speech recognition via Deepgram's Nova-3 model. Transcribe audio with word-level timestamps, language detection, punctuation, and speaker diarization.

Direct integration with OpenAI API for accessing GPT-4o, o1, DALL-E, Whisper, and Embeddings. Useful for multi-model workflows, image generation, and text embedding pipelines.

Connect to LawGeex AI contract review via MCP. Automate contract analysis, clause detection, risk identification, and redlining against your legal playbook. Integrate AI-powered contract review into transactional workflows for procurement, sales, and legal ops teams.

Integrate with ThoughtSpot AI-powered analytics via MCP. Use natural language search across your data warehouse, generate Liveboards, access SpotIQ AI insights, and embed analytics. Connect to Snowflake, BigQuery, Databricks, and 50+ cloud data sources through ThoughtSpot Sage.

Access the AlphaFold Protein Structure Database via MCP. Retrieve predicted 3D protein structures for over 200 million proteins, confidence scores per residue (pLDDT), predicted aligned error matrices, and download mmCIF or PDB format coordinates. Query by UniProt accession for any organism in the database.

Roboflow computer vision platform API — manage image datasets, run object detection and classification models, annotate images, and deploy custom vision models to production.

MLflow experiment tracking and model registry MCP — log ML runs, compare metrics, register and version models, manage artifacts, and query experiment history across your machine learning projects.

Neptune.ai MLOps experiment tracker MCP — log training runs, track hyperparameters, compare model versions, manage datasets, and monitor ML pipelines with rich metadata storage for research and production workflows.

ClearML MLOps platform MCP — manage experiment tracking, model deployment, data versioning, and ML pipelines. Query task history, compare runs, clone experiments, and orchestrate distributed training jobs.

Comet ML experiment management MCP — track experiments, log metrics and parameters, compare model versions, visualize training curves, manage model registry, and collaborate on ML research across teams.

BentoML model serving and deployment MCP — build and deploy ML services, manage Bentos and runners, scale inference endpoints, monitor serving performance, and package models for production with any framework.

Unstructured.io document processing MCP — extract text and structure from PDFs, Word docs, HTML, images, and emails. Parse tables, forms, and complex layouts for downstream LLM ingestion and RAG pipelines.

LlamaIndex LlamaParse document parsing MCP — parse complex PDFs, tables, figures, and structured documents with state-of-the-art accuracy for RAG and LLM workflows. Supports multi-modal document understanding.

Marqo tensor search and vector database MCP — index and search multimodal content (text, images), manage indexes, perform semantic search, run hybrid lexical-vector queries, and build AI-native search experiences.

Open WebUI self-hosted AI interface MCP — manage conversations, switch between local and API-based LLMs, query chat history, manage model configurations, and interact with Ollama and OpenAI-compatible backends.

AnythingLLM private AI workspace MCP — manage workspaces, ingest documents, query embedded knowledge bases, configure LLM providers, and build custom AI agents with your own data in a self-hosted environment.

LibreChat open-source AI chat platform MCP — manage multi-model conversations, configure endpoints (OpenAI, Claude, Gemini, Ollama), manage presets, query conversation history, and administer users and settings.

Jan local-first AI assistant MCP — run local LLMs (Llama, Mistral, Gemma) on your hardware, manage model downloads, switch between local and cloud AI, and interact with the Jan OpenAI-compatible API server.

Botpress conversational AI platform MCP — manage bots, inspect conversation flows, query message logs, update intents and entities, deploy bot updates, and monitor chatbot performance across channels.

DVC (Data Version Control) ML pipeline MCP — query experiment runs and metrics, retrieve tracked dataset versions, compare model performance across commits, manage pipeline stages, access artifact storage locations, and reproduce ML experiments with version-controlled data.

Feast open-source feature store MCP — retrieve feature values for online inference, query historical feature data for training, manage feature views and entities, browse the feature registry, monitor feature freshness, and inspect feature statistics for ML pipelines.

Official MCP server for Azure AI Foundry (formerly Azure ML Studio). Access models, knowledge bases, evaluations, deployments, and experiments. Manage AI model lifecycle, fine-tuning jobs, and endpoint deployments across Azure AI services.

MCP server for Groq's ultra-fast LLM inference API. Access Llama, Mixtral, and Gemma models at blazing speeds via GroqCloud. Ideal for latency-sensitive AI workflows needing sub-second response times.

Run local LLMs via Ollama from any MCP-compatible client. Pull, run, and interact with open-source models like Llama 3, Mistral, CodeLlama, and Gemma entirely on-device. No API keys, full privacy.

Run thousands of open-source AI models via Replicate's API. Access image generation (FLUX, SDXL), video generation, audio models, and custom fine-tunes. Stream outputs and manage prediction lifecycle.

MCP integration for Cohere's enterprise NLP platform. Access Command models for generation, Embed for semantic search, Rerank for relevance scoring, and RAG pipelines. Optimized for enterprise retrieval use cases.

Access 800,000+ ML models, datasets, and Spaces on Hugging Face Hub via MCP. Run inference on hosted models, search the model library, download datasets, and interact with Gradio Spaces programmatically.

MCP server for OpenAI's Realtime API enabling low-latency voice and audio interactions. Build voice assistants, transcription pipelines, and real-time audio processing workflows with GPT-4o Audio.

Generate images with Stable Diffusion and SDXL via Stability AI's API. Supports text-to-image, image-to-image, inpainting, outpainting, and upscaling. Access the full Stability AI model suite including SD3 and SDXL Turbo.

Generate and edit video using Runway's Gen-3 Alpha model. Create video from text prompts, extend clips, apply style transfers, and use AI magic tools for video post-production via MCP.

Create AI-powered talking avatar videos via HeyGen's API. Generate video avatars from text, clone voices, translate videos, and create personalized video messages at scale through MCP.

Text-to-image generation with exceptional text rendering via Ideogram's API. Create images with accurate, legible text, logos, and typography. Supports V2 and V2 Turbo for fast high-quality generation.

This is the same official pinecone-io/pinecone-mcp server viewed through its RAG-pipeline and production-index angle. Beyond documentation search, teams use it to script batch upserts of embeddings into Pinecone indexes, run similarity queries with metadata filters and namespace scoping to test retrieval quality for a RAG application, and manage serverless vs. pod-based index configuration directly from an AI coding assistant — useful when iterating on chunking strategy, embedding model choice, or reranking logic without leaving the editor. Supports namespaces for multi-tenant applications and metadata filtering for hybrid structured/vector search. Install with `npx -y @pinecone-database/mcp` and a `PINECONE_API_KEY` from the Pinecone console (Node.js 18+ required); documentation-search tools work even without a key, but index read/write requires one. Maintained directly by Pinecone at 70+ GitHub stars.

Open-source embedding database for AI applications. Store and query embeddings with metadata filtering for RAG workflows. Supports multiple embedding functions and runs locally or in the cloud.

High-performance vector database for billion-scale similarity search via Milvus MCP. Manage collections, insert vectors, run ANN search, and build production RAG systems with hybrid search combining dense and sparse vectors.

Intelligent memory layer for AI applications. Automatically extracts, stores, and retrieves relevant memories across conversations. Enables personalized AI experiences with user-specific context that persists across sessions.

Long-term memory for AI agents and chatbots via Zep's API. Automatically summarizes, embeds, and retrieves conversation history. Supports entity extraction, fact-based recall, and temporal reasoning for stateful AI apps.

Trusted RAG platform for enterprise AI. Ingest documents, query corpora, and build grounded AI applications with Vectara's Boomerang embedding model. Includes hallucination detection and factual consistency scoring.

Multimodal AI search and embeddings via Jina AI. Generate embeddings, perform web search, read URLs, classify content, and segment text. Includes Jina Reader for clean web content extraction optimized for LLMs.

State-of-the-art text and code embeddings via Voyage AI. Generate high-quality embeddings optimized for retrieval, rerank search results, and build semantic search applications. Purpose-built embeddings for legal, code, and finance domains.

Open-source embeddings and data visualization via Nomic Atlas. Generate competitive-quality embeddings with nomic-embed, visualize high-dimensional data in Atlas maps, and build semantic search on private data.

Enterprise search and vector database via Vespa's APIs. Deploy applications, feed documents, run queries combining BM25 and vector search, and manage ML models. Powers recommendation, RAG, and hybrid search at scale.

Fast AI image and video generation via Fal.ai serverless GPU platform. Generate images with Flux, SDXL, and other leading models. Run LoRA fine-tuning, video generation, real-time image editing, and background removal. Sub-second inference for production workflows.

Control ComfyUI local Stable Diffusion workflows via MCP. Execute node-based image generation pipelines, queue prompts, monitor job progress, load custom checkpoints and LoRAs, and retrieve generated images. Supports SDXL, SD1.5, Flux, and any custom workflow JSON.

InvokeAI Stable Diffusion studio integration via MCP. Generate images, run inpainting and outpainting workflows, manage model checkpoints, apply ControlNet conditioning, and access the canvas history. Supports local and remote InvokeAI instances over REST API.

AUTOMATIC1111 Stable Diffusion WebUI server integration for MCP. Generate images via txt2img and img2img endpoints, apply extensions, manage the model list, run interrogate/CLIP captioning, and control generation parameters. Works with any A1111-compatible UI including Forge.

StackBlitz Bolt AI app builder integration via MCP. Create full-stack web applications with a single prompt, manage project files in the WebContainer runtime, install npm packages, preview running apps, and export production builds. Supports React, Vue, SvelteKit, and more.

Lovable AI-powered full-stack app builder via MCP. Generate React + Supabase applications from natural language, manage project repos, trigger build deployments, update component code, and integrate databases. Ideal for rapid SaaS prototyping without writing boilerplate.

Vercel v0 generative UI design tool via MCP. Generate shadcn/ui React components from text descriptions, refine existing UI components, export clean TypeScript code, and integrate with Vercel deployments. Produces production-quality Tailwind CSS components instantly.

Cloudflare Workers AI inference platform via MCP. Run 50+ AI models at the edge including LLaMA, Mistral, Stable Diffusion, and Whisper. Access text generation, embeddings, image classification, translation, and speech-to-text — all serverless with no GPU setup required.

IBM watsonx.data lakehouse integration via MCP. Query document libraries, run natural language analytics against IBM's data lakehouse platform, retrieve structured data using the watsonx.data AI-powered retrieval service, and interact with enterprise data stored in watsonx.

IBM Data Intelligence unified MCP gateway for the watsonx ecosystem. Exposes and manages MCP tools across microservices in IBM's Data Intelligence platform, enabling AI agents to access data catalogs, lineage information, quality metrics, and enterprise data governance tools from a single endpoint.

Generate interactive Plotly charts and dashboards from data — scatter, bar, heatmaps, 3D, and more.

Run ultra-fast inference on Cerebras hardware — Llama, Mistral, and other models at hardware-accelerated speed.

Access AI21 Labs Jamba and Jurassic models for text generation, contextual answers, and paraphrase rewriting.

Use xAI Grok models for real-time web-aware generation, reasoning, and code tasks via the xAI API.

Build and query Haystack NLP pipelines — document search, QA, RAG, and extraction using Haystack components.

Connect to Rasa conversational AI — test dialogue flows, manage NLU training data, and query bot responses.

Manage Google Dialogflow CX agents, intents, flows, pages, and test conversations.

Scaffold and query Vercel AI SDK streaming apps, route handlers, and multi-step agent implementations.

Use IBM Watson services — NLP, speech-to-text, tone analysis, and Watson Assistant via unified MCP interface.

Fast LLM inference via Fireworks AI — run Llama, Mixtral, Gemma, and fine-tuned models at production speed with low latency.

Run inference on SambaNova Cloud — access Llama 4, Llama 3.1 405B, and other large models on SambaNova's custom RDU hardware with ultra-low latency.

Host and run ML models on DeepInfra — access open-source LLMs, image generation, embeddings, and ASR models via a simple OpenAI-compatible API.

Deploy and query ML models on Anyscale — run Ray Serve endpoints, scale LLM inference, and manage fine-tuned model deployments on Anyscale's managed Ray platform.

Deploy and call ML models on Baseten — invoke Truss-packaged models, manage deployments, monitor performance, and handle autoscaling for production AI workloads.

Manage GPU cloud workloads on RunPod — spin up serverless endpoints, manage pods, query GPU availability, and run custom AI inference at scale.

Build and train ML models on Lightning AI — launch cloud studios, run training jobs, deploy models, and manage compute via the Lightning AI platform API.

Fine-tune and deploy LLMs on Gradient — manage fine-tuning jobs, deploy models, run inference, and monitor model performance via Gradient AI API.

AI video generation platform for personalized video at scale. Create hyper-personalized videos using AI-powered replicas.

Empathic Voice Interface powered by emotional intelligence. Build voice AI that understands and responds to human emotions.

Award-winning AI voice generator and text-to-speech platform with 500+ voices in 100 languages.

Studio-quality AI voiceovers in minutes. Access 120+ AI voices for videos, podcasts, and presentations.

AI text-to-speech API with ultra-realistic voice cloning. Generate natural-sounding speech in 900+ voices.

Enterprise AI voice platform for creating studio-quality voiceovers. Create consistent brand voices at scale.

Build, test, and deploy conversational voice AI agents. Create AI phone agents with natural conversations.

Send and receive phone calls with AI. Create autonomous AI phone agents for sales, support, and scheduling.

AI-powered digital humans and avatar video generation. Create lifelike talking head videos from text or audio.

AI-powered video repurposing tool. Automatically clip long videos into viral short-form content for social media.

AI-powered video creation platform. Turn text prompts into professional videos with AI-generated scripts and visuals.

AI video creation from long-form text and articles. Automatically create branded short videos from blogs and scripts.

AI-powered podcast creation and editing. Transcribe, edit audio, and generate AI voices for podcast production.

Conversational AI for games and virtual worlds. Create NPC characters with persistent memory, knowledge, and voice.

Pack your entire repository into a single AI-friendly file. Prepare codebases for LLM analysis and context windows.

AI-powered codebase search and Q&A. Ask questions about any GitHub/GitLab repo in natural language.

Online video editing and creation platform with AI tools. Trim, caption, translate, and repurpose video content via API.

Modal Labs serverless GPU cloud — deploy, run, and manage ML models and Python functions with instant scale.

Inferless serverless ML inference platform — deploy and call AI models with automatic GPU scaling.

Lepton AI cloud platform for deploying open-source LLMs and AI applications with simple Python APIs.

Cerebrium ML infrastructure platform — deploy GPU workloads and custom AI models serverlessly via MCP.

SambaNova AI inference platform — run Llama 4, DeepSeek, and Qwen models on SambaNova reconfigurable dataflow architecture for enterprise AI.

Luma AI video generation API — create AI videos from text or images using Dream Machine, generate 3D NeRF captures, and manage generated content.

Kling AI video generation — create high-quality cinematic videos from text prompts and images using Kuaishou's state-of-the-art video diffusion model.

Interact with Ray clusters for distributed ML training, hyperparameter tuning, data processing, and AI serving at scale.

Manage Azure ML experiments, datasets, compute clusters, model registries, and deployments through AI-assisted MLOps workflows.

Access AWS Bedrock foundation models — Titan, Jurassic, Stable Diffusion, and more — through AI agent workflows without API key management.

Integrate with Fundraise Up's AI-powered donation platform for optimizing giving flows, recurring upgrades, and donor retention at nonprofits.

Integrate Darktrace AI cybersecurity platform for self-learning threat detection, autonomous response, email security, cloud security posture, and zero-trust enforcement.

Access Google Vertex AI ML platform — deploy and query models, run batch predictions, manage Vertex AI Feature Store and Model Registry, trigger AutoML training jobs, and integrate Vertex AI Search and Conversation APIs.

Interact with Deepnote collaborative data notebooks — run notebook cells, query results from executed code, manage projects and integrations, share notebooks, and export notebook outputs to PDF or HTML formats.

AI-powered content creation via Jasper API — generate marketing copy, blog posts, social media content, and ad creative using brand voice profiles, access Jasper templates and workflows, retrieve AI-generated content variants, manage campaigns and content calendar, apply brand voice and style guidelines, run plagiarism and quality checks, and integrate generated content with CMS platforms.

Marketing content generation via Copy.ai API — generate ad copy, email sequences, product descriptions, and social posts using GTM-ready templates, run batch content generation workflows, access brand voice settings, retrieve generated content history, manage content projects and workflows, integrate with CRM and email platforms, and export content in multiple formats.

AI content generation via Writesonic API — produce SEO-optimized articles, landing pages, product descriptions, and ad copy, use Chatsonic for real-time web-connected content, manage brand voice profiles and factual data, generate content in 30+ languages, access readability and SEO scoring, run bulk content generation, and export content directly to CMS platforms.

Connect to Harvey AI for legal research, contract analysis, and drafting — perform due diligence document review, generate legal memos and briefs, analyze regulatory requirements, extract key clauses from agreements, identify risks in contracts, and accelerate legal workflows across practice areas including M&A, litigation, and compliance.

Integrate Luminance AI-powered contract lifecycle management — review and negotiate contracts using legal AI, auto-redline agreements against preferred positions, manage contract repositories, track obligation deadlines, identify anomalous clauses, and run playbook-based review workflows for NDAs, MSAs, and other commercial agreements.

Accelerate contract drafting and review with Spellbook — draft contract clauses from scratch, review agreements against standard playbooks, suggest missing provisions, flag aggressive terms, generate redlines, compare against market standards, and automate routine contract tasks across NDAs, service agreements, and employment contracts.

Integrate Aider AI pair programming tool via its local API — start and manage Aider sessions on local codebases, send natural language coding instructions and receive diffs, manage file context additions and removals, switch between LLM backends, access commit history created by Aider, retrieve session logs and change summaries, and build automated code generation and refactoring pipelines using Aider as a code execution engine.

Control Cognition AI's Devin autonomous software engineer via their API — create and assign coding tasks with natural language specifications, retrieve task status and progress updates, access session transcripts and code outputs, review PRs generated by Devin, manage knowledge base items and playbooks, pull task completion metrics and time tracking, and integrate Devin into engineering workflows for automated feature development and bug fixing.

Integrate Continue open-source AI code assistant via their extension API — manage custom model configurations, retrieve context providers and slash commands, access codebase indexing status and embeddings, configure prompt templates and system prompts, pull usage analytics and model performance metrics, manage team-shared configs via config.yaml, and build custom Continue extensions and context providers for specialized development workflows.

Automate GitHub issue resolution via Sweep AI's coder bot API — create Sweep tasks from issue descriptions, retrieve PR status and code change summaries, access Sweep's codebase understanding and search results, manage sweep.yaml configuration files, pull task completion metrics, access refactoring and test generation workflows, and integrate Sweep into CI/CD pipelines for automated code maintenance and technical debt reduction.

AI-powered contract lifecycle management platform. Automate contract creation, negotiation, approval workflows, and obligation tracking.

All-in-one contract management platform for in-house legal teams. Create, negotiate, sign, and manage contracts with AI-powered automation.

AI-powered contract management and repository tool. Extract key terms, track obligations, set renewal alerts, and search across your contract portfolio.

Contract analytics and management platform. Get instant AI-generated contract summaries, identify risks, and manage obligations at scale.

Enterprise contract lifecycle management with AI. Automate contract processes, extract metadata, track KPIs, and manage vendor performance.

Autonomous commercial negotiations AI. Automate supplier negotiations and contract amendments at scale, achieving better commercial outcomes 24/7.

AI-powered contract review and negotiation assistant. Identify missing and risky clauses, apply your playbook, and speed up contract review cycles.

AI-powered personalization platform by Mastercard. Deliver individualized experiences across web, email, mobile, and kiosk for retail and financial services.

Customer experience personalization platform for e-commerce. Real-time decisioning, product recommendations, and AI-powered 1:1 personalization at scale.

AI-powered code explanation and documentation tool. Get instant explanations for any code snippet, function, or codebase section in plain English.

Generate high-quality text-to-speech audio via the Speechify API — convert long-form documents, articles, and notes to natural-sounding speech, select from premium AI voices, adjust speaking speed and pitch, produce MP3/WAV output files, support SSML markup, and integrate audio content generation into accessibility tools and content creation pipelines.

Generate images with Midjourney via the unofficial Midjourney proxy API — submit /imagine prompts, retrieve generated images, use variation and upscale commands, manage job queues, access image URLs and seeds, apply style parameters (aspect ratio, version, quality), and integrate AI image generation into creative and marketing automation workflows.

Extract structured data from PDFs and documents via the Docparser API — parse invoices, contracts, and forms using pre-trained document parsers, retrieve extracted fields and line items, manage document queues, access parsing results as JSON, configure custom parsing rules, and integrate intelligent document processing into accounts payable, contract management, and data extraction workflows.

Extract text and structured data from documents using AWS Textract — analyze PDFs and images to detect text, tables, forms, and key-value pairs, process multi-page documents asynchronously, access signature detection and expense analysis, retrieve bounding box coordinates, query lending and identity document models, and build intelligent document processing pipelines on AWS infrastructure.

Task Master AI is the most widely-used AI-driven task management framework for software development, with 12,000+ GitHub stars and a purpose-built MCP server that plugs directly into Claude Desktop, Cursor, Windsurf, and any MCP-compatible coding agent. Created by eyaltoledano, it converts high-level project requirements into structured, dependency-tracked development tasks that an AI agent can plan, execute, and update autonomously across coding sessions. The MCP server exposes tools to initialize a project from a PRD or specification document, parse and break down complex tasks into subtasks, list all tasks with their status and dependencies, get next recommended task based on dependency resolution, mark tasks as in-progress or done, update task details and acceptance criteria, expand single tasks into subtasks with AI-generated breakdowns, and view the full task dependency graph. Task Master AI integrates tightly with Claude's extended thinking for complex planning and supports Perplexity for research-backed task breakdowns. Install globally via npm, then run `task-master init` to scaffold your project. Configure the MCP server in your client's JSON config pointing at the globally installed binary. Task Master AI dramatically improves autonomous coding agent quality by keeping Claude focused on the correct next task, preventing scope drift, and maintaining context across long multi-session projects.

MCP Shrimp Task Manager is an intelligent task management server built specifically for AI coding agents — emphasizing chain-of-thought planning, reflection, and style consistency across development sessions. It converts natural language project descriptions into structured, dependency-tracked development tasks with iterative refinement built in. Rather than treating tasks as a flat to-do list, Shrimp models tasks with explicit dependencies, execution state, and reasoning traces so the AI agent can pick up exactly where it left off across sessions. Supports Cursor, Roo Code, Windsurf, Claude Code, and any MCP-compatible client. Features include an optional GUI for visualizing task graphs, multi-language template support (English, Chinese, and more), configurable data directory, and a demo video showing end-to-end agent-driven development. With 2,100+ GitHub stars and a dedicated documentation site, Shrimp Task Manager is one of the most-starred agentic task management MCP servers available. Install by cloning the repo, running npm install + npm run build, and pointing your MCP client at the built index.js.

AI Data Parser is a credit-based document-parsing API that converts PDFs, images, invoices, receipts, resumes, and unstructured forms into schema-guaranteed JSON via a single POST request. Designed for AI agents and automation pipelines, it accepts your target JSON schema and guarantees the response validates against it — eliminating the fragile post-processing step that breaks most extraction workflows. Free tier ships 50 credits with no card required. Paid packs ($9/500 credits up to $99/10,000) mean you pay per document, not per month — ideal for agent workflows with variable volume. The API ships with OpenAPI spec, llms.txt, and copy-paste tool definitions for OpenAI and Anthropic tool use, so integration into Claude or GPT-4o agents takes minutes. An MCP server is on the roadmap (planned Q3 2026), which will let Claude Desktop, Cursor, Windsurf, and any MCP-compatible coding agent call the parser as a native tool — ask it to "parse this invoice" and get back clean JSON without any boilerplate. Use cases: invoice data extraction, receipt parsing, resume screening, bank statement normalization, contract field extraction, and form digitization.