@perplexity-ai/mcp-server 0.2.0

package/dist/index.js

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Definition of the Perplexity Ask Tool.
+ * This tool accepts an array of messages and returns a chat completion response
+ * from the Perplexity API, with citations appended to the message if provided.
+ */
+const PERPLEXITY_ASK_TOOL = {
+    name: "perplexity_ask",
+    description: "Engages in a conversation using the Sonar API. " +
+        "Accepts an array of messages (each with a role and content) " +
+        "and returns a ask completion response from the Perplexity model.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            messages: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        role: {
+                            type: "string",
+                            description: "Role of the message (e.g., system, user, assistant)",
+                        },
+                        content: {
+                            type: "string",
+                            description: "The content of the message",
+                        },
+                    },
+                    required: ["role", "content"],
+                },
+                description: "Array of conversation messages",
+            },
+        },
+        required: ["messages"],
+    },
+};
+/**
+ * Definition of the Perplexity Research Tool.
+ * This tool performs deep research queries using the Perplexity API.
+ */
+const PERPLEXITY_RESEARCH_TOOL = {
+    name: "perplexity_research",
+    description: "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.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            messages: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        role: {
+                            type: "string",
+                            description: "Role of the message (e.g., system, user, assistant)",
+                        },
+                        content: {
+                            type: "string",
+                            description: "The content of the message",
+                        },
+                    },
+                    required: ["role", "content"],
+                },
+                description: "Array of conversation messages",
+            },
+        },
+        required: ["messages"],
+    },
+};
+/**
+ * Definition of the Perplexity Reason Tool.
+ * This tool performs reasoning queries using the Perplexity API.
+ */
+const PERPLEXITY_REASON_TOOL = {
+    name: "perplexity_reason",
+    description: "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.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            messages: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        role: {
+                            type: "string",
+                            description: "Role of the message (e.g., system, user, assistant)",
+                        },
+                        content: {
+                            type: "string",
+                            description: "The content of the message",
+                        },
+                    },
+                    required: ["role", "content"],
+                },
+                description: "Array of conversation messages",
+            },
+        },
+        required: ["messages"],
+    },
+};
+/**
+ * Definition of the Perplexity Search Tool.
+ * This tool performs web search using the Perplexity Search API.
+ */
+const PERPLEXITY_SEARCH_TOOL = {
+    name: "perplexity_search",
+    description: "Performs web search using the Perplexity Search API. " +
+        "Returns ranked search results with titles, URLs, snippets, and metadata.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query string",
+            },
+            max_results: {
+                type: "number",
+                description: "Maximum number of results to return (1-20, default: 10)",
+                minimum: 1,
+                maximum: 20,
+            },
+            max_tokens_per_page: {
+                type: "number",
+                description: "Maximum tokens to extract per webpage (default: 1024)",
+                minimum: 256,
+                maximum: 2048,
+            },
+            country: {
+                type: "string",
+                description: "ISO 3166-1 alpha-2 country code for regional results (e.g., 'US', 'GB')",
+            },
+        },
+        required: ["query"],
+    },
+};
+// Retrieve the Perplexity API key from environment variables
+const PERPLEXITY_API_KEY = process.env.PERPLEXITY_API_KEY;
+if (!PERPLEXITY_API_KEY) {
+    console.error("Error: PERPLEXITY_API_KEY environment variable is required");
+    process.exit(1);
+}
+/**
+ * Performs a chat completion by sending a request to the Perplexity API.
+ * Appends citations to the returned message content if they exist.
+ *
+ * @param {Array<{ role: string; content: string }>} messages - An array of message objects.
+ * @param {string} model - The model to use for the completion.
+ * @returns {Promise<string>} The chat completion result with appended citations.
+ * @throws Will throw an error if the API request fails.
+ */
+function performChatCompletion(messages_1) {
+    return __awaiter(this, arguments, void 0, function* (messages, model = "sonar-pro") {
+        // Construct the API endpoint URL and request body
+        const url = new URL("https://api.perplexity.ai/chat/completions");
+        const body = {
+            model: model, // Model identifier passed as parameter
+            messages: messages,
+            // Additional parameters can be added here if required (e.g., max_tokens, temperature, etc.)
+            // See the Sonar API documentation for more details: 
+            // https://docs.perplexity.ai/api-reference/chat-completions
+        };
+        let response;
+        try {
+            response = yield fetch(url.toString(), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${PERPLEXITY_API_KEY}`,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (error) {
+            throw new Error(`Network error while calling Perplexity API: ${error}`);
+        }
+        // Check for non-successful HTTP status
+        if (!response.ok) {
+            let errorText;
+            try {
+                errorText = yield response.text();
+            }
+            catch (parseError) {
+                errorText = "Unable to parse error response";
+            }
+            throw new Error(`Perplexity API error: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        // Attempt to parse the JSON response from the API
+        let data;
+        try {
+            data = yield response.json();
+        }
+        catch (jsonError) {
+            throw new Error(`Failed to parse JSON response from Perplexity API: ${jsonError}`);
+        }
+        // Directly retrieve the main message content from the response 
+        let messageContent = data.choices[0].message.content;
+        // If citations are provided, append them to the message content
+        if (data.citations && Array.isArray(data.citations) && data.citations.length > 0) {
+            messageContent += "\n\nCitations:\n";
+            data.citations.forEach((citation, index) => {
+                messageContent += `[${index + 1}] ${citation}\n`;
+            });
+        }
+        return messageContent;
+    });
+}
+/**
+ * Formats search results from the Perplexity Search API into a readable string.
+ *
+ * @param {any} data - The search response data from the API.
+ * @returns {string} Formatted search results.
+ */
+function formatSearchResults(data) {
+    if (!data.results || !Array.isArray(data.results)) {
+        return "No search results found.";
+    }
+    let formattedResults = `Found ${data.results.length} search results:\n\n`;
+    data.results.forEach((result, index) => {
+        formattedResults += `${index + 1}. **${result.title}**\n`;
+        formattedResults += `   URL: ${result.url}\n`;
+        if (result.snippet) {
+            formattedResults += `   ${result.snippet}\n`;
+        }
+        if (result.date) {
+            formattedResults += `   Date: ${result.date}\n`;
+        }
+        formattedResults += `\n`;
+    });
+    return formattedResults;
+}
+/**
+ * Performs a web search using the Perplexity Search API.
+ *
+ * @param {string} query - The search query string.
+ * @param {number} maxResults - Maximum number of results to return (1-20).
+ * @param {number} maxTokensPerPage - Maximum tokens to extract per webpage.
+ * @param {string} country - Optional ISO country code for regional results.
+ * @returns {Promise<string>} The formatted search results.
+ * @throws Will throw an error if the API request fails.
+ */
+function performSearch(query_1) {
+    return __awaiter(this, arguments, void 0, function* (query, maxResults = 10, maxTokensPerPage = 1024, country) {
+        const url = new URL("https://api.perplexity.ai/search");
+        const body = {
+            query: query,
+            max_results: maxResults,
+            max_tokens_per_page: maxTokensPerPage,
+        };
+        if (country) {
+            body.country = country;
+        }
+        let response;
+        try {
+            response = yield fetch(url.toString(), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${PERPLEXITY_API_KEY}`,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (error) {
+            throw new Error(`Network error while calling Perplexity Search API: ${error}`);
+        }
+        // Check for non-successful HTTP status
+        if (!response.ok) {
+            let errorText;
+            try {
+                errorText = yield response.text();
+            }
+            catch (parseError) {
+                errorText = "Unable to parse error response";
+            }
+            throw new Error(`Perplexity Search API error: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        let data;
+        try {
+            data = yield response.json();
+        }
+        catch (jsonError) {
+            throw new Error(`Failed to parse JSON response from Perplexity Search API: ${jsonError}`);
+        }
+        return formatSearchResults(data);
+    });
+}
+// Initialize the server with tool metadata and capabilities
+const server = new Server({
+    name: "example-servers/perplexity-ask",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+/**
+ * Registers a handler for listing available tools.
+ * When the client requests a list of tools, this handler returns all available Perplexity tools.
+ */
+server.setRequestHandler(ListToolsRequestSchema, () => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        tools: [PERPLEXITY_ASK_TOOL, PERPLEXITY_RESEARCH_TOOL, PERPLEXITY_REASON_TOOL, PERPLEXITY_SEARCH_TOOL],
+    });
+}));
+/**
+ * Registers a handler for calling a specific tool.
+ * Processes requests by validating input and invoking the appropriate tool.
+ *
+ * @param {object} request - The incoming tool call request.
+ * @returns {Promise<object>} The response containing the tool's result or an error.
+ */
+server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { name, arguments: args } = request.params;
+        if (!args) {
+            throw new Error("No arguments provided");
+        }
+        switch (name) {
+            case "perplexity_ask": {
+                if (!Array.isArray(args.messages)) {
+                    throw new Error("Invalid arguments for perplexity_ask: 'messages' must be an array");
+                }
+                // Invoke the chat completion function with the provided messages
+                const messages = args.messages;
+                const result = yield performChatCompletion(messages, "sonar-pro");
+                return {
+                    content: [{ type: "text", text: result }],
+                    isError: false,
+                };
+            }
+            case "perplexity_research": {
+                if (!Array.isArray(args.messages)) {
+                    throw new Error("Invalid arguments for perplexity_research: 'messages' must be an array");
+                }
+                // Invoke the chat completion function with the provided messages using the deep research model
+                const messages = args.messages;
+                const result = yield performChatCompletion(messages, "sonar-deep-research");
+                return {
+                    content: [{ type: "text", text: result }],
+                    isError: false,
+                };
+            }
+            case "perplexity_reason": {
+                if (!Array.isArray(args.messages)) {
+                    throw new Error("Invalid arguments for perplexity_reason: 'messages' must be an array");
+                }
+                // Invoke the chat completion function with the provided messages using the reasoning model
+                const messages = args.messages;
+                const result = yield performChatCompletion(messages, "sonar-reasoning-pro");
+                return {
+                    content: [{ type: "text", text: result }],
+                    isError: false,
+                };
+            }
+            case "perplexity_search": {
+                if (typeof args.query !== "string") {
+                    throw new Error("Invalid arguments for perplexity_search: 'query' must be a string");
+                }
+                const { query, max_results, max_tokens_per_page, country } = args;
+                const maxResults = typeof max_results === "number" ? max_results : undefined;
+                const maxTokensPerPage = typeof max_tokens_per_page === "number" ? max_tokens_per_page : undefined;
+                const countryCode = typeof country === "string" ? country : undefined;
+                const result = yield performSearch(query, maxResults, maxTokensPerPage, countryCode);
+                return {
+                    content: [{ type: "text", text: result }],
+                    isError: false,
+                };
+            }
+            default:
+                // Respond with an error if an unknown tool is requested
+                return {
+                    content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        // Return error details in the response
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+/**
+ * Initializes and runs the server using standard I/O for communication.
+ * Logs an error and exits if the server fails to start.
+ */
+function runServer() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const transport = new StdioServerTransport();
+            yield server.connect(transport);
+            console.error("Perplexity MCP Server running on stdio with Ask, Research, Reason, and Search tools");
+        }
+        catch (error) {
+            console.error("Fatal error running server:", error);
+            process.exit(1);
+        }
+    });
+}
+// Start the server and catch any startup errors
+runServer().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@perplexity-ai/mcp-server",
+  "version": "0.2.0",
+  "description": "Official MCP server for Perplexity API Platform",
+  "keywords": [
+    "ai",
+    "perplexity",
+    "mcp",
+    "modelcontextprotocol"
+  ],
+  "homepage": "https://docs.perplexity.ai/guides/mcp-server",
+  "bugs": {
+    "url": "https://github.com/perplexityai/modelcontextprotocol/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/perplexityai/modelcontextprotocol.git"
+  },
+  "license": "MIT",
+  "author": "Perplexity <>",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "perplexity-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "watch": "tsc --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.1",
+    "axios": "^1.6.2",
+    "dotenv": "^16.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "shx": "^0.3.4",
+    "typescript": "^5.6.2"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}