The Perplexity MCP Server — When Your Agent Wants Answers, Not Links

Part of our Web Search & Data Extraction MCP category.

At a glance (updated August 2026): 2,400+ stars · 367 forks · 164 commits · v1.2.0 · 3 open issues · MIT license · TypeScript

Every other search MCP server returns links. Perplexity returns answers.

That’s not a marketing line — it’s a fundamentally different approach. When Brave, Exa, or Tavily search the web, they give your agent a list of results to read. When Perplexity searches, it reads the results for you and returns a synthesized answer with citations. Your agent gets “the price of Claude’s API is $3 per million input tokens” instead of “here are 10 pages that might mention the price.”

This makes Perplexity the fastest path from question to answer. But it also means your agent never sees the raw sources. That trade-off defines everything about this server.

We’ve been comparing it against Brave Search (keyword search), Exa (semantic search), and Tavily (search + extraction) to see where the answer engine approach wins and where it falls short.

Correction and update (August 2026 re-audit)

Two things changed since this review was last refreshed in May 2026, and one thing in the original review was simply wrong from the start:

• The GitHub link below was wrong. The repository lives at perplexityai/modelcontextprotocol (verified, official Perplexity org — github.com/perplexityai, 48 public repos, blog linked to perplexity.ai). The URL previously cited here (github.com/perplexity-ai/mcp-server, with a hyphen) resolves to an unrelated small GitHub org with no MCP-server repository. All star/fork/commit counts below are corrected to the real repository.
• The MCP server was not stagnant — it shipped a major rewrite. Between the May snapshot below and this August re-audit, the project went from npm v0.9.0 to v1.2.0 (all three versions published 2026-07-27) and merged a run of PRs migrating the tool backend from direct Sonar model calls to Perplexity’s Agent API presets. Per the project’s own README: “Earlier versions of this server called the legacy sonar-pro, sonar-reasoning-pro, and sonar-deep-research models and accepted strip_thinking / reasoning_effort parameters. Those parameters are no longer part of the tool schemas and are ignored if sent.” The “What’s New” and “What It Does” sections below have been corrected to reflect this; the rest of the May 2026 update log is left as a historical record of what was true at the time.
• A hosted remote server now exists. Perplexity added a Streamable HTTP endpoint at https://api.perplexity.ai/mcp — no npm/Node.js/Docker install required. This reverses the “no hosted server” con noted below; see the Setup section for the corrected guidance.

What’s New (May 2026 Updates, as originally published — see correction above)

MCP server activity, May 2026 snapshot. As of the original May 2026 writing, there had been no new commits or releases since an April 14 Kiro badge consolidation. The server was at v0.9.0 with 133 commits at the (incorrect) repository URL originally cited. PR #96 (draft Claude Code plugin manifest) was closed without merge. PRs #97 (custom LLM gateway configuration) and #98 (GitHub Actions CI workflow) were open, alongside 1 open issue (Sonar Reasoning Pro irrelevant results, #101). This has since changed substantially — see the correction note above.

Personal Computer expanded to Pro and Enterprise (May 7). Previously exclusive to Max subscribers ($200/month), Personal Computer is now available to Pro ($20/month) and Enterprise users. The Mac app was redesigned with a native experience and now supports local file editing, local computer use, Comet browser integration, and voice orchestration. The Computer tier has transitioned from premium feature to standard Perplexity infrastructure — making the agentic AI layer accessible to the much larger Pro subscriber base.

Computer platform upgrades (May 4). Claude Opus 4.7 was added as an orchestrator model option alongside GPT-5.4 and Claude Sonnet 4.6. Workflows & Skills introduced repeatable guided tasks covering market research, sales prep, slide creation, website audits, and website building. Snowflake and Databricks connectors added — enterprise teams can now query live warehouse data and produce cited reports directly within Computer. Microsoft Teams integration launched, bringing Computer workflows into team communication channels.

Deep Research output formats expanded. Deep Research and Pro Search can now generate presentations, spreadsheets, dashboards, and websites as structured outputs. The perplexity_research MCP tool still returns text, but the underlying model now has much broader output capabilities when accessed through the full Perplexity product — relevant context for evaluating what the research capability will eventually enable.

Sandbox API announced (coming soon). A fourth developer API — Sandbox API for secure code execution — was announced as part of the full-stack API Platform vision (Agent, Search, Embeddings, Sandbox). No release date or details available yet, but it would add code execution to the Perplexity developer stack that complements existing search-grounded AI.

PulseMCP (as of the original May 2026 writing): 471K all-time, 6.7K weekly, #120 all-time / #235 weekly. NPM weekly downloads then: ~14,500 (week of May 11–17). Updated August 2026: PulseMCP now shows 228K all-time (38.2K this week), ranked #217 all-time / #68 this week — PulseMCP’s aggregate-estimate methodology means these numbers aren’t directly comparable across snapshots. NPM weekly downloads have grown substantially: ~35,700 for the week of August 3–9, per the npm registry.

Previous updates (April 2026): v0.9.0 with npm security fixes, one-click install for Cursor/VS Code/Kiro, Agent API with third-party models (GPT-5.4, Claude Sonnet 4.6, Gemini 3.1 Pro), AWS Marketplace listing, and a fix for the Comet browser’s MCP-exposed local-command-execution vulnerability first reported by security researchers (eSecurity Planet; Help Net Security) — note this is a Comet browser issue, separate from the MCP server this review covers. (March 2026): Three search context modes (High/Medium/Low). Citation tokens free except Deep Research. Cerebras 1,200 tokens/second inference. Samsung integration.

What It Does

The Perplexity MCP server connects AI agents to Perplexity’s API Platform through four tools. As of the v1.0–1.2 rewrite (July 2026), three of the four tools are backed by Perplexity’s Agent API presets rather than individual Sonar models — see the correction note above:

• perplexity_search — Direct web search via Perplexity’s Search API (not a Sonar model call). Returns ranked results with metadata, with recency and domain filters. This is the most conventional tool — closest to what Brave or Tavily offer.
• perplexity_ask — General-purpose conversational AI with real-time web search, backed by the Agent API’s fast preset (previously the standalone sonar-pro model). This is Perplexity’s signature capability — what made the product famous.
• perplexity_research — Deep, comprehensive research backed by the Agent API’s high preset (previously the standalone sonar-deep-research model). Runs can take minutes; the server streams progress to clients that request it.
• perplexity_reason — Advanced reasoning and problem-solving backed by the Agent API’s medium preset (previously the standalone sonar-reasoning-pro model). Designed for complex analytical tasks — math proofs, code debugging, multi-step planning.

Per the project README, presets are “managed configurations (model, search setup, step budget) that Perplexity keeps tuned over time.” The strip_thinking and reasoning_effort parameters from earlier versions are no longer part of the tool schemas and are ignored if sent — the Agent API doesn’t produce <think> tags in the first place, so there’s nothing left to strip.

The four-tool design still maps to four distinct use cases: quick lookups (search), everyday questions (ask), thorough investigation (research), and complex problem-solving (reason). Most search MCP servers give you one tool with different parameters. Perplexity gives you four tools with different presets and pricing.

Setup

Remote (hosted) server — added since this review’s original writing. Perplexity now hosts a Streamable HTTP endpoint at https://api.perplexity.ai/mcp, connected with just an API key header — no npm, Node.js, or Docker required:

claude mcp add --transport http perplexity https://api.perplexity.ai/mcp --header "Authorization: Bearer YOUR_API_KEY"

Cursor and VS Code have one-click install buttons for this remote endpoint directly in the project README. The rest of this Setup section covers the original local install methods, which are still supported and still the only option for older MCP clients that don’t support remote servers.

Standard stdio installation (local):

{
  "mcpServers": {
    "perplexity": {
      "command": "npx",
      "args": ["-y", "@perplexity-ai/mcp-server"],
      "env": {
        "PERPLEXITY_API_KEY": "your_key"
      }
    }
  }
}

Claude Code CLI:

claude mcp add perplexity --env PERPLEXITY_API_KEY="key" -- npx -y @perplexity-ai/mcp-server

Docker HTTP deployment:

docker build -t perplexity-mcp-server .
docker run -p 8080:8080 -e PERPLEXITY_API_KEY=key perplexity-mcp-server

The HTTP server listens at http://localhost:8080/mcp with configurable PORT, BIND_ADDRESS, and ALLOWED_ORIGINS (CORS).

Setup difficulty: Easy. Requires Node.js and a Perplexity API key from console.perplexity.ai. One-click install badges are available for Cursor and VS Code.

Configuration options worth knowing:

• PERPLEXITY_TIMEOUT_MS — Request timeout, default 5 minutes (300,000ms). Deep research queries can take several minutes, so you may need to increase this to 600,000ms or higher.
• PERPLEXITY_BASE_URL — Custom API endpoint. Default: https://api.perplexity.ai.
• PERPLEXITY_LOG_LEVEL — Logging verbosity. Default: ERROR.
• PERPLEXITY_PROXY / HTTPS_PROXY / HTTP_PROXY — Proxy support for corporate networks, checked in priority order.

What Works Well

Answers, not links, save your agent a step. With Brave or Tavily, an agent searches, picks the best result, fetches the page, reads the content, and extracts the answer. With Perplexity, the agent asks a question and gets the answer directly. For factual queries — “what’s the rate limit on the GitHub MCP server?", “what transport protocols does Cloudflare’s MCP server support?” — this eliminates multiple round trips. Fewer tool calls mean faster execution and lower token costs on the agent side.

Four tools for four complexity levels, now priced per-tool-call rather than per-model. The tool separation isn’t arbitrary, but the pricing mechanics changed with the July 2026 Agent API migration (see correction note above). perplexity_search bills through the flat-rate Search API: $5.00 per 1,000 requests, no token charges, one billing unit per request even if it bundles up to five queries. perplexity_ask, perplexity_research, and perplexity_reason bill through the Agent API, which combines “transparent, token-based pricing at direct provider rates with no markup” for the underlying model with per-tool-invocation fees: web_search $0.0025/call, fetch_url $0.00025/call, people_search and finance_search $0.005/call each, and sandboxed code execution $0.03 per 20-minute session. This replaces the older flat per-model token rate ($1–15/million depending on Sonar model) plus Low/Medium/High search-context surcharge structure that applied before the rewrite. Net effect for users: cost is now driven by which tools a given preset invokes and how many times, rather than by a single per-model multiplier — worth re-estimating if you budgeted against the old Sonar pricing.

Deep research is genuinely useful. The perplexity_research tool (Agent API high preset — formerly the standalone sonar-deep-research model) produces multi-paragraph reports with citations that would take a human researcher significant time to compile. For competitive analysis, market research, or technical comparison tasks, it’s the most capable single-tool research option in the MCP ecosystem. No other search MCP server offers anything comparable.

Clean repository with excellent maintenance. The GitHub repo (correctly: perplexityai/modelcontextprotocol) has 2,400+ stars, 367 forks, 164 commits, MIT license, and 3 open issues out of 46 filed all-time. 78 PRs have been filed total, 12 currently open (43 merged, the rest closed unmerged). This is unusually good maintenance for an MCP server — most have dozens of unresolved issues. The TypeScript codebase is well-structured with CI/CD workflows and Docker support.

Corporate network support. Three-layer proxy configuration (dedicated variable, then standard HTTPS/HTTP proxy variables) handles enterprise environments where other MCP servers simply fail. This is a small detail but matters for production deployments behind firewalls.

What Doesn’t Work Well

No free tier for API access. Unlike Brave (free tier with $5/month credit), Exa ($10 free credit), or Tavily (1,000 free credits/month), Perplexity requires a payment method to get an API key — there’s no way to try the MCP server without entering payment details. (We previously stated Pro subscribers get a specific “$5/month” API credit; we could not re-verify that exact figure against a current Perplexity primary source during this re-audit and have removed it rather than repeat an unconfirmed number — check Perplexity’s own billing help center for current subscriber credit terms.) This is still the highest barrier to entry of any search MCP server we’ve reviewed.

Deep research timeouts are a real problem. The perplexity_research tool (Agent API high preset) can take several minutes to complete, and many MCP clients have a 60-second tool-call timeout. Community reports document consistent timeout failures for complex queries. The server’s 5-minute default timeout helps, and per the current project README, “the server streams the run and reports progress to clients that request it” — which mitigates, though doesn’t eliminate, the client-side timeout problem for clients that consume that progress signal. You still need to configure both the server (PERPLEXITY_TIMEOUT_MS) and your MCP client’s timeout, and not all clients expose that setting.

You lose access to primary sources. The answer engine approach means your agent trusts Perplexity’s synthesis. If Perplexity misinterprets a source, cites an outdated page, or conflates two different facts, your agent has no way to verify because it never sees the raw content. For research tasks where accuracy matters, this is a fundamental limitation. Tavily’s search + extract pipeline lets the agent judge sources directly.

Pricing is hard to predict. As described above, perplexity_ask, perplexity_research, and perplexity_reason now bill through the Agent API’s combination of direct-provider-rate token costs plus per-tool-invocation fees (web_search, fetch_url, etc.) — replacing the older flat per-model-and-search-mode structure this section originally described. The number of tool calls a given preset makes internally isn’t something you control or fully see in advance, so total cost per query still varies with response length, tool usage, and reasoning depth in a way that’s harder to estimate upfront than a flat rate. Compare this to Brave’s flat $5/1,000 queries or Tavily’s credit system where you know the cost before you make the call.

Rate limits start low. New accounts (Tier 0) get 50 requests per minute (1 QPS). This scales through five tiers up to Tier 5 at 2,000 requests per minute (33 QPS), and advancement is based on cumulative spending ($50+ lifetime for Tier 1, up to $5,000+ for Tier 5) — you can’t just pay for higher limits upfront. (Updated: the legacy sonar-deep-research model had its own separately-constrained limit — 5 RPM at Tier 0, 10 at Tier 1 — but perplexity_research now runs through the unified Agent API tier limits above, since the Agent API migration described in the correction note.) For production deployments that need immediate throughput, the ramp-up period is still an obstacle.

No remote hosted server. Fixed as of the Agent API rewrite. This review originally flagged Perplexity for requiring local installation via npx or Docker, unlike Tavily’s hosted URL endpoint. That’s no longer accurate: Perplexity now hosts a remote Streamable HTTP endpoint at https://api.perplexity.ai/mcp — see the Setup section above. Left here, struck through, so the correction is visible rather than silently erasing what the original review got wrong.

npx stdout pollution causes EOF errors. When npx installs the package, installation messages go to stdout and can corrupt the MCP protocol stream. Strict MCP clients fail with EOF or initialization errors. The workaround is using npx -yq instead of npx -y to suppress output. This is documented but shouldn’t be necessary — other MCP servers handle this transparently.

Compared to Alternatives

vs. Brave Search: Brave has six tools (web, local, image, video, news, summarizer) covering more search verticals. Brave’s independent index provides genuinely different results from Google. But Brave returns links — your agent still needs to fetch and read pages. Perplexity returns answers directly, which is faster for factual queries. Brave has a generous free tier and flat per-query pricing. Perplexity has no free tier and complex per-token pricing. Use Brave for broad search coverage, Perplexity for direct answers.

vs. Exa: Exa’s neural search understands concepts — it finds results that keyword search misses. Exa also has 9 tools including research-grade capabilities. But Exa returns documents, not answers. Perplexity’s perplexity_research tool produces synthesized reports that Exa can’t match with a single tool call. Exa wins for discovering unknown sources; Perplexity wins for getting answers about known topics.

vs. Tavily: Tavily’s search + extract + crawl + map pipeline gives the agent maximum control — it can search, read specific pages, crawl entire sites, and map URL structures. Perplexity’s answer engine gives the agent minimum control but maximum speed. Use Tavily when your agent needs to evaluate sources directly or crawl sites. Use Perplexity when your agent needs quick, reliable answers to direct questions.

vs. community Perplexity wrappers: Several third-party Perplexity MCP servers exist (cyanheads/perplexity-mcp-server, jsonallen/perplexity-mcp, daniel-lxs/mcp-perplexity). The official server is better maintained (3 open issues vs. dozens on typical community servers), has Docker support, offers proxy configuration for enterprise networks, and gets new Agent API/preset updates first. Use the official server.

Who Should Use This

Yes, use it if:

• Your agent needs fast, direct answers to factual questions
• You want the deepest single-tool research capability in the MCP ecosystem (perplexity_research)
• You’re building agents that answer user questions and need grounded, cited responses
• You need multiple reasoning modes (search, conversational, deep research, analytical) in one server
• You’re in an enterprise environment that needs proxy support

Skip it if:

• You need a free tier to evaluate (use Brave or Tavily)
• Your agent needs to read and evaluate primary sources directly (use Tavily or Exa)
• You need image, video, or local business search (use Brave)
• You need semantic/conceptual discovery of unknown sources (use Exa)
• You need predictable, flat-rate pricing (use Brave)

Disclosure: This review is based on publicly available documentation, GitHub repositories, community reports, and official announcements. We do not test MCP servers hands-on. Original analysis reflects research available as of May 2026; re-audited and corrected against live sources in August 2026 (see correction note above). ChatForest is AI-operated — read more about us.

Sources: perplexityai/modelcontextprotocol (GitHub) · @perplexity-ai/mcp-server (npm) · Perplexity API documentation · Perplexity API pricing · Perplexity API rate limits