Provides AI-powered web search, deep research, reasoning, brainstorming, code review, explanations, and file analysis with real-time web grounding and citations using Perplexity's Sonar, Sonar Pro, Sonar Reasoning Pro, and Sonar Deep Research models.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Perplexity MCP Server ask perplexity about the latest advancements in AI"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server that brings Perplexity to Claude Code — AI-powered web search, deep research, reasoning, brainstorming, code review, explanations, and file analysis. All with real-time web grounding and citations. Supports Sonar, Sonar Pro, Sonar Reasoning Pro, and Sonar Deep Research models.
Go to Perplexity API Settings
Create an account or sign in
Generate an API key
Copy the key (you'll need it in Step 3)
Node.js 18+ - Download here
Claude Code CLI - Installation guide
git clone https://github.com/wynandw87/claude-code-perplexity-mcp.git
cd claude-code-perplexity-mcpmacOS / Linux / Windows:
npm installNote: Dependencies are installed and the server is built automatically in one step.
Choose your install scope:
Scope | Flag | Who can use it |
User (recommended) |
| You, in any project |
Project |
| Anyone who clones this repo |
Local |
| Only in current directory |
Replace YOUR_API_KEY with your actual Perplexity API key, and use the full path to dist/index.js.
Tip: To get the full path, run this from the cloned directory:
macOS/Linux:
echo "$(pwd)/dist/index.js"Windows:
echo %cd%\dist\index.js
macOS / Linux:
claude mcp add -s user Perplexity -e PERPLEXITY_API_KEY=YOUR_API_KEY -- node /full/path/to/dist/index.jsWindows (CMD):
claude mcp add -s user Perplexity -e "PERPLEXITY_API_KEY=YOUR_API_KEY" -- node "C:\full\path\to\dist\index.js"Windows (PowerShell):
claude mcp add -s user Perplexity -e "PERPLEXITY_API_KEY=YOUR_API_KEY" '--' node "C:\full\path\to\dist\index.js"The setup scripts handle dependency installation, building, and registration automatically.
macOS / Linux:
chmod +x setup.sh
./setup.sh YOUR_API_KEYWindows (PowerShell):
.\setup.ps1 -ApiKey YOUR_API_KEYOr use the npm helper (if API key is set in environment):
export PERPLEXITY_API_KEY=YOUR_API_KEY
npm run install:claudeClose and reopen Claude Code for the changes to take effect.
claude mcp listYou should see Perplexity listed with a Connected status.
Related MCP server: Perplexity MCP Server
Web Search (search_web) - AI-powered web search with domain filtering, recency filtering, and detailed citations
Deep Research (deep_research) - Exhaustive multi-step research using sonar-deep-research
Reasoning + Search (search_with_reasoning) - Step-by-step reasoning combined with live web search
Raw Search (search) - Ranked search results with titles, URLs, and snippets
General Queries (ask) - Web-grounded Q&A with automatic citations
Brainstorming (brainstorm) - Creative ideation informed by real-time web data
Code Review (code_review) - Code analysis with web-grounded best practices
Explanations (explain) - Clear concept explanations with web-grounded accuracy
File Upload (upload_file) - Upload documents and images for analysis (text files, images)
Once installed, use trigger phrases to invoke Perplexity:
Trigger | Tool | Example |
| Ask | "ask perplexity about quantum computing" |
| Web Search | "perplexity search: latest React 19 features" |
| Deep Research | "perplexity deep research on Rust vs Go for microservices" |
| Reasoning | "perplexity reason about RSC vs traditional SSR performance" |
| Raw Search | "perplexity raw search for MCP server TypeScript examples" |
| Code Review | "perplexity review this function for security" |
| Brainstorm | "perplexity brainstorm ideas for authentication" |
| Explain | "perplexity explain how WebSockets work" |
| Upload File | "perplexity upload ./report.py and review it" |
Or ask naturally:
"Ask Perplexity what the latest best practices are for Next.js"
"Have Perplexity review this code for security issues"
"Brainstorm with Perplexity about scaling strategies"
"Perplexity search the web for the latest news on AI"
"Do a deep research with Perplexity on the state of WebAssembly"
"Perplexity reason through the tradeoffs of microservices vs monolith"
"Upload this CSV to Perplexity and ask it to summarize the data"
Query Perplexity with web-grounded answers and citations.
Parameters:
prompt (string, required) - The question or instruction
model (string, optional) - Model identifier (defaults to sonar-pro)
search (boolean, optional) - Enable web search grounding (default: true)
Search the web with domain and recency filtering. Best-in-class AI search.
Parameters:
query (string, required) - The search query or question
allowed_domains (string[], optional) - Only include results from these domains (max 5)
excluded_domains (string[], optional) - Exclude these domains from search (max 5)
recency (string, optional) - "hour", "day", "week", "month"
detail (string, optional) - Search depth: "low", "medium", "high"
Conduct exhaustive, multi-step research on a topic. May take 30-60+ seconds.
Parameters:
query (string, required) - The research question or topic to investigate
Step-by-step reasoning combined with live web search.
Parameters:
prompt (string, required) - The question or problem requiring deep reasoning
allowed_domains (string[], optional) - Only include results from these domains (max 5)
recency (string, optional) - "hour", "day", "week", "month"
Get raw ranked search results without AI synthesis.
Parameters:
query (string, required) - The search query
max_results (integer, optional) - Number of results (1-50, default: 10)
domain_filter (string[], optional) - Filter to these domains only (max 5)
recency (string, optional) - "hour", "day", "week", "month"
Code review with web-grounded current best practices.
Parameters:
code (string, required) - The code to review
focus (string, optional) - Specific focus area (e.g., "security", "performance")
Brainstorming informed by real-time web data and current trends.
Parameters:
topic (string, required) - The subject to brainstorm about
context (string, optional) - Additional context
Clear explanations with web-grounded accuracy.
Parameters:
concept (string, required) - What to explain
Upload a document or image for analysis.
Parameters:
file_path (string, required) - Absolute path to the file to upload
query (string, optional) - Question to ask about the file immediately after upload
model (string, optional) - Model identifier (defaults to sonar-pro)
Supports text files (.txt, .md, .py, .js, .ts, .csv, .json, etc.) and images (.png, .jpg, .gif, .webp).
Model | Best For |
| Quick queries, summaries — fast and cost-effective |
| Default — complex queries, citations, multi-step reasoning |
| Multi-step reasoning with live web search |
| Exhaustive research, comprehensive reports |
All models have 128K context windows and real-time web grounding.
Variable | Required | Default | Description |
| Yes | — | Perplexity API key |
| No |
| Default model for text tools |
| No |
| API timeout in ms |
This MCP server uses the Perplexity REST API directly (Chat Completions and Search endpoints) with native fetch. No SDK dependency — just @modelcontextprotocol/sdk and zod. It connects to Claude Code via stdio transport.
Tools provided:
Tool | API | Default Model |
| Chat Completions | Configurable ( |
| Chat Completions + domain/recency filters |
|
| Chat Completions |
|
| Chat Completions |
|
| Search API | — |
| Chat Completions |
|
| Chat Completions |
|
| Chat Completions |
|
| Chat Completions (inline/vision) | Configurable ( |
If you entered the wrong API key, remove and reinstall:
claude mcp remove PerplexityThen reinstall using the command from Step 3.3 above (use the same scope you originally installed with).
Check if the server is installed:
claude mcp listIf not listed, follow Step 3 to install it.
Verify your API key is valid at Perplexity API Settings
Check Node.js version (needs 18+):
node --versionEnsure the server was built — if dist/index.js is missing, run npm install again
Check that dist/index.js exists — if not, run npm install
Verify the path is absolute in your claude mcp add command
Restart Claude Code after any configuration changes
Deep research uses 5x base timeout — it's expected to take longer
Reasoning and search tools use 3x base timeout
Increase PERPLEXITY_TIMEOUT environment variable for slow connections
sonar-deep-research can take 30-60+ seconds for comprehensive research. This is normal — it's doing multi-step investigation across many sources.
claude mcp listPull requests welcome! Please keep it simple and beginner-friendly.
MIT
Made for the Claude Code community
Ask Perplexity a question with real-time web-grounded answers and citations. Trigger: 'use perplexity', 'ask perplexity', or 'perplexity:' followed by a question.
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | The question or prompt for Perplexity | |
| model | No | Model identifier (optional, defaults to sonar-pro). Models: sonar, sonar-pro. | |
| search | No | Enable web search grounding (default: true) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full burden. It mentions 'real-time web-grounded answers and citations', which gives some behavioral context, but it lacks details on authentication, rate limits, or output format (e.g., how citations are presented). This is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, consisting of two clear sentences with no extraneous information. The key purpose and triggers are front-loaded, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has three parameters (one required), no output schema, and no nested objects, the description covers the essential purpose and triggers. However, it could be slightly more complete by describing the return format (e.g., structure of citations) since there is no output schema to rely on.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all three parameters with descriptions, achieving 100% schema coverage. The description adds trigger phrases and mentions 'web-grounded', which aligns with the 'search' parameter, but does not provide significant additional meaning beyond the schema. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'ask' and the resource 'Perplexity' with real-time web-grounded answers and citations. It also provides trigger phrases. However, it does not explicitly differentiate from sibling tools like 'search' or 'deep_research', making it less than perfect.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides trigger phrases for when to use this tool, such as 'use perplexity' or 'ask perplexity'. However, it does not mention when not to use it or suggest alternatives, leaving the usage context implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Brainstorm solutions with Perplexity, informed by real-time web data and current trends. Trigger: 'perplexity brainstorm', 'brainstorm with perplexity', or 'perplexity ideas'.
| Name | Required | Description | Default |
|---|---|---|---|
| topic | Yes | The topic to brainstorm about | |
| context | No | Additional context |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description mentions that the tool is 'informed by real-time web data and current trends', indicating it uses web search. However, without annotations, it lacks disclosure about potential external service dependencies, rate limits, or the nature of the AI-generated responses, which is important for a brainstorming tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with only two sentences plus a list of trigger phrases, and the purpose is front-loaded. Every sentence adds value, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (brainstorming with external web data), the description is too brief. It does not explain the expected output format, the role of Perplexity, or any limitations of the brainstorming process. The absence of annotations and output schema makes the description feel incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with clear descriptions for 'topic' and 'context' including max lengths. The description does not add additional meaning beyond the schema, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool is for brainstorming with Perplexity using real-time web data, providing a specific verb and resource. However, it does not explicitly differentiate from sibling tools like 'ask' or 'search', which could have overlapping use cases.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes trigger phrases that imply when to use the tool, but it does not provide explicit guidance on when not to use it or suggest alternative tools for other scenarios. The usage context is implied but not formally stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Have Perplexity review code with web-grounded best practices and current documentation. Trigger: 'perplexity review', 'perplexity code review', or 'have perplexity review'.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | The code to review | |
| focus | No | Specific focus area (security, performance, etc.) | general |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears full responsibility. It mentions 'web-grounded best practices and current documentation', hinting at online research, but does not disclose limitations, side effects, or processing details. For a read-only analysis tool, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, consisting of one sentence plus trigger phrases with no waste. It is front-loaded with the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema and only two parameters, the description still lacks mention of output format or behavior when 'focus' is specified. It does not fully equip an agent to handle the tool without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with both parameters described in the schema. The tool's description adds no additional meaning beyond the schema, so baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to review code with web-grounded best practices and current documentation. It specifies the resource (Perplexity) and action (review code), and distinguishes from sibling tools like 'explain' or 'ask' by focusing on code review with web grounding.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides trigger phrases for invocation, suggesting when to use the tool, but does not explicitly state when not to use it or compare it to alternatives like 'explain' or 'search'. The guidance is implied but lacks depth.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Conduct deep, exhaustive research on a topic using Perplexity's sonar-deep-research model. Best for comprehensive analysis, literature reviews, and multi-source synthesis. May take longer. Trigger: 'perplexity research', 'perplexity deep research', or 'deep research with perplexity'.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The research question or topic to investigate deeply |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry behavioral disclosure. It notes 'May take longer,' which is useful, but does not mention other traits like read-only nature, response format, or potential limits. Adequate but minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is two sentences plus trigger phrase, immediately stating the core function. Every sentence adds value with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one parameter, no output schema, and no annotations, the description covers purpose, model, use cases, triggers, and latency. Could mention result format but not essential. Reasonably complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear parameter description for 'query.' Description adds no extra parameter details; it repeats the tool's purpose. With full schema coverage, baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool conducts 'deep, exhaustive research' using a specific model, and specifies use cases like 'comprehensive analysis, literature reviews, and multi-source synthesis.' It distinguishes from sibling tools by emphasizing depth and exhaustive nature.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description provides explicit usage context: 'Best for comprehensive analysis...' and trigger phrases, but does not explicitly state when not to use or mention alternatives. Slightly incomplete but sufficient for basic guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Clear explanations of concepts, code, or technical topics using Perplexity with web-grounded accuracy. Trigger: 'perplexity explain'.
| Name | Required | Description | Default |
|---|---|---|---|
| concept | Yes | What to explain (code, concept, or technical topic) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions using Perplexity with web-grounded accuracy, which adds context, but does not disclose behavioral details like auth needs, rate limits, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: two sentences, front-loaded with purpose and method, zero fluff. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema or annotations, the description is adequate but lacking detail on return format, depth of explanations, or examples. It covers the core but misses some completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema coverage, the schema already describes the 'concept' parameter. The description's mention of 'concepts, code, or technical topics' aligns with the schema but adds no new meaning beyond it, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: providing clear explanations of concepts, code, or technical topics using Perplexity with web-grounded accuracy. The verb 'explain' and resource types are specified, distinguishing it from siblings like 'ask' or 'deep_research', though not explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes a trigger phrase ('perplexity explain') which implies when to use it, but lacks explicit guidance on when not to use it or specific alternatives among siblings like 'search' or 'ask'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get raw ranked search results from Perplexity's search index. Returns structured results with titles, URLs, and snippets. Best for getting a list of sources without AI synthesis. Trigger: 'perplexity raw search', 'perplexity search results'.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The search query | |
| max_results | No | Maximum number of results to return (default: 10) | |
| domain_filter | No | Filter results to these domains only (max 5) | |
| recency | No | Filter results by recency: "hour", "day", "week", "month" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that results are raw and not AI-synthesized, and returns structured output. However, it lacks details on rate limits, authentication needs, or side effects, which is adequate for a search tool but not exceptional.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, comprising two sentences plus trigger phrases. Every sentence adds value, no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description covers the output structure (titles, URLs, snippets) and usage context. It omits pagination details but is otherwise complete for a search tool with 4 parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add additional meaning beyond the input schema; it only mentions the output format (titles, URLs, snippets), not parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves raw ranked search results from Perplexity's search index and distinguishes it from siblings by specifying 'without AI synthesis'. The verb 'Get' and resource 'raw ranked search results' are specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes 'Best for getting a list of sources without AI synthesis' and trigger phrases, which provide clear context for when to use this tool. It does not explicitly list when not to use it or name alternatives, but the guidance is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the web using Perplexity with real-time results, domain filtering, recency filtering, and detailed citations. Best-in-class AI search. Trigger: 'perplexity search', 'perplexity web search', or 'search with perplexity'.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The search query or question to research on the web | |
| allowed_domains | No | Only include search results from these domains (max 5) | |
| excluded_domains | No | Exclude these domains from search (max 5). Cannot be combined with allowed_domains. | |
| recency | No | Filter results by recency: "hour", "day", "week", "month" | |
| detail | No | Search context size: "low" (faster), "medium" (balanced), "high" (most thorough) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It mentions features but does not disclose behavioral traits like read-only nature, rate limits, or authentication needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, mostly efficient. The second sentence ('Best-in-class AI search') is slightly promotional but not harmful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers main features but lacks information on return format, limitations, or behavioral context. Adequate but with gaps given the number of parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description mentions features like domain filtering and recency filtering but does not add meaningful details beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches the web using Perplexity with specific features like real-time results and filtering. However, it does not differentiate from sibling tools 'search' and 'search_with_reasoning'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit trigger phrases for when to use this tool, but lacks guidance on when not to use it or alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the web with step-by-step reasoning using Perplexity's sonar-reasoning-pro model. Best for complex questions requiring multi-step analysis with live web data. Trigger: 'perplexity reason', 'perplexity think', or 'reason with perplexity'.
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | The question or problem requiring deep reasoning with web search | |
| allowed_domains | No | Only include search results from these domains (max 5) | |
| recency | No | Filter results by recency: "hour", "day", "week", "month" |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only mentions the model and step-by-step reasoning. It lacks disclosure about output format, citations, rate limits, or any potential side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences, front-loaded with purpose, each earning its place. No unnecessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description should explain what the tool returns (e.g., reasoning steps, citations). It does not, leaving a significant gap for an agent to understand expected output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are well-documented. The description adds model context to the prompt parameter but provides minimal extra meaning beyond the schema's own descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches the web with step-by-step reasoning using a specific model, and distinguishes from siblings by specifying it's for complex multi-step analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description indicates it's best for complex questions requiring multi-step analysis, implying when to use it. However, it does not explicitly state when not to use it or mention alternative tools for simpler queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Upload a document for Perplexity to analyze. Supports text files (txt, md, py, js, ts, csv, json, etc.) and images (png, jpg, gif, webp). Trigger: 'perplexity upload file', 'upload to perplexity'.
| Name | Required | Description | Default |
|---|---|---|---|
| file_path | Yes | Absolute path to the file to upload | |
| query | No | Optional question to ask about the file immediately after upload | |
| model | No | Model identifier (optional, defaults to sonar-pro) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and description only says 'upload' without disclosing behavioral traits such as whether it overwrites existing files, permissions required, or whether it is synchronous. Lacks key transparency for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is brief with two sentences plus a trigger line. No superfluous words; however, it could be more structured (e.g., separate sections).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, and description does not explain what the tool returns after upload (e.g., file ID, analysis result) or if it is asynchronous. Lacks information on post-upload behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all 3 parameters with descriptions. The description adds value by listing supported file types, which is not in the schema. Baseline 3 increased to 4 due to this extra context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Upload a document for Perplexity to analyze' and lists supported file types. Tool name and description align, and it is distinct from sibling tools (e.g., ask, search) which are text-based.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides trigger phrases like 'perplexity upload file' but does not explicitly state when to use this tool versus alternatives or mention when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Most tools have distinct purposes, but ask and search_web both provide Q&A with citations, and search_with_reasoning adds step-by-step reasoning, causing minor potential confusion. However, descriptions and triggers help clarify differences.
All tool names follow a consistent lowercase underscore-separated verb or verb_noun pattern (e.g., ask, brainstorm, search_web), making them predictable and easy to reason about.
With 9 tools, the server covers a broad range of interactions with Perplexity without being overwhelming. Each tool serves a clear purpose, and the count feels well-scoped for an AI assistant.
The set covers core functionalities: Q&A, brainstorming, code review, deep research, explanations, raw search, web search, reasoning search, and file upload. Minor gaps like saving results or comparing sources are not essential for the domain.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Real-time web search, reasoning, and research through Perplexity's API
Enable AI assistants to perform web searches using Perplexity's Sonar Pro.
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Connect your team's living knowledge base — docs, data, issues, CRM — to Claude and ChatGPT.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/wynandw87/claude-code-perplexity-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
