Perplexity MCP Server vs Tavily MCP Server

Perplexity API Platform MCP Server

The official MCP server implementation for the Perplexity API Platform, providing AI assistants with real-time web search, reasoning, and research capabilities through the Agent API and the Search API.

Remote MCP Server

The remote MCP server is hosted by Perplexity and is the easiest way to get started: same tools, nothing to install or update. The Cursor and VS Code buttons at the top of this page connect to it with one click. If your MCP client does not support remote servers yet, skip to the local server setup below. Connect over Streamable HTTP with your Perplexity API key:

https://api.perplexity.ai/mcp

For Claude Code:

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

See the MCP integration docs for manual Cursor/VS Code configuration, usage from the Anthropic API, and setup for other clients.

Local MCP Server

Get Your API Key

1. Get your Perplexity API Key from the API Portal
2. Replace your_key_here in the configurations below with your API key
3. (Optional) Set timeout: PERPLEXITY_TIMEOUT_MS=600000 (default: 5 minutes)
4. (Optional) Set custom base URL: PERPLEXITY_BASE_URL=https://your-custom-url.com (default: https://api.perplexity.ai)
5. (Optional) Set log level: PERPLEXITY_LOG_LEVEL=DEBUG|INFO|WARN|ERROR (default: ERROR)

Claude Code

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

Or install via plugin:

export PERPLEXITY_API_KEY="your_key_here"
claude
## Then run: /plugin marketplace add perplexityai/modelcontextprotocol
## Then run: /plugin install perplexity

Codex

codex mcp add perplexity --env PERPLEXITY_API_KEY="your_key_here" -- npx -y @perplexity-ai/mcp-server

Agent Plugins

This repository is packaged as an Agent Plugin, so clients that support the standard can install it directly from this repository. The Agent Plugins format does not carry secrets, so set the PERPLEXITY_API_KEY environment variable through your client's plugin or MCP settings.

Other MCP Clients

Most clients can be configured manually using the same mcpServers wrapper in their client config (as shown for Cursor). If a client has a different schema, check its docs for the exact wrapper format.

For manual setup, these clients all use the same mcpServers structure:

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

Proxy Setup (For Corporate Networks)

If you are running this server at work—especially behind a company firewall or proxy—you may need to tell the program how to send its internet traffic through your network's proxy. Follow these steps:

1. Get your proxy details

• Ask your IT department for your HTTPS proxy address and port.
• You may also need a username and password.

2. Set the proxy environment variable

The easiest and most reliable way for Perplexity MCP is to use PERPLEXITY_PROXY. For example:

export PERPLEXITY_PROXY=https://your-proxy-host:8080

If your proxy needs a username and password, use:

export PERPLEXITY_PROXY=https://username:password@your-proxy-host:8080

3. Alternate: Standard environment variables

If you'd rather use the standard variables, we support HTTPS_PROXY and HTTP_PROXY.

[!NOTE]
The server checks proxy settings in this order: PERPLEXITY_PROXY → HTTPS_PROXY → HTTP_PROXY. If none are set, it connects directly to the internet.
URLs must include https://. Typical ports are 8080, 3128, and 80.

Self-Hosted HTTP Mode

For cloud or shared deployments, run the server in HTTP mode.

Environment Variables

Docker

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

Node.js

export PERPLEXITY_API_KEY=your_key_here
npm install && npm run build && npm run start:http

The server will be accessible at http://localhost:8080/mcp

Available Tools

perplexity_search

Search results include publication and last-updated dates when available. Missing or null dates are omitted from the formatted output.

Direct web search using the Perplexity Search API. Returns ranked search results with metadata, perfect for finding current information. Supports recency filters (search_recency_filter), domain restrictions (search_domain_filter), and Fast Search (search_type: "fast") for lower latency and cost.

perplexity_ask

General-purpose conversational AI with real-time web search, backed by the Agent API fast preset. Great for quick questions and everyday searches.

perplexity_research

Deep, comprehensive research backed by the Agent API high preset. Ideal for thorough analysis and detailed reports. Runs can take minutes; the server streams the run and reports progress to clients that request it.

perplexity_reason

Advanced reasoning and problem-solving backed by the Agent API medium preset. Perfect for complex analytical tasks.

perplexity_ask and perplexity_reason accept optional positive-integer max_tokens (total search context, up to 120,000) and max_tokens_per_page (context per result page, up to 20,000). These Agent API budgets control retrieved search content, not generated answer length. When omitted, the preset's search configuration remains in effect.

The legacy search_context_size argument is still accepted, but is translated locally into explicit budgets rather than sent to the Agent API:

This compatibility policy is not an exact equivalent of Sonar's named sizes; the Agent API migration guide has no named-size equivalent. Each explicit budget overrides its corresponding legacy default.

[!NOTE]
Presets are managed configurations (model, search setup, step budget) that Perplexity keeps tuned over time; see the presets guide. 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 Agent API produces no <think> tags.

Use as a Library

The package also exports the server factory for embedding in your own Node process:

import { createPerplexityServer } from "@perplexity-ai/mcp-server";

// Single-tenant: reads PERPLEXITY_API_KEY from the environment.
const server = createPerplexityServer("my-service");

// Multi-tenant hosts resolve the key per call instead. When a provider is
// set, the environment variable is never consulted, and a provider that
// returns no key fails the call rather than falling back.
const tenantServer = createPerplexityServer("my-service", {
  apiKey: () => currentRequestApiKey,
});

Mount the returned server on any MCP transport (stdio, streamable HTTP, in-memory).

Troubleshooting

• API Key Issues: Ensure PERPLEXITY_API_KEY is set correctly
• Connection Errors: Check your internet connection and API key validity
• Tool Not Found: Make sure the package is installed and the command path is correct
• Timeout Errors: For very long research queries, set PERPLEXITY_TIMEOUT_MS to a higher value
• Proxy Issues: Verify your PERPLEXITY_PROXY or HTTPS_PROXY setup and ensure api.perplexity.ai isn't blocked by your firewall.
• EOF / Initialize Errors: Some strict MCP clients fail because npx writes installation messages to stdout. Use npx -yq instead of npx -y to suppress this output.

For support, visit community.perplexity.ai or file an issue.

Tavily MCP Server

The Tavily MCP server provides:

• search, extract, map, crawl tools
• Real-time web search capabilities through the tavily-search tool
• Intelligent data extraction from web pages via the tavily-extract tool
• Powerful web mapping tool that creates a structured map of website
• Web crawler that systematically explores websites

📚 Helpful Resources

• Tutorial on combining Tavily MCP with Neo4j MCP server
• Tutorial on integrating Tavily MCP with Cline in VS Code

Remote MCP Server

Connect directly to Tavily's remote MCP server instead of running it locally. This provides a seamless experience without requiring local installation or configuration.

Simply use the remote MCP server URL with your Tavily API key:

https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>

Get your Tavily API key from tavily.com.

Alternatively, you can pass your API key through an Authorization header if the MCP client supports this:

Authorization: Bearer <your-api-key>

Note: When using the remote MCP, you can specify default parameters for all requests by including a DEFAULT_PARAMETERS header containing a JSON object with your desired defaults. Example:

{"include_images":true, "search_depth": "basic", "max_results": 10}

Connect to Claude Code

Claude Code is Anthropic's official CLI tool for Claude. You can add the Tavily MCP server using the claude mcp add command. There are two ways to authenticate:

Option 1: API Key in URL

Pass your API key directly in the URL. Replace <your-api-key> with your actual Tavily API key:

claude mcp add --transport http tavily https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>

Option 2: OAuth Authentication Flow

Add the server without an API key in the URL:

claude mcp add --transport http tavily https://mcp.tavily.com/mcp

After adding, you'll need to complete the authentication flow:

1. Run claude to start Claude Code
2. Type /mcp to open the MCP server management
3. Select the Tavily server and complete the authentication process

Tip: Add --scope user to either command to make the Tavily MCP server available globally across all your projects:

claude mcp add --transport http --scope user tavily https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>

Once configured, you'll have access to the Tavily search, extract, map, and crawl tools.

Connect to Cursor

Click the ⬆️ Add to Cursor ⬆️ button, this will do most of the work for you but you will still need to edit the configuration to add your API-KEY. You can get a Tavily API key here.

once you click the button you should be redirect to Cursor ...

Step 1

Click the install button

Step 2

You should see the MCP is now installed, if the blue slide is not already turned on, manually turn it on. You also need to edit the configuration to include your own Tavily API key.

Step 3

You will then be redirected to your mcp.json file where you have to add your-api-key.

{
  "mcpServers": {
    "tavily-remote-mcp": {
      "command": "npx -y mcp-remote https://mcp.tavily.com/mcp/?tavilyApiKey=<your-api-key>",
      "env": {}
    }
  }
}

Remote MCP Server OAuth Flow

The Tavily Remote MCP server supports secure OAuth authentication, allowing you to connect and authorize seamlessly with compatible clients.

How to Set Up OAuth Authentication

A. Using MCP Inspector:

• Open the MCP Inspector and click "Open Auth Settings".
• Select the OAuth flow and complete these steps:
  1. Metadata discovery
  2. Client registration
  3. Preparing authorization
  4. Request authorization and obtain the authorization code
  5. Token request
  6. Authentication complete

Once finished, you will receive an access token that lets you securely make authenticated requests to the Tavily Remote MCP server.

B. Using other MCP Clients (Example: Cursor):

You can configure your MCP client to use OAuth without including your Tavily API key in the URL. For example, in your mcp.json:

{
  "mcpServers": {
    "tavily-remote-mcp": {
      "command": "npx mcp-remote https://mcp.tavily.com/mcp",
      "env": {}
    }
  }
}

If you need to clear stored OAuth credentials and reauthenticate, run:

rm -rf ~/.mcp-auth

Note:

• OAuth authentication is optional. You can still use API key authentication at any time by including your Tavily API key in the URL query parameter (?tavilyApiKey=...) or by setting it in the Authorization header, as described above.

Choosing an Account for OAuth

Each time you connect, Tavily asks whether to use your personal account or one of your organizations. To switch Tavily logins, choose Use a different account.

• Key used: the account's mcp_auth_default key. Tavily creates it if it doesn't exist.
• Organization keys: used even if another member created the key or your organization restricts key access.
• Personal accounts off: if an organization you belong to disables personal accounts, Personal isn't offered.
• Lost access: if you lose access to the account or its key is deleted, requests fail and ask you to reconnect. Tavily never switches accounts on its own.

Local MCP

Prerequisites 🔧

Before you begin, ensure you have:

• Tavily API key
  • If you don't have a Tavily API key, you can sign up for a free account here
• Claude Desktop or Cursor
• Node.js (v20 or higher)
  • You can verify your Node.js installation by running:
    • node --version
• Git installed (only needed if using Git installation method)
  • On macOS: brew install git
  • On Linux:
    • Debian/Ubuntu: sudo apt install git
    • RedHat/CentOS: sudo yum install git
  • On Windows: Download Git for Windows

Running with NPX

npx -y tavily-mcp@latest

Default Parameters Configuration ⚙️

You can set default parameter values for the tavily-search tool using the DEFAULT_PARAMETERS environment variable. This allows you to configure default search behavior without specifying these parameters in every request.

Example Configuration

export DEFAULT_PARAMETERS='{"include_images": true}'

Example usage from Client

{
  "mcpServers": {
    "tavily-mcp": {
      "command": "npx",
      "args": ["-y", "tavily-mcp@latest"],
      "env": {
        "TAVILY_API_KEY": "your-api-key-here",
        "DEFAULT_PARAMETERS": "{\"include_images\": true, \"max_results\": 15, \"search_depth\": \"advanced\"}"
      }
    }
  }
}

Identifying the End User (Optional)

You can optionally identify the end user on whose behalf requests are being made by setting the TAVILY_HUMAN_ID environment variable. When set, Tavily MCP forwards it as the X-Human-Id header on every API call, enabling per-user analytics.

This is entirely optional — leave it unset and behavior is unchanged.

{
  "mcpServers": {
    "tavily-mcp": {
      "command": "npx",
      "args": ["-y", "tavily-mcp@latest"],
      "env": {
        "TAVILY_API_KEY": "your-api-key-here",
        "TAVILY_HUMAN_ID": "your-user-id"
      }
    }
  }
}

Privacy note: Tavily hashes human_id server-side (SHA-256) before storage, so the raw value is never persisted. Even so, prefer opaque identifiers (e.g. an internal user ID) over raw PII like emails when possible.

Acknowledgments ✨

• Model Context Protocol for the MCP specification
• Anthropic for Claude Desktop