Best Pinecone MCP Server MCP Server Alternatives 2026

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

Free and open-source by Anthropic. Knowledge graph stored locally — no external service costs.

a single structured-reasoning tool that lets a model plan, revise and branch its own chain of thought instead of answering in one shot. Published by Anthropic as part of the official modelcontextprotocol/servers monorepo (89,000+ stars, actively maintained), it exposes exactly one tool — sequential_thinking — and that tool is the whole product. Each call carries a `thought` string plus bookkeeping fields: `thoughtNumber`, `totalThoughts`, and `nextThoughtNeeded`, which the model flips to false when it is done. The interesting fields are the optional ones. `isRevision` and `revisesThought` let the model go back and correct an earlier step rather than plowing ahead on a bad assumption; `branchFromThought` and `branchId` let it fork into an alternative line of reasoning and carry both forward; `needsMoreThoughts` lets it extend past its own original estimate when a problem turns out to be deeper than it looked. In practice you never call the tool by hand. You connect the server to an MCP host and ask a question that deserves more than one pass — plan a PostgreSQL 14 to 16 migration and revise if downtime exceeds five minutes, work out why a deploy only fails in production, compare three architectures and branch when an assumption breaks. You can tell it is working when the host inspector shows repeated sequential_thinking calls with a rising `thoughtNumber` rather than a single response. Install with `npx -y @modelcontextprotocol/server-sequential-thinking` — note the hyphenated package name, which differs from both the `sequentialthinking` directory in the repo and the Docker image `mcp/sequentialthinking`, a mismatch that breaks a lot of copied configs. A Docker image is published alongside the npm package, and the README carries one-click VS Code install buttons for both transports. Set `DISABLE_THOUGHT_LOGGING=true` if you do not want every thought written to the server log.

Free and open-source by Anthropic. Runs locally with no external API dependencies.

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.

The MCP server is free and open-source. Exa: Free tier with 1,000 searches/mo. Pro plans available for higher volume. See official pricing.

The official MongoDB MCP server, `mongodb-js/mongodb-mcp-server`, maintained by MongoDB. Searchers find it as the MongoDB MCP server or the Mongo MCP server; both names refer to this one project, and there is no separate short-form server. It is really two tool surfaces in one process. The database tools connect to any MongoDB deployment over a connection string in `MDB_MCP_CONNECTION_STRING` — `find`, `aggregate`, `explain`, `collection-schema`, `collection-indexes`, `create-index`, `count`, `export`, `mongodb-logs` and the write tools — or, if no connection string is set, the model calls the `connect` tool at runtime and passes the returned `connectionId` to later calls. The Atlas tools are a separate control plane: listing and creating clusters, database users, IP access-list entries, stream processing resources and the performance advisor. They authenticate with Atlas Service Account credentials (`MDB_MCP_API_CLIENT_ID` / `MDB_MCP_API_CLIENT_SECRET`), not with a connection string, and they simply do not register when those are unset — the usual cause of a 'the Atlas tools are missing' report. Two defaults are worth knowing before you point it at production. `readOnly` is false, so every write tool including `drop-database` is registered unless you pass `--readOnly`, which is why MongoDB's own README uses that flag in every example. And confirmation-required tools rely on MCP elicitation, so on a client that does not support elicitation they execute without prompting — `--readOnly` or `--disabledTools` is the actual boundary. Other guardrails: `indexCheck` rejects queries that would do a collection scan, server-side JavaScript (`$where`, `$function`, `$accumulator`) is disabled by default, results are capped at 100 documents and 16 MB per call, and `--dryRun` prints the resolved config and enabled tool list without starting the server. Requires Node 22.13.0 or later (Node 20 is deprecated); also published as the `mongodb/mongodb-mcp-server` Docker image. Runs over stdio by default, with an optional HTTP transport and a separate monitoring listener for `/health` and Prometheus `/metrics`.

The MCP server is free and open-source. MongoDB Atlas: Free tier (512MB). Shared: from $9/mo. Dedicated: from $57/mo. Enterprise: Custom.

OpenAI Codex is a lightweight coding agent that runs in your terminal, and it sits on both sides of the Model Context Protocol — which is exactly the confusion the "codex mcp" search hides. As a client, Codex connects to other MCP servers you configure under `[mcp_servers]` in `~/.codex/config.toml`, and the `codex mcp` subcommand manages those configured launchers. As a server, Codex exposes its own experimental MCP interface: run `codex mcp-server` (alias `codex-mcp-server`) and another MCP client can drive a local Codex engine over stdio using JSON-RPC 2.0. That server interface is genuinely useful and genuinely experimental — the docs state it is subject to change without notice — and it publishes methods to manage threads, turns, accounts, config and approvals: v2 RPCs like `thread/start`, `thread/resume`, `thread/fork`, `turn/start`, `turn/steer`, `turn/interrupt`, `account/login/start`, `config/read`/`config/value/write`, `model/list`, plus v1 compatibility calls (`getConversationSummary`, `getAuthStatus`, `gitDiffToRemote`, fuzzy file search) and streaming `codex/event/*` notifications. Approvals flow the other way as server-to-client requests (`applyPatchApproval`, `execCommandApproval`), so a host UI can gate patch and exec actions. Install the CLI with `npm install -g @openai/codex` (or Homebrew), then start the server with `codex mcp-server`; a quick inspection UI is `npx @modelcontextprotocol/inspector codex mcp-server`. Built in Rust, Apache-2.0 licensed, and by far the most-starred entry in this space at 100,000+ stars. Use this when you want an AI client to orchestrate a real Codex coding session rather than reimplement one.

This MCP server is free and open-source. Check the GitHub repository for details.

The PostgreSQL MCP server was the Model Context Protocol reference server for Postgres, and it is retired: the source now sits in modelcontextprotocol/servers-archived — a repository GitHub reports as archived, described as "Reference MCP servers that are no longer maintained" — and the npm package @modelcontextprotocol/server-postgres carries a deprecation notice reading "Package no longer supported." It still installs and still runs, which is why most third-party setup articles have not caught up. What it provides is deliberately small: a single tool, query, which executes read-only SQL inside a READ ONLY transaction, plus per-table schema information exposed as MCP resources at postgres://<host>/<table>/schema, with column names and data types discovered from database metadata. There is no index advice, no health check, no separate schema-listing tool, and no write mode. Install is npx @modelcontextprotocol/server-postgres with a postgres:// connection string as the argument. For active work against Postgres, the maintained alternative is Postgres MCP Pro (crystaldba/postgres-mcp), which exposes nine tools including index tuning against hypothetical indexes and a database health check, and has an explicit restricted access mode; if your database is hosted on Supabase or Neon, their platform servers add branching and logs that a raw Postgres connection cannot see. Reach for this archived server only when you want the smallest possible surface — one process, one read-only query tool, nothing else.

Free and open-source MCP server. PostgreSQL is free and open-source. Hosting costs depend on your infrastructure choice.

conversational read and write access to any SQLite database file, plus a running business-insights memo that accumulates what the analysis turns up. It is a Python server on PyPI, not a Node one, and the difference is the single most common reason setups fail here: `@modelcontextprotocol/server-sqlite` does not exist on npm, so every npx line for it 404s. The working invocation is `uvx mcp-server-sqlite --db-path /path/to/database.db` (PyPI package mcp-server-sqlite, v2025.4.25), or the equivalent `mcp/sqlite` Docker image with a volume mounted at /mcp. The --db-path argument is required and points at the .db file; the server will create it if it is not there yet. Six tools are exposed, deliberately split by risk: read_query for SELECT only, write_query for INSERT/UPDATE/DELETE, create_table for DDL, list_tables and describe-table for schema introspection, and append_insight, which writes into a memo://insights resource that updates live as findings accumulate — that resource, not the SQL tools, is what makes this server different from a generic database connector. It also ships an mcp-demo prompt that takes a business topic, generates a plausible schema and sample data, and walks through an analysis end to end, which is the fastest way to see the memo behaviour without wiring up real data. One caveat to weigh before adopting it: this is an Anthropic reference implementation that now lives in modelcontextprotocol/servers-archived, archived on 2025-05-28. The published package still installs and runs, but it is frozen — no new features, no dependency updates, and no security patches.

Free and open-source MCP server. SQLite is public domain — completely free with no external service costs.

The Redis MCP Server (redis/mcp-redis) is Redis's own natural-language interface for agentic applications, letting an AI client read and write Redis data over the Model Context Protocol. Note which one you install: the server most tutorials still point at is Anthropic's reference implementation, which now lives in modelcontextprotocol/servers-archived, and its npm package @modelcontextprotocol/server-redis is explicitly marked "Package no longer supported" with a last publish of 2025-04-25. The maintained server is a Python package instead, run with uvx --from redis-mcp-server@latest, and it covers far more of Redis than the reference one did: string, hash, list, set and sorted-set tools; JSON document tools; pub/sub with stateful channel and pattern subscriptions; Streams tools including consumer-group create, read, acknowledge and destroy; vector index management and vector search through the query engine; a docs search tool; and a server-management tool for database info. Connection is a redis:// or rediss:// URL passed as --url, or the REDIS_HOST/REDIS_PORT/REDIS_PWD/REDIS_SSL environment variables, with Redis Cluster mode behind REDIS_CLUSTER_MODE and EntraID service-principal, managed-identity and default-credential auth flows for Azure Managed Redis. There is no --read-only flag: the documented way to stop an agent writing is a Redis ACL user (ACL SETUSER readonlyuser on >pw ~* +@read -@write). Ships as a PyPI package, a GitHub install via uvx, and an official mcp/redis Docker image; stdio transport only.

The MCP server is free and open-source. Redis Cloud: Free tier (30MB). Essentials: from $7/mo. Pro: Custom pricing. Self-hosted Redis is free.

Supabase MCP Server connects Cursor, Claude Code, Claude Desktop, Windsurf and other MCP clients to a Supabase project, and the first thing to know is that the personal access token setup most guides still describe is gone. Supabase now runs a hosted server at https://mcp.supabase.com/mcp using OAuth 2.1 with dynamic client registration — you add the URL, your client opens a browser, you pick the organization, and there is no PAT to mint or rotate. For Claude Code that is `claude mcp add --scope project --transport http supabase "https://mcp.supabase.com/mcp"` followed by `/mcp` in a plain terminal (not the IDE extension) to run the auth flow. Three URL query parameters do the real configuration work: `read_only=true` runs every statement as a read-only Postgres role, `project_ref=<id>` scopes the server to one project and drops the account-management tools entirely, and `features=` selects the tool groups. Those groups are database (list_tables, list_extensions, list_migrations, apply_migration, execute_sql), debugging (get_logs across API/Postgres/Edge Functions/Auth/Storage/Realtime, plus get_advisors for security and performance findings), development (get_project_url, get_publishable_keys, generate_typescript_types), Edge Functions (list, get, deploy), account management, docs search, experimental branching on paid plans, and storage — storage is the one group disabled by default. Running Supabase locally with the CLI exposes a reduced server at http://localhost:54321/mcp with no OAuth; self-hosted installs are similar. The npm package `@supabase/mcp-server-supabase` still exists for stdio clients and also exports `createToolSchemas()` so Vercel AI SDK users get typed tool inputs and outputs. Read Supabase's security best-practices page before pointing this at anything with production data — the mutating tools are real.

The MCP server is free and open-source. Supabase: Free tier (500MB, 50K monthly active users). Pro: $25/mo. Team: $599/mo. Enterprise: Custom.

The Neon MCP Server (neondatabase/mcp-server-neon) is Neon's official, open-source bridge between natural language and the Neon serverless Postgres platform. It translates conversational requests into Neon API and SQL calls, letting Claude, Cursor, VS Code, and other MCP clients create projects and branches, run queries, inspect schemas, and perform database migrations without hand-writing SQL or hitting the API directly. A standout capability is migration support built on Neon's branching: the server can spin up a branch, apply and test a schema change there, and only then merge it — so an assistant can safely run "add a created_at column to the users table" against an isolated copy first. The easiest setup is the remote hosted server at https://mcp.neon.tech/mcp, which supports both OAuth (no API key to manage) and API-key auth via the Authorization header; run `npx neon@latest init` for one-command configuration of Cursor, VS Code (Copilot), and Claude Code, or `npx add-mcp https://mcp.neon.tech/mcp` to register it across all detected editors. Requires Node.js 18+ and a free Neon account; if IP Allow is enabled, whitelist the mcp.neon.tech static IPs. Neon explicitly scopes this server to local development and IDE workflows — its README warns against production use since natural-language commands can execute powerful, irreversible database operations, so always review actions before authorizing them.

The MCP server is free and open-source. Neon: Free tier (0.5 GiB storage). Launch: $19/mo. Scale: $69/mo. Business: $700/mo.