Perplexity MCP Server

2 forks

6 stars

Free

What is perplexity-mcp-server

perplexity-mcp-server is a powerful tool developed by laodev1 designed to facilitate seamless interactions between Claude, an advanced AI system, and Perplexity AI's language models. Built using Node.js, this server implements Anthropic's Model Context Protocol (MCP), which is a universal standard that allows AI systems to securely interact with various data sources and tools. By acting as a secure bridge, perplexity-mcp-server enhances AI capabilities and interactions, making it easier for AI systems to access and utilize external data and tools.

How to Use perplexity-mcp-server

To get started with perplexity-mcp-server, follow these steps:

Installation: Begin by setting up the server in your local environment. You'll need to clone the repository and install the necessary dependencies using Node.js. Then, prepare your environment by creating a .env file that stores your Perplexity API key.
Configuration: Integrate the server with Claude Desktop by updating the claude_desktop_config.json file with the correct server path and environment variables. This ensures that Claude can communicate with perplexity-mcp-server effectively.
Development and Execution: For development purposes, you can start a server with automatic recompilation using a specific command. This setup allows you to efficiently develop and test new features or changes.
Tool Usage: The server provides two main tools:
- perplexity_chat: This tool is used for generating chat completions with full message history support. Configure parameters such as model type, conversation history, and temperature settings to tailor the AI interactions.
- perplexity_ask: Ideal for quick, single-query interactions, this tool allows you to send straightforward questions to Perplexity AI and receive instant responses.

Key Features of perplexity-mcp-server

Secure AI Interactions: By implementing the Model Context Protocol, perplexity-mcp-server ensures secure and efficient communication between AI models and external data sources.
Versatile Toolset: The server includes tools like perplexity_chat for detailed conversations and perplexity_ask for quick queries, each enhancing the AI's ability to process and respond to information.
Robust Error Handling: Comprehensive error management is built-in, including API error reporting, invalid tool request handling, and connection error management, ensuring a smooth user experience.
Flexible Configuration: The server is highly configurable, allowing for environment-based settings and easy integration with Claude Desktop through a JSON configuration file.
Developer-Friendly: With a TypeScript-based architecture, the server offers type safety and modular tool definitions, making it easy for developers to extend and customize.
Security and Privacy: Input validation, sanitized error messages, and API key management through environment variables ensure that user data and operations remain secure.

The perplexity-mcp-server is designed to empower AI systems by providing a robust framework for interaction with Perplexity AI's language models, all while maintaining a focus on security, ease of use, and extensibility.

Overview

The Perplexity MCP Server is a Node.js implementation of Anthropic's Model Context Protocol (MCP) that enables Claude to interact with Perplexity's language models. This server provides a secure bridge between Claude and Perplexity AI's capabilities, allowing for enhanced AI interactions through tool use.

Available Tools

The server currently implements two main tools:

1. perplexity_chat

Advanced chat completion tool with full message history support.

 "name": "perplexity_chat",
 "description": "Generate a chat completion using Perplexity AI",
 "parameters": {
 "model": "string (optional) - One of: llama-3.1-sonar-small-128k-online, llama-3.1-sonar-large-128k-online, llama-3.1-sonar-huge-128k-online",
 "messages": "array of {role, content} objects - The conversation history",
 "temperature": "number (optional) - Sampling temperature between 0-2"

2. perplexity_ask

Simplified single-query interface for quick questions.

 "name": "perplexity_ask",
 "description": "Send a simple query to Perplexity AI",
 "parameters": {
 "query": "string - The question or prompt to send",
 "model": "string (optional) - One of: llama-3.1-sonar-small-128k-online, llama-3.1-sonar-large-128k-online, llama-3.1-sonar-huge-128k-online"

Installation

Clone the repository:

git clone 
cd perplexity-mcp-server

Install dependencies:

npm install

Create .env file:

PERPLEXITY_API_KEY=your-api-key-here

Build the project:

npm run build

Claude Desktop Configuration

To add this server to Claude Desktop, update your claude_desktop_config.json:

 "mcpServers": {
 //more servers...
 "perplexity": {
 "command": "node",
 "args": ["path\\to\\perplexity-mcp-server\\dist\\index.js"],
 "env": {
 "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY"
 //more servers...

The configuration file is typically located at:

Windows: %APPDATA%/Claude/config/claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/config/claude_desktop_config.json
Linux: ~/.config/Claude/config/claude_desktop_config.json

Development

Start the development server with automatic recompilation:

npm run dev

The server uses TypeScript and implements the MCP protocol using the @modelcontextprotocol/sdk package.

Architecture

Core Components

PerplexityServer Class

Implements MCP server protocol
Handles tool registration and execution
Manages error handling and server lifecycle

Tools System

Modular tool definitions
Type-safe tool handlers
Structured input validation

Technical Details

Built with TypeScript for type safety
Uses @modelcontextprotocol/sdk for MCP implementation
Communicates via stdio transport
Environment-based configuration

Error Handling

The server implements comprehensive error handling:

API error reporting
Invalid tool requests handling
Connection error management
Process signal handling

Dependencies

@modelcontextprotocol/sdk: ^1.0.3
dotenv: ^16.4.7
isomorphic-fetch: ^3.0.0

Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Security

API keys are managed through environment variables
Input validation for all tool parameters
Error messages are sanitized before output
Process isolation through MCP protocol

License

This project is licensed under the ISC License.

Troubleshooting

Common issues and solutions:

Server Not Found

Verify the path in claude_desktop_config.json is correct
Ensure the server is built (npm run build)
Check if Node.js is in your PATH

Authentication Errors

Verify your Perplexity API key in .env
Check if the API key has the required permissions

Tool Execution Errors

Verify the tool parameters match the schema
Check network connectivity
Review server logs for detailed error messages

How to Use

To use the perplexity-mcp-server, follow these steps:

Visit https://github.com/laodev1/perplexity-mcp-serverhttps://github.com/laodev...
Follow the setup instructions to create an account (if required)
Connect the MCP server to your Claude Desktop application
Start using perplexity-mcp-server capabilities within your Claude conversations

Additional Information

Created

December 12, 2024

Company

laodev1

Related MCP Servers

Start building your own MCP Server

Interested in creating your own MCP Server? Check out the official documentation and resources.

Learn More