Discover Awesome MCP Servers

MCP Vision Relay

Wraps local multimodal CLIs (Google Gemini CLI and Qwen CLI) as MCP tools, enabling text-only AI assistants like Claude to analyze images through relay calls. Supports local paths, URLs, and base64 image inputs with configurable models and output formats.

Modular Search MCP

A VS Code extension that integrates DuckDuckGo web search capabilities with GitHub Copilot Chat through a Model Context Protocol server.

Vibetest Use

Launches multiple Browser-Use agents to automatically test websites for UI bugs, broken links, accessibility issues, and other technical problems on both live and localhost sites.

MCP SSH Agent

A server that enables secure interaction with remote SSH hosts through standardized MCP interface, providing functions like listing hosts, executing commands, and transferring files using native SSH tools.

DeSo MCP Server

A comprehensive Model Context Protocol server that transforms Cursor's AI assistant into a DeSo blockchain development expert, providing complete API coverage, debugging solutions, and code generation for DeSo applications.

Alayman Article Retrieval

Retrieves blog articles from an external API with metadata including titles, authors, URLs, and engagement metrics like share counts and view counts.

Desmos MCP Server

Enables mathematical formula visualization and analysis through interactive plotting, formula validation, and symbolic computation. Supports both Desmos API integration and local matplotlib rendering for creating 2D mathematical graphs.

mcp-micromanage

開発ワークフローのためのマイクロマネジメントツール：コーディングエージェントが、詳細なコミットレベルの粒度で、連続的な開発タスクを計画、追跡、可視化するのを支援します。インタラクティブな可視化、自動化されたステータス追跡、構造化されたワークフロー管理機能を備えています。

lafe-blog MCP Server

Enables creating and managing text notes with a simple note-taking system. Provides tools to create notes, access them via URIs, and generate summaries of all stored notes.

GUARDRAIL: Security Framework for Large Language Model Applications

GUARDRAIL - MCP Security - Gateway for Unified Access, Resource Delegation, and Risk-Attenuating Information Limits

NCP MCP Server

Enables conversational management of Naver Cloud Platform infrastructure through Claude Desktop, allowing users to create, query, and manage cloud resources like servers, VPCs, load balancers, and databases using natural language.

Remote MCP Server (Authless)

Deploys a Model Context Protocol server on Cloudflare Workers without authentication requirements, allowing you to create and expose custom AI tools to clients like Claude Desktop or Cloudflare AI Playground.

MCP Server MySQL

Enables LLMs to interact with MySQL databases through standardized protocol, supporting database management, table operations, data queries, and modifications with configurable permission controls.

MCP Server Directory

AIアプリケーション、開発、統合のためのモデルコンテキストプロトコルサーバーを見つけて共有しましょう。

GoHighLevel MCP Server

Connects Claude Desktop directly to GoHighLevel CRM accounts with 269+ tools across contacts, messaging, appointments, opportunities, marketing automation, and e-commerce operations through the Model Context Protocol.

Robot Navigation MCP Server

Enables robot navigation control and monitoring through natural language. Provides tools for robot positioning, navigation to coordinates, device status monitoring, task management, and emergency controls.

Google Maps MCP Server for Cloud Run

Provides Google Maps functionality through Cloud Run, enabling route calculation, traffic analysis, route comparison, and trip cost estimation with rate-limited public access.

MCP Chat with Claude

Okay, here's a TypeScript example for a web app (acting as the host) connecting to a Node.js MCP (Mesh Control Protocol) server. This example focuses on the core connection and message exchange. It assumes you have a basic understanding of TypeScript, Node.js, and web development. **Important Considerations:** * **MCP Library:** This example uses a hypothetical `mcp-client` library. You'll likely need to adapt it to a real MCP library or implement your own MCP client logic. MCP is a protocol, and you'll need to handle the specific message formats and handshake procedures defined by your MCP implementation. * **Security:** In a production environment, you *must* consider security. Use secure WebSockets (WSS), authentication, and authorization to protect your MCP communication. * **Error Handling:** This example includes basic error handling, but you'll need to expand it to handle various network errors, MCP protocol errors, and unexpected situations. * **Framework:** This example uses vanilla TypeScript and assumes you'll integrate it into your web framework of choice (React, Angular, Vue, etc.). **1. Node.js MCP Server (Simplified Example - `mcp-server.ts`)** ```typescript // mcp-server.ts import WebSocket, { WebSocketServer } from 'ws'; const wss = new WebSocketServer({ port: 8080 }); wss.on('connection', ws => { console.log('Client connected'); ws.on('message', message => { console.log(`Received: ${message}`); // Process the MCP message (replace with your MCP logic) try { const parsedMessage = JSON.parse(message.toString()); // Assuming JSON format // Example: Echo back the message with a "response" field const response = { type: 'response', data: parsedMessage, status: 'ok' }; ws.send(JSON.stringify(response)); } catch (error) { console.error('Error processing message:', error); ws.send(JSON.stringify({ type: 'error', message: 'Invalid message format' })); } }); ws.on('close', () => { console.log('Client disconnected'); }); ws.on('error', error => { console.error('WebSocket error:', error); }); // Example: Send a welcome message ws.send(JSON.stringify({ type: 'welcome', message: 'Welcome to the MCP server!' })); }); console.log('MCP Server started on port 8080'); ``` **To run the server:** 1. Make sure you have Node.js and npm installed. 2. Create a directory for your project. 3. Save the code above as `mcp-server.ts`. 4. Open a terminal in the project directory. 5. Run: ```bash npm install ws # Install the WebSocket library npm install -D typescript @types/node @types/ws # Install TypeScript and type definitions npx tsc mcp-server.ts # Compile the TypeScript code node mcp-server.js # Run the compiled JavaScript ``` **2. Web App (TypeScript Client - `index.ts`)** ```typescript // index.ts (or your main TypeScript file) class MCPClient { private socket: WebSocket | null = null; private serverUrl: string; constructor(serverUrl: string) { this.serverUrl = serverUrl; } connect(): Promise<void> { return new Promise((resolve, reject) => { this.socket = new WebSocket(this.serverUrl); this.socket.addEventListener('open', () => { console.log('Connected to MCP server'); resolve(); }); this.socket.addEventListener('message', (event) => { console.log('Received:', event.data); this.handleMessage(event.data); }); this.socket.addEventListener('close', () => { console.log('Disconnected from MCP server'); this.socket = null; }); this.socket.addEventListener('error', (error) => { console.error('WebSocket error:', error); reject(error); }); }); } sendMessage(message: any): void { if (this.socket && this.socket.readyState === WebSocket.OPEN) { this.socket.send(JSON.stringify(message)); } else { console.warn('Not connected to MCP server. Message not sent.'); } } disconnect(): void { if (this.socket) { this.socket.close(); this.socket = null; } } private handleMessage(data: any): void { try { const message = JSON.parse(data); // Handle different message types based on your MCP protocol switch (message.type) { case 'welcome': console.log('Server says:', message.message); break; case 'response': console.log('Response from server:', message.data); break; case 'error': console.error('Error from server:', message.message); break; default: console.log('Unknown message type:', message); } } catch (error) { console.error('Error parsing message:', error); } } } // Example Usage (in your web app's main script) document.addEventListener('DOMContentLoaded', () => { const mcpClient = new MCPClient('ws://localhost:8080'); // Replace with your server URL const connectButton = document.getElementById('connectButton'); const sendButton = document.getElementById('sendButton'); const disconnectButton = document.getElementById('disconnectButton'); const messageInput = document.getElementById('messageInput') as HTMLInputElement; connectButton?.addEventListener('click', () => { mcpClient.connect().catch(error => { console.error('Failed to connect:', error); }); }); sendButton?.addEventListener('click', () => { const messageText = messageInput.value; try { const message = JSON.parse(messageText); mcpClient.sendMessage(message); } catch (error) { console.error("Invalid JSON message", error); } }); disconnectButton?.addEventListener('click', () => { mcpClient.disconnect(); }); }); ``` **3. HTML (Example - `index.html`)** ```html <!DOCTYPE html> <html> <head> <title>MCP Client</title> </head> <body> <h1>MCP Client</h1> <button id="connectButton">Connect</button> <button id="disconnectButton">Disconnect</button> <input type="text" id="messageInput" placeholder="Enter JSON message"> <button id="sendButton">Send Message</button> <script src="index.js"></script> <!-- Make sure this points to your compiled JavaScript file --> </body> </html> ``` **To run the web app:** 1. Save the code above as `index.ts` and `index.html` in the same directory. 2. Compile the TypeScript: ```bash npm install -D typescript @types/node # If you haven't already npx tsc index.ts ``` 3. This will create an `index.js` file. 4. Open `index.html` in your web browser. You'll need a simple web server to serve the HTML file correctly (e.g., using `npx serve .` or a similar tool). **Explanation:** * **`MCPClient` Class:** * Handles the WebSocket connection to the MCP server. * `connect()`: Establishes the WebSocket connection and sets up event listeners for `open`, `message`, `close`, and `error`. * `sendMessage()`: Sends a message to the server (after converting it to JSON). * `disconnect()`: Closes the WebSocket connection. * `handleMessage()`: Parses incoming messages and dispatches them based on their `type`. This is where you'll implement your MCP protocol logic. * **HTML:** * Provides buttons to connect, disconnect, and send messages. * An input field for entering JSON messages. * **Event Listeners:** * The `DOMContentLoaded` event ensures that the JavaScript code runs after the HTML is fully loaded. * Event listeners are attached to the buttons to call the `MCPClient` methods. **Key Improvements and Considerations:** * **MCP Protocol Implementation:** The `handleMessage()` function is the most important part to customize. You'll need to implement the specific message formats and logic defined by your MCP protocol. This might involve: * Defining TypeScript interfaces for your MCP message types. * Handling different commands and data structures. * Implementing error handling for invalid messages. * **Error Handling:** Add more robust error handling to catch network errors, invalid messages, and other unexpected situations. Consider using `try...catch` blocks and logging errors to the console or a logging service. * **Reconnection Logic:** Implement automatic reconnection logic in case the connection to the MCP server is lost. Use a backoff strategy to avoid overwhelming the server with reconnection attempts. * **Buffering Messages:** If the connection is temporarily lost, you might want to buffer messages and send them when the connection is re-established. * **Authentication/Authorization:** Implement authentication and authorization to ensure that only authorized clients can connect to the MCP server. This might involve using tokens, certificates, or other security mechanisms. * **Web Framework Integration:** Adapt this example to your chosen web framework (React, Angular, Vue, etc.). Use the framework's component model and data binding features to manage the MCP connection and display data. * **Asynchronous Operations:** Use `async/await` to handle asynchronous operations more cleanly. * **Testing:** Write unit tests and integration tests to ensure that your MCP client is working correctly. This comprehensive example provides a solid foundation for building a web app that connects to a Node.js MCP server using TypeScript. Remember to adapt it to your specific MCP protocol and security requirements.

MoluAbi MCP Server

Enables complete AI agent lifecycle management through MoluAbi's platform, allowing users to create, manage, and interact with AI assistants. Provides comprehensive tools for agent operations with secure authentication, usage tracking, and payment integration.

Daemon-MCP

Daem0n-MCP provides AI agents with persistent, semantically indexed memory to track decisions, rules, and outcomes across sessions. It actively prevents repetitive mistakes by enforcing context checks and prioritizing information about past failures during recall. Best for Claude Code.

Daniel Rosehill's MCP Installer

Manages installation and configuration of MCP servers across multiple clients (Claude Code, Cursor, VS Code) from a personal GitHub registry, with support for API key management and bulk installations.

SouthAsia MCP Tool

Model Control Protocol (MCP) フレームワークに基づいてツールを構築するためのテンプレートです。カスタムツールを開発し、Cursor と統合するための構造化された方法を提供します。

Prycd Pricing MCP Server

Enables access to the Prycd Pricing API for retrieving estimated property values and performing health checks on the API service.

MCP Server Tester

Model Context Protocol (MCP) サーバー用の自動テストツール - 開発中

Gaia-Protocol

Gaia Protocol—a planetary DAO for global resource management using quantum-entangled ledgers and algorithmic governance.

Airtable MCP Server

Enables complete interaction with Airtable databases through 16 CRUD operations including batch processing, schema management, and record manipulation. Designed for AI applications and n8n workflows with HTTP streaming support.

WarpGBM MCP Service

Provides GPU-accelerated gradient boosting model training and inference through a cloud service. Enables AI agents to train models on NVIDIA A10G GPUs and get fast cached predictions with portable model artifacts.

Oracle MCP Server

Oracleデータベース操作のためのモデルコンテキストプロトコル（MCP）サーバー実装

MCP Server with Qdrant

Qdrant + mcp-qdrant-server (クドラント + mcp-qdrant-server)