Provides AI-powered search, research, and reasoning capabilities through three specialized tools: perplexity_ask for general conversational AI, perplexity_research for deep research with citations, and perplexity_reason for advanced reasoning

1. Click on "Install Server".

2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.

3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Perplexity Server research the latest advancements in quantum computing with citations"

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.

# Clone the template
git clone <your-repo-url>
cd mcp-perplexity


# Create a new project using the generator
./create-mcp-project your-project-name --description "Your project description" --author "Your Name"

# Or use the Node.js script directly
node setup-new-project.js your-project-name --description "Your project description" --author "Your Name"

# Clone the template
git clone <your-repo-url>
cd mcp-template

# Install dependencies
npm install

# Copy environment configuration
cp .env.example .env # Create this file with your settings

# Server Configuration
PORT=3000
LOG_LEVEL=info

# Perplexity API Configuration
PERPLEXITY_API_KEY=your_perplexity_api_key_here

# Start development server with hot reload
npm run dev

# Build for production
npm run build

# Start production server
npm start

# Run tests
npm test

# Lint and format code
npm run lint
npm run lint:fix

mcp-perplexity/
├── src/
│ ├── config/ # Configuration management
│ │ └── index.ts # Main config file
│ ├── services/ # Service layer
│ │ └── perplexity.ts # Perplexity API service
│ ├── utils/ # Utility functions
│ └── index.ts # Main server application
├── create-mcp-project # Bash script for project generation
├── setup-new-project.js # Node.js project generator
├── Dockerfile # Docker configuration
├── package.json # Dependencies and scripts
├── tsconfig.json # TypeScript configuration
└── README.md # This file

# Basic usage
./create-mcp-project weather-service

# With full options
./create-mcp-project task-manager \
 --description "AI-powered task management MCP server" \
 --author "Your Name" \
 --install-deps

# Custom target directory
./create-mcp-project file-processor --target-dir ./my-custom-server

# Skip git initialization
./create-mcp-project data-analyzer --no-git

{
 "name": "perplexity_ask",
 "arguments": {
 "messages": [
 {
 "role": "user",
 "content": "What are the latest developments in AI?"
 }
 ]
 }
}

{
 "name": "perplexity_research",
 "arguments": {
 "messages": [
 {
 "role": "user",
 "content": "Research the current state of quantum computing and its applications"
 }
 ]
 }
}

{
 "name": "perplexity_reason",
 "arguments": {
 "messages": [
 {
 "role": "user",
 "content": "Analyze the pros and cons of different renewable energy sources"
 }
 ]
 }
}

// Register your custom tool
server.tool(
 'your-tool-name',
 'Description of your tool',
 {
 // Define input schema using Zod
 parameter1: z.string().describe('Parameter description'),
 parameter2: z.number().optional().describe('Optional parameter'),
 },
 async ({ parameter1, parameter2 }) => {
 try {
 // Your tool implementation here
 const result = await yourCustomLogic(parameter1, parameter2);

 return {
 content: [
 {
 type: 'text',
 text: JSON.stringify(result, null, 2),
 } as TextContent,
 ],
 };
 } catch (error) {
 const errorMessage =
 error instanceof Error ? error.message : String(error);
 throw new Error(`Error in your-tool-name: ${errorMessage}`);
 }
 }
);

interface Config {
 logging: LoggingConfig;
 server: ServerConfig;
 // Add your custom config sections
 database: {
 url: string;
 timeout: number;
 };
 external: {
 apiKey: string;
 baseUrl: string;
 };
}

const config: Config = {
 // ... existing config
 database: {
 url: process.env.DATABASE_URL || 'sqlite://memory',
 timeout: parseInt(process.env.DB_TIMEOUT || '5000', 10),
 },
 external: {
 apiKey: process.env.EXTERNAL_API_KEY || '',
 baseUrl: process.env.EXTERNAL_BASE_URL || 'https://api.example.com',
 },
};

async run() {
 const app = express();
 app.use(express.json());

 // Add your custom middleware
 app.use(cors()); // CORS support
 app.use(helmet()); // Security headers
 app.use(morgan('combined')); // Request logging

 // ... rest of the setup
}

# Build Docker image
docker build -t mcp-perplexity-server .

# Run container
docker run -p 3000:3000 --env-file .env mcp-perplexity-server

version: '3.8'
services:
 mcp-server:
 build: .
 ports:
 - '3000:3000'
 environment:
 - NODE_ENV=production
 - PORT=3000
 - LOG_LEVEL=info
 restart: unless-stopped
 healthcheck:
 test: ['CMD', 'curl', '-f', 'http://localhost:3000/health']
 interval: 30s
 timeout: 10s
 retries: 3

docker-compose up -d

// Add security middleware
import helmet from 'helmet';
import cors from 'cors';
import rateLimit from 'express-rate-limit';

app.use(helmet());
app.use(
 cors({
 origin: process.env.ALLOWED_ORIGINS?.split(',') || false,
 })
);

const limiter = rateLimit({
 windowMs: 15 * 60 * 1000, // 15 minutes
 max: 100, // Limit each IP to 100 requests per windowMs
});
app.use('/mcp', limiter);

# Run all tests
npm test

# Run tests in watch mode
npm run test:watch

# Run tests with coverage
npm run test:coverage

import { describe, test, expect } from '@jest/globals';
// Your test imports

describe('YourComponent', () => {
 test('should handle valid input', async () => {
 // Test implementation
 });
});

NODE_ENV=production
PORT=3000
LOG_LEVEL=warn

# Add your production-specific variables
DATABASE_URL=postgresql://...
REDIS_URL=redis://...
API_KEYS=...