The Perplexity MCP Server enables web searches using Perplexity AI with intelligent query handling and filtering options:
Web Search: Perform searches using the Perplexity API
Intelligent Model Selection: Automatically chooses the optimal model based on query intent (research, reasoning, general search)
Manual Model Control: Set or view information about available Perplexity AI models
Domain Filtering: Allow or block up to 3 specific domains in search results
Recency Filtering: Limit results to a specific time window (hour, day, week, month)
Filter Management: View active filters or clear all filters
Integration: Works seamlessly with Claude Desktop App for interactive search
Provides web search capabilities using Perplexity's API with automatic model selection based on query intent, supporting various Perplexity models like sonar, sonar-pro, sonar-reasoning, sonar-reasoning-pro, and sonar-deep-research
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 what are the latest developments in quantum computing?"
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.
An MCP server that provides Perplexity AI web search capabilities to Claude, with automatic model selection, stateful filters, and 10 purpose-built tools.
Node.js v20 or higher
A Perplexity API key — get one at https://www.perplexity.ai/settings/api
Claude Desktop (or any MCP-compatible client)
Related MCP server: Perplexity MCP Server
Clone this repository:
git clone https://github.com/RossH121/perplexity-mcp.git
cd perplexity-mcpInstall dependencies:
npm installBuild the server:
npm run buildAdd the server to Claude's config file at ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"perplexity-server": {
"command": "node",
"args": ["/absolute/path/to/perplexity-mcp/build/index.js"],
"env": {
"PERPLEXITY_API_KEY": "your-api-key-here",
"PERPLEXITY_MODEL": "sonar-pro"
}
}
}
}Replace /absolute/path/to with the actual path to where you cloned the repository.
The server automatically selects the best model based on your query, but you can also set a default via PERPLEXITY_MODEL:
Model | Best for |
| Comprehensive reports, exhaustive multi-source research |
| Complex logic, math, chain-of-thought analysis |
| General search, factual queries (default) |
| Quick, simple lookups |
For pricing and availability: https://docs.perplexity.ai/guides/pricing
search — AI-powered web searchThe main search tool. Automatically selects the right model based on your query. Returns a synthesized answer with cited sources.
Parameter | Options | Description |
| string | Your search query |
|
| How much web context to retrieve. |
|
| Search engine tier (nested in |
|
| Depth of reasoning for |
| boolean | Remove |
|
|
|
|
| Filter sources by publication date |
|
| Filter sources by last-updated date |
|
| Restrict sources to languages (ISO 639-1) |
| ISO 639-1 | Preferred response language |
| boolean | Answer from training data only (no web search) |
| boolean | Let a classifier decide whether to search |
| boolean | Append an Images section of result URLs |
| string[] | Restrict images by domain or format |
| boolean | Append follow-up question suggestions |
| — | Localize results via |
|
| Streaming event format for Pro Search |
| boolean | Append a request-cost footer when available |
| boolean | Enable streaming responses |
Examples:
"What's the latest on fusion energy?" → auto-selects sonar-pro
"Deep research analysis of CRISPR gene editing advances" → auto-selects sonar-deep-research
"Solve this logic puzzle step by step" → auto-selects sonar-reasoning-pro
raw_search — Raw ranked results (no LLM)Returns ranked web results directly without AI synthesis. Faster and cheaper — useful for URL discovery, building source lists, or fact-checking pipelines.
Parameter | Options | Description |
| string or string[] | Search query, or an array of queries run in one request |
| 1–20 | Number of results (default: 10) |
| number | Token budget overall / per result |
|
| Source category |
|
|
|
|
| Time window filter |
|
| Filter by publication date |
|
| Filter by last-updated date |
|
| Restrict to languages (ISO 639-1) |
| ISO 3166 code | Localize results (e.g. |
Note: prior versions sent these params in camelCase, which the Search API silently ignored — so
max_results,recency,search_modeand the date filters had no effect. This is fixed; they now take effect.
async_research — Long-running deep researchSubmit a sonar-deep-research job and poll it, instead of blocking on a synchronous call. Useful when research may exceed the 5-minute synchronous timeout. Jobs expire 7 days after creation.
Parameter | Options | Description |
|
| What to do |
| string | Research question (required for |
| string | Job id from a prior |
| Sonar model | Job model (default: |
|
| Reasoning depth |
|
| Source category |
| boolean | Strip |
"Submit async research: comprehensive comparison of solid-state battery startups"
→ returns a request_id
"Check async research status for <request_id>"agent — Agentic loop with built-in toolsThe Perplexity Agent API. Runs a multi-step agent that can call built-in tools and optionally a third-party model.
Parameter | Options | Description |
| string | The task or question |
| e.g. | Provider-qualified model |
| string[] | Fallback chain (takes precedence over |
|
| Named preset instead of a model |
| string | System prompt |
| 1–10 | Max agentic/tool steps |
| number | Max output tokens |
|
| Built-in tools the agent may use |
embeddings — Text embeddingsGenerate embeddings via the Perplexity Embeddings API. Returns a compact summary (model, vector count, token usage) by default.
Parameter | Options | Description |
| string or string[] | Text(s) to embed (max 512) |
|
| Embedding model (default: 0.6b) |
| number | Output dimensions (Matryoshka) |
| boolean | Include raw base64-encoded vectors |
domain_filter — Allowlist/blocklist domainsRestrict or exclude specific domains from search results. Filters persist across all subsequent searches until cleared.
action: "allow" — restrict results to this domain (allowlist mode)
action: "block" — exclude this domain from results (denylist mode)
Maximum 20 domains; cannot mix allow and block in the same filter set
"Allow results only from arxiv.org and nature.com"
"Block pinterest.com and reddit.com from search results"recency_filter — Time window filterLimit search results to a specific time period. Persists until changed.
Options: hour, day, week, month, year, none
"Set recency filter to week"
"Remove the recency filter"clear_filters — Reset all filtersClears all domain and recency filters in one call.
list_filters — View active filtersShows currently active domain allowlist/blocklist and recency setting.
model_info — View or override model selectionView available models and current selection, or manually force a specific model.
"Show model info"
"Set model to sonar-deep-research"The server scores your query against keyword lists to automatically pick the right model:
Research keywords (deep research, comprehensive, in-depth) → sonar-deep-research
Reasoning keywords (solve, logic, mathematical, figure out) → sonar-reasoning-pro
Simple keywords (quick, brief, basic) → sonar
Everything else → sonar-pro
Each response shows which model was used and why. If a query strongly matches a model (score ≥ 2), it will override a manually set model.
Time-sensitive research with domain filtering:
recency_filter → week
domain_filter → allow nature.com, allow arxiv.org
search → "Recent breakthroughs in quantum error correction"
Financial document research:
raw_search with search_mode: "sec" → find relevant filings
search with search_mode: "sec" → synthesized analysis
Academic literature review:
search with search_mode: "academic", search_context_size: "high" → comprehensive results from peer-reviewed sources
Deep research with reasoning control:
search with reasoning_effort: "high", strip_thinking: true → thorough analysis without <think> blocks in the output
npm run build # Compile TypeScript to build/
npm start # Run the built serverSource is in src/ — after editing, rebuild and restart Claude to load changes.
MIT
Remove all domain filters (both allowed and blocked). Use when switching search contexts or starting fresh. Does not affect recency filter.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It effectively discloses key behavioral traits: it's a destructive operation (removes filters), specifies what gets affected (domain filters) and what doesn't (recency filter), and implies a reset context. However, it doesn't mention permissions, side effects, or response format, leaving some gaps.
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 and well-structured in two sentences: the first states the purpose and scope, the second provides usage guidelines and exclusions. Every sentence adds clear value with zero waste, making it easy to parse and understand 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's simplicity (0 parameters, no output schema, no annotations), the description is nearly complete. It covers purpose, usage, and behavioral aspects effectively. However, it lacks details on permissions or confirmation prompts, which could be relevant for a destructive operation, leaving minor room for improvement.
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 tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the lack of inputs. The description adds no parameter-specific information, which is appropriate here. A baseline of 4 is applied as it compensates adequately for the zero-parameter case by focusing on usage 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?
The description clearly states the specific action ('Remove all domain filters') and specifies the scope ('both allowed and blocked'), distinguishing it from sibling tools like 'domain_filter' which likely manages individual filters. It goes beyond just restating the name by detailing what exactly gets cleared.
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 explicitly provides usage scenarios ('when switching search contexts or starting fresh') and clarifies exclusions ('Does not affect recency filter'), offering clear guidance on when to use this tool versus alternatives like 'recency_filter' or 'list_filters'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Configure domain filtering for search results. Use 'allow' to prioritize trusted sources (e.g., documentation sites, academic domains) or 'block' to exclude unreliable sources. Maximum 20 domains total. Filters persist across searches until cleared.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | Domain name without protocol. Examples: 'wikipedia.org', 'docs.python.org', 'arxiv.org'. For subdomains: 'api.example.com' | |
| action | Yes | 'allow' prioritizes this domain in results, 'block' excludes it completely |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: it specifies the maximum limit of 20 domains, persistence across searches until cleared, and the effect of actions ('allow' prioritizes, 'block' excludes). It lacks details on error handling or rate limits, but covers essential operational constraints.
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 appropriately sized and front-loaded, with every sentence adding value: the first states the purpose, the second explains usage with examples, and the third covers constraints and persistence. There is no wasted text, making it efficient and well-structured.
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 moderate complexity (2 parameters, no output schema, no annotations), the description is largely complete: it explains what the tool does, how to use it, and key behaviors. It could improve by mentioning the tool's relationship to siblings like 'clear_filters' or expected output, but it adequately covers the core functionality and constraints.
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 schema already documents both parameters fully. The description adds minimal value beyond the schema by reinforcing the purpose of 'allow' and 'block' actions, but does not provide additional syntax or format details. This meets the baseline for high schema coverage.
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 with specific verbs ('configure domain filtering') and resource ('search results'), distinguishing it from siblings like 'clear_filters' and 'list_filters' by focusing on configuration rather than management or listing. It specifies the exact function of setting up domain-based filters.
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 clear context on when to use this tool (e.g., to prioritize trusted sources or exclude unreliable ones) and mentions persistence across searches, but it does not explicitly state when not to use it or name alternatives like 'recency_filter' for other filtering needs. Usage is implied but not exhaustively defined against all siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Display current filter configuration including allowed domains, blocked domains, and active recency setting. Useful for debugging search behavior.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes what information is displayed (filter configuration details) and hints at a read-only operation ('Display'), but doesn't specify output format, potential errors, or any side effects. It adds some context about debugging utility, but lacks details on permissions or rate limits.
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 two concise sentences that are front-loaded with the core purpose and followed by a utility note. Every word adds value without repetition or fluff, making it highly efficient and well-structured.
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 low complexity (0 parameters, no annotations, no output schema), the description is reasonably complete for a read-only configuration display tool. It specifies what information is included and the debugging context, but lacks details on output format or error handling, which could be helpful for an agent.
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 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, earning a baseline score of 4 for not introducing confusion or redundancy.
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: 'Display current filter configuration' with specific components listed (allowed domains, blocked domains, recency setting). It uses a specific verb ('Display') and identifies the resource ('filter configuration'), but doesn't explicitly distinguish it from sibling tools like 'domain_filter' or 'recency_filter' that might modify these settings.
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 implied usage guidance by stating it's 'Useful for debugging search behavior,' suggesting it should be used when troubleshooting search issues. However, it doesn't explicitly state when to use this tool versus alternatives like 'search' or the various filter-modifying siblings, nor does it provide any exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
View available Perplexity models and their specializations, or manually override model selection. By default, models are auto-selected based on query intent (research, reasoning, general search).
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | Optional: Override auto-selection. 'sonar-deep-research' for comprehensive analysis, 'sonar-reasoning-pro' for complex logic, 'sonar' for quick lookups |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: viewing available models, their specializations, and the ability to override auto-selection. It explains the default behavior (auto-selection based on query intent) and the override capability, though it doesn't specify what happens when no parameter is provided (e.g., whether it returns a list or default info).
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 appropriately sized and front-loaded with the core purpose in the first clause. Both sentences earn their place: the first establishes what the tool does, and the second explains the default behavior and context. There's no wasted language or redundancy.
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 moderate complexity (1 optional parameter with full schema coverage, no output schema), the description is mostly complete. It covers purpose, usage, and parameter context well. However, it doesn't specify what the tool returns (e.g., a list of models with details or just confirmation), which would be helpful since there's no output schema.
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 adds value by explaining the context of the parameter: 'manually override model selection' and 'By default, models are auto-selected based on query intent'. This provides semantic meaning beyond the schema's enum descriptions, helping the agent understand when and why to use the parameter.
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 with specific verbs ('View available Perplexity models and their specializations, or manually override model selection') and distinguishes it from sibling tools like 'search' or 'list_filters' by focusing on model information and selection rather than filtering or searching operations.
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 explicitly provides usage guidance: 'By default, models are auto-selected based on query intent (research, reasoning, general search)' and indicates when to use the override parameter. This clearly distinguishes it from the default auto-selection behavior and helps the agent understand when manual selection is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Control the time window for search results. Essential for time-sensitive queries like news, updates, or recent developments. Filter persists until changed.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | Yes | Time window: 'hour' for breaking news, 'day' for daily updates, 'week' for recent developments, 'month' for broader recent context, 'none' to include all time periods |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals important behavioral traits: the filter persists until changed (stateful behavior), and it's for search results (context of application). However, it doesn't mention potential side effects, error conditions, or what happens when the filter is applied.
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 perfectly concise with three sentences that each earn their place: states the core function, provides usage context, and reveals important behavioral trait (persistence). No wasted words, front-loaded with the essential 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 the tool's moderate complexity (stateful filter setting), no annotations, and no output schema, the description does reasonably well. It explains what the tool does, when to use it, and a key behavioral aspect (persistence). However, it doesn't describe what the tool returns or potential error conditions, leaving some gaps in 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 description coverage and only 1 parameter, the schema already fully documents the parameter. The description adds some value by explaining why you'd use different time windows ('breaking news', 'daily updates', etc.), but doesn't provide additional syntax or format details beyond what's in the schema. For a single-parameter tool with excellent schema coverage, this is above baseline.
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 with specific verbs ('Control the time window for search results') and distinguishes it from siblings by focusing on time-based filtering. It explicitly mentions what it does (sets a time window filter) rather than just restating the name.
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 clear context for when to use this tool ('Essential for time-sensitive queries like news, updates, or recent developments'), but doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools. It implies usage scenarios but lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Web search via Perplexity AI with automatic model selection. Returns cited sources with summaries. The search uses only the query text (not conversation history). Best for: current events, factual research, technical documentation, comparative analysis.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Direct search query. Be specific with 2-3 context words, use expert terminology. Good: 'Compare 2025 React vs Vue performance for enterprise apps'. Bad: 'tell me about frameworks'. Tips: Use 'site:domain.com' for specific sites, include years for recent info, add 'analyze/compare/explain' for reasoning tasks. | |
| stream | No | Enable streaming responses (default: false) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key traits: the search mechanism ('via Perplexity AI with automatic model selection'), output format ('returns cited sources with summaries'), and input constraints ('uses only the query text'). However, it lacks details on rate limits, authentication needs, or error handling, which are common for such tools.
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 appropriately sized and front-loaded, with every sentence earning its place. It starts with the core functionality, adds key features, and ends with usage guidelines, all in a concise and structured manner without unnecessary details.
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 (a search tool with behavioral nuances) and no output schema, the description is mostly complete. It covers purpose, usage, and key behaviors, but could benefit from mentioning response format details or potential limitations. However, it compensates well with clear guidelines and transparency.
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 schema already documents both parameters thoroughly. The description does not add meaning beyond what the schema provides for parameters; it focuses on overall tool behavior instead. Baseline 3 is appropriate as the schema handles parameter documentation adequately.
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 with specific verbs ('web search via Perplexity AI') and resources ('returns cited sources with summaries'). It distinguishes itself from potential siblings by specifying 'automatic model selection' and 'uses only the query text (not conversation history)', making its scope explicit and differentiated.
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 explicit usage guidelines with 'Best for: current events, factual research, technical documentation, comparative analysis.' This clearly indicates when to use this tool versus alternatives, offering specific contexts and exclusions (e.g., not for conversational history-based queries).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0clear_filtersdomain_filterlist_filtersmodel_inforecency_filtersearchEach tool has a clearly distinct purpose with no overlap: clear_filters removes filters, domain_filter configures domains, list_filters displays current settings, model_info shows models, recency_filter controls time windows, and search performs web searches. The descriptions reinforce these unique roles, making misselection unlikely.
All tool names follow a consistent verb_noun pattern with snake_case (e.g., clear_filters, domain_filter, list_filters, model_info, recency_filter, search). The naming is predictable and readable throughout, with no deviations or mixed conventions.
With 6 tools, this server is well-scoped for its purpose of configuring and executing Perplexity AI searches. Each tool earns its place by covering essential aspects like filtering, model selection, and search execution, without being overly sparse or bloated.
The tool set provides complete coverage for the domain of Perplexity AI search configuration and execution. It includes setup (filters, model info), control (recency, domain filters), status (list_filters), and core functionality (search), with no obvious gaps that would cause agent failures.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
Docs: https://docs.keenable.ai/mcp-server Keenable is a free, remote MCP server that gives agents access to the web index. Search the web with ranked results and date/site filters, then fetch any indexed page as clean markdown. Works out of the box with no account or API key.
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/RossH121/perplexity-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
