La implementación oficial del servidor MCP para la plataforma de API de Perplexity, que proporciona a los asistentes de IA capacidades de búsqueda web en tiempo real, razonamiento e investigación a través de los modelos Sonar y la API de búsqueda.
Búsqueda web directa utilizando la API de búsqueda de Perplexity. Devuelve resultados de búsqueda clasificados con metadatos, ideal para encontrar información actual.
IA conversacional de propósito general con búsqueda web en tiempo real utilizando el modelo sonar-pro. Ideal para preguntas rápidas y búsquedas cotidianas.
Investigación profunda y exhaustiva utilizando el modelo sonar-deep-research. Ideal para análisis exhaustivos e informes detallados.
Razonamiento avanzado y resolución de problemas utilizando el modelo sonar-reasoning-pro. Ideal para tareas analíticas complejas.
[!TIP] Disponible como parámetro opcional para perplexity_reason y perplexity_research:
strip_thinkingEstablézcalo en
truepara eliminar las etiquetas<think>...</think>de la respuesta, ahorrando tokens de contexto. Predeterminado:false
Related MCP server: Perplexity Ask MCP Server
Obtenga su clave de API de Perplexity desde el Portal de API
Reemplace your_key_here en las configuraciones a continuación con su clave de API
(Opcional) Establecer tiempo de espera: PERPLEXITY_TIMEOUT_MS=600000 (predeterminado: 5 minutos)
(Opcional) Establecer URL base personalizada: PERPLEXITY_BASE_URL=https://your-custom-url.com (predeterminado: https://api.perplexity.ai)
(Opcional) Establecer nivel de registro: PERPLEXITY_LOG_LEVEL=DEBUG|INFO|WARN|ERROR (predeterminado: ERROR)
claude mcp add perplexity --env PERPLEXITY_API_KEY="your_key_here" -- npx -y @perplexity-ai/mcp-serverO instale a través del plugin:
export PERPLEXITY_API_KEY="your_key_here"
claude
# Then run: /plugin marketplace add perplexityai/modelcontextprotocol
# Then run: /plugin install perplexitycodex mcp add perplexity --env PERPLEXITY_API_KEY="your_key_here" -- npx -y @perplexity-ai/mcp-serverLa mayoría de los clientes se pueden configurar manualmente utilizando el mismo contenedor mcpServers en su configuración de cliente (como se muestra para Cursor). Si un cliente tiene un esquema diferente, consulte su documentación para conocer el formato exacto del contenedor.
Para la configuración manual, todos estos clientes utilizan la misma estructura mcpServers:
Cliente | Archivo de configuración |
Cursor |
|
Claude Desktop |
|
Kiro |
|
Windsurf |
|
VS Code |
|
{
"mcpServers": {
"perplexity": {
"command": "npx",
"args": ["-y", "@perplexity-ai/mcp-server"],
"env": {
"PERPLEXITY_API_KEY": "your_key_here"
}
}
}
}Si está ejecutando este servidor en el trabajo, especialmente detrás de un firewall o proxy de la empresa, es posible que deba indicarle al programa cómo enviar su tráfico de Internet a través del proxy de su red. Siga estos pasos:
1. Obtenga los detalles de su proxy
Solicite a su departamento de TI la dirección y el puerto de su proxy HTTPS.
Es posible que también necesite un nombre de usuario y una contraseña.
2. Establezca la variable de entorno del proxy
La forma más fácil y fiable para Perplexity MCP es utilizar PERPLEXITY_PROXY. Por ejemplo:
export PERPLEXITY_PROXY=https://your-proxy-host:8080Si su proxy necesita un nombre de usuario y una contraseña, utilice:
export PERPLEXITY_PROXY=https://username:password@your-proxy-host:80803. Alternativa: Variables de entorno estándar
Si prefiere utilizar las variables estándar, admitimos HTTPS_PROXY y HTTP_PROXY.
[!NOTE] El servidor comprueba la configuración del proxy en este orden:
PERPLEXITY_PROXY→HTTPS_PROXY→HTTP_PROXY. Si no se establece ninguno, se conecta directamente a Internet. Las URL deben incluirhttps://. Los puertos típicos son8080,3128y80.
Para implementaciones en la nube o compartidas, ejecute el servidor en modo HTTP.
Variable | Descripción | Predeterminado |
| Su clave de API de Perplexity | Requerido |
| URL base personalizada para solicitudes de API |
|
| Puerto del servidor HTTP |
|
| Interfaz de red a la que vincularse |
|
| Orígenes CORS (separados por comas) |
|
docker build -t perplexity-mcp-server .
docker run -p 8080:8080 -e PERPLEXITY_API_KEY=your_key_here perplexity-mcp-serverexport PERPLEXITY_API_KEY=your_key_here
npm install && npm run build && npm run start:httpEl servidor será accesible en http://localhost:8080/mcp
Problemas con la clave de API: Asegúrese de que PERPLEXITY_API_KEY esté configurado correctamente
Errores de conexión: Compruebe su conexión a Internet y la validez de la clave de API
Herramienta no encontrada: Asegúrese de que el paquete esté instalado y que la ruta del comando sea correcta
Errores de tiempo de espera: Para consultas de investigación muy largas, establezca PERPLEXITY_TIMEOUT_MS en un valor más alto
Problemas de proxy: Verifique su configuración de PERPLEXITY_PROXY o HTTPS_PROXY y asegúrese de que api.perplexity.ai no esté bloqueado por su firewall.
Errores de EOF / Inicialización: Algunos clientes MCP estrictos fallan porque npx escribe mensajes de instalación en stdout. Utilice npx -yq en lugar de npx -y para suprimir esta salida.
Para obtener asistencia, visite community.perplexity.ai o envíe un problema.
Engages in a conversation using the Sonar API. Accepts an array of messages (each with a role and content) and returns a chat completion response from the Perplexity model.
| Name | Required | Description | Default |
|---|---|---|---|
| messages | Yes | Array of conversation messages |
| Name | Required | Description |
|---|---|---|
| response | Yes | The response from Perplexity |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=true and openWorldHint=true, which the description doesn't contradict. The description adds that it 'engages in a conversation' and uses the 'Sonar API', providing some context beyond annotations, but lacks details on rate limits, authentication needs, or specific behavioral traits like response format or error handling.
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 and front-loaded, consisting of two sentences that directly state the tool's action and parameters without unnecessary details. Every sentence contributes essential information, 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 complexity (a conversational AI tool with one parameter), the description covers the basic purpose and input. With annotations providing safety hints and an output schema presumably detailing the response, the description is reasonably complete, though it could benefit from more behavioral context or sibling differentiation.
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%, with the single parameter 'messages' fully documented in the schema. The description mentions 'accepts an array of messages (each with a role and content)', which aligns with but doesn't add meaningful semantics beyond the schema, such as usage examples or constraints on message structure.
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 'engages in a conversation using the Sonar API' and 'returns a chat completion response from the Perplexity model', which specifies the verb (engages/returns) and resource (conversation/response). However, it doesn't explicitly differentiate from sibling tools like perplexity_reason or perplexity_search, which likely have similar conversational purposes but different scopes or behaviors.
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 no guidance on when to use this tool versus its siblings (perplexity_reason, perplexity_research, perplexity_search). It mentions the general action but offers no context about appropriate scenarios, exclusions, or alternatives, leaving the agent to guess based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Performs reasoning tasks using the Perplexity API. Accepts an array of messages (each with a role and content) and returns a well-reasoned response using the sonar-reasoning-pro model.
| Name | Required | Description | Default |
|---|---|---|---|
| messages | Yes | Array of conversation messages | |
| strip_thinking | No | If true, removes <think>...</think> tags and their content from the response to save context tokens. Default is false. |
| Name | Required | Description |
|---|---|---|
| response | Yes | The response from Perplexity |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=true and openWorldHint=true, which the description doesn't contradict. The description adds value by specifying the model (sonar-reasoning-pro) and the purpose (reasoning tasks), but it lacks details on behavioral traits like rate limits, error handling, or response format beyond what annotations provide. No contradiction is present.
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 and front-loaded, consisting of two sentences that efficiently convey the core functionality and model used. Every sentence adds value without redundancy, 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's complexity (reasoning tasks with an API), annotations cover safety (readOnlyHint) and scope (openWorldHint), and an output schema exists, the description is reasonably complete. It specifies the model and purpose, but could improve by differentiating from siblings or adding more context on use cases.
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 fully documents the parameters (messages array and strip_thinking boolean). The description adds no additional meaning beyond what's in the schema, such as examples or usage tips for parameters. Baseline 3 is appropriate as the schema handles the heavy lifting.
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 'performs reasoning tasks using the Perplexity API' and 'returns a well-reasoned response using the sonar-reasoning-pro model,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like perplexity_ask, perplexity_research, or perplexity_search, leaving some ambiguity about when to choose this tool over others for reasoning tasks.
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 no guidance on when to use this tool versus its siblings (perplexity_ask, perplexity_research, perplexity_search). It mentions the model (sonar-reasoning-pro) but doesn't specify use cases, exclusions, or alternatives, leaving the agent without clear context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Performs deep research using the Perplexity API. Accepts an array of messages (each with a role and content) and returns a comprehensive research response with citations.
| Name | Required | Description | Default |
|---|---|---|---|
| messages | Yes | Array of conversation messages | |
| strip_thinking | No | If true, removes <think>...</think> tags and their content from the response to save context tokens. Default is false. |
| Name | Required | Description |
|---|---|---|
| response | Yes | The response from Perplexity |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate read-only and open-world hints, which the description doesn't contradict. It adds value by specifying that it 'returns a comprehensive research response with citations', providing context on output behavior. However, it lacks details on rate limits, authentication needs, or response format beyond citations.
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 front-loaded with the core purpose, uses two concise sentences with zero waste, and efficiently conveys key information without redundancy. Every sentence earns its place by adding distinct value.
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 presence of annotations and an output schema, the description is reasonably complete for a research tool. It covers the basic action and output type, though it could benefit from more context on when to use versus siblings or behavioral traits like response structure.
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 fully documents parameters. The description adds minimal semantics by mentioning 'array of messages' and 'comprehensive research response', but doesn't elaborate on parameter usage beyond what's in the schema. Baseline 3 is appropriate given 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 action ('Performs deep research') and resource ('using the Perplexity API'), and distinguishes from siblings by specifying 'deep research' rather than generic queries. However, it doesn't explicitly contrast with 'perplexity_reason' or 'perplexity_search' to fully differentiate purpose.
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?
No guidance is provided on when to use this tool versus alternatives like 'perplexity_ask' or 'perplexity_search'. The description mentions 'deep research' but doesn't clarify scenarios or prerequisites for choosing this over sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Performs web search using the Perplexity Search API. Returns ranked search results with titles, URLs, snippets, and metadata. Perfect for finding up-to-date facts, news, or specific information.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query string | |
| max_results | No | Maximum number of results to return (1-20, default: 10) | |
| max_tokens_per_page | No | Maximum tokens to extract per webpage (default: 1024) | |
| country | No | ISO 3166-1 alpha-2 country code for regional results (e.g., 'US', 'GB') |
| Name | Required | Description |
|---|---|---|
| results | Yes | Formatted search results |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, indicating safe, external data access. The description adds valuable behavioral context beyond this by specifying the return format ('ranked search results with titles, URLs, snippets, and metadata') and the tool's strength for 'up-to-date' information, which helps the agent understand output structure and timeliness without contradicting annotations.
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 efficiently structured in two sentences: the first states the core functionality and output, and the second provides usage context. Every phrase adds value without redundancy, making it front-loaded and appropriately sized for a search tool.
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, rich annotations (readOnlyHint, openWorldHint), 100% schema coverage, and the presence of an output schema (implied by context signals), the description is complete enough. It covers purpose, output format, and ideal use cases, leaving technical details to structured fields.
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%, providing full documentation for all 4 parameters. The description doesn't add any parameter-specific details beyond what the schema already covers, such as explaining how 'country' affects results or typical 'query' formats. This meets the baseline of 3 when schema coverage is high.
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 ('Performs web search') and resource ('using the Perplexity Search API'), and distinguishes it from siblings by emphasizing web search functionality rather than conversational or analytical approaches. The phrase 'Perfect for finding up-to-date facts, news, or specific information' further clarifies its distinct use case.
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 ('Perfect for finding up-to-date facts, news, or specific information'), which implicitly suggests it's for factual retrieval rather than reasoning or research tasks handled by siblings. However, it doesn't explicitly name alternatives or state when not to use it, which prevents a perfect score.
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.
v0.6.1perplexity_askperplexity_reasonperplexity_researchperplexity_searchThe tools are mostly distinct with clear primary purposes: 'ask' for general conversation, 'reason' for reasoning tasks, 'research' for deep research with citations, and 'search' for web search results. However, 'ask' and 'reason' could be confused as both involve chat completions with similar inputs, potentially leading to misselection in ambiguous scenarios.
All tool names follow a consistent 'perplexity_' prefix with descriptive suffixes (ask, reason, research, search), using snake_case uniformly. This predictable pattern makes it easy for an agent to understand and navigate the tool set without confusion.
With 4 tools, the count is well-scoped for a server focused on interacting with the Perplexity API. Each tool serves a distinct function (conversation, reasoning, research, search), and there are no redundant or unnecessary tools, making the set efficient and appropriate for the domain.
The tool set covers core functionalities of the Perplexity API, including general chat, reasoning, research, and web search, which aligns well with the server's purpose. A minor gap is the lack of tools for managing conversations (e.g., clearing history or handling follow-ups), but agents can work around this using the provided message arrays.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Enable AI assistants to perform web searches using Perplexity's Sonar Pro.
Real-time web search, reasoning, and research through Perplexity's API
Give AI assistants access to real-time data. Search the web, compare flights, find hotels, and more.
Agent-native search engine with live web research optimized for AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/perplexityai/modelcontextprotocol'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
