Discover Awesome MCP Servers

File Rank MCP Server

A tool that helps rank codebase files by importance (1-10 scale), track file dependencies, and provide summaries, all accessible through a simple JSON-based interface.

boldsign

boldsign

MCP Claude Spotify

An integration that allows Claude Desktop to interact with Spotify, enabling users to control playback, search music, manage playlists, and get recommendations through natural language commands.

DDG MCP1234

A basic MCP server template with example tools for echoing messages and retrieving server information. Built with FastMCP framework and supports both stdio and HTTP transports.

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 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. The MCP protocol itself is not standardized, so you'll need to know the specific format your Node.js server expects. * **Security:** In a production environment, you'll need to consider security aspects like authentication, authorization, and encryption (e.g., using TLS/SSL for WebSocket connections). * **Error Handling:** The example includes basic error handling, but you should expand it to handle various potential issues (e.g., connection errors, invalid messages). * **Framework:** This example uses plain TypeScript and assumes you'll integrate it into your web app framework of choice (React, Angular, Vue, etc.). **1. Web App (TypeScript - Host)** ```typescript // webapp.ts import { MCPClient } from './mcp-client'; // Hypothetical MCP client library const mcpServerAddress = 'ws://localhost:3000'; // Replace with your MCP server address let mcpClient: MCPClient | null = null; function connectToMCP() { mcpClient = new MCPClient(mcpServerAddress); mcpClient.on('open', () => { console.log('Connected to MCP server!'); // Send an initial message (e.g., registration) mcpClient?.send({ type: 'register', clientId: 'web-app-1' }); }); mcpClient.on('message', (message: any) => { console.log('Received message from MCP server:', message); // Process the message based on its type switch (message.type) { case 'statusUpdate': // Update UI based on status updateUI(message.data); break; case 'commandResponse': // Handle the response to a command handleCommandResponse(message.data); break; default: console.warn('Unknown message type:', message.type); } }); mcpClient.on('close', () => { console.log('Disconnected from MCP server.'); mcpClient = null; // Attempt to reconnect after a delay setTimeout(connectToMCP, 5000); // Reconnect every 5 seconds }); mcpClient.on('error', (error: any) => { console.error('MCP client error:', error); }); mcpClient.connect(); } function sendMessageToMCP(message: any) { if (mcpClient) { mcpClient.send(message); } else { console.warn('Not connected to MCP server. Message dropped:', message); } } function updateUI(data: any) { // Example: Update a DOM element with the received data const statusElement = document.getElementById('status'); if (statusElement) { statusElement.textContent = JSON.stringify(data); } } function handleCommandResponse(data: any) { // Example: Display a command response in an alert alert('Command Response: ' + JSON.stringify(data)); } // Call this function when your web app initializes connectToMCP(); // Example usage: Send a command to the MCP server when a button is clicked const sendCommandButton = document.getElementById('sendCommand'); if (sendCommandButton) { sendCommandButton.addEventListener('click', () => { sendMessageToMCP({ type: 'executeCommand', command: 'doSomething', params: { value: 42 } }); }); } ``` **2. Hypothetical `mcp-client.ts` (Adapt to your needs!)** ```typescript // mcp-client.ts import WebSocket from 'isomorphic-ws'; // Use a WebSocket library (e.g., isomorphic-ws for browser/Node compatibility) import { EventEmitter } from 'events'; export class MCPClient extends EventEmitter { private socket: WebSocket | null = null; private url: string; constructor(url: string) { super(); this.url = url; } connect() { this.socket = new WebSocket(this.url); this.socket.onopen = () => { this.emit('open'); }; this.socket.onmessage = (event: WebSocket.MessageEvent) => { try { const message = JSON.parse(event.data as string); this.emit('message', message); } catch (error) { console.error('Error parsing message:', error); this.emit('error', error); } }; this.socket.onclose = () => { this.emit('close'); }; this.socket.onerror = (error: any) => { this.emit('error', error); }; } send(message: any) { if (this.socket && this.socket.readyState === WebSocket.OPEN) { this.socket.send(JSON.stringify(message)); } else { console.warn('Socket not open. Message dropped:', message); } } close() { if (this.socket) { this.socket.close(); this.socket = null; } } } ``` **3. Node.js MCP Server (Example - for context)** ```javascript // server.js (Node.js) const WebSocket = require('ws'); const wss = new WebSocket.Server({ port: 3000 }); wss.on('connection', ws => { console.log('Client connected'); ws.on('message', message => { try { const parsedMessage = JSON.parse(message); console.log('Received message:', parsedMessage); // Process the message switch (parsedMessage.type) { case 'register': console.log(`Client registered with ID: ${parsedMessage.clientId}`); // Store the client ID or perform other registration tasks break; case 'executeCommand': console.log(`Executing command: ${parsedMessage.command} with params:`, parsedMessage.params); // Simulate command execution setTimeout(() => { ws.send(JSON.stringify({ type: 'commandResponse', data: { result: 'Command completed successfully!' } })); }, 1000); // Simulate a 1-second delay break; default: console.warn('Unknown message type:', parsedMessage.type); } } catch (error) { console.error('Error parsing 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); }); // Send a welcome message to the client ws.send(JSON.stringify({ type: 'welcome', message: 'Welcome to the MCP server!' })); }); console.log('MCP server started on port 3000'); ``` **Explanation:** 1. **`webapp.ts` (Web App):** * Imports the `MCPClient` (from the hypothetical `mcp-client.ts`). * `connectToMCP()`: Creates an `MCPClient` instance, sets up event listeners (`open`, `message`, `close`, `error`), and calls `connect()` to initiate the connection. It also attempts to reconnect if the connection is lost. * `sendMessageToMCP()`: Sends a message to the MCP server. It checks if the client is connected before sending. * `updateUI()` and `handleCommandResponse()`: Example functions to process messages received from the MCP server and update the web app's UI. * Example button click handler to send a command. 2. **`mcp-client.ts` (Hypothetical MCP Client):** * Uses the `isomorphic-ws` library for WebSocket compatibility (works in both browser and Node.js environments). You might need to install it: `npm install isomorphic-ws`. * `MCPClient` class: * `connect()`: Creates a WebSocket connection to the MCP server. Sets up event handlers for `open`, `message`, `close`, and `error`. * `send()`: Sends a message to the MCP server (after converting it to JSON). * `close()`: Closes the WebSocket connection. * Uses `EventEmitter` to emit events that the web app can listen to. 3. **`server.js` (Node.js MCP Server):** * A basic Node.js WebSocket server using the `ws` library. You'll need to install it: `npm install ws`. * Handles client connections, message reception, and message sending. * Includes example logic for handling `register` and `executeCommand` message types. * Sends a welcome message to new clients. **How to Use:** 1. **Install Dependencies:** ```bash # For the web app (if using a bundler like webpack or parcel) npm install isomorphic-ws # For the Node.js server npm install ws ``` 2. **Run the Node.js Server:** ```bash node server.js ``` 3. **Bundle and Run the Web App:** * Use a bundler like webpack, Parcel, or Rollup to bundle your TypeScript code into JavaScript that can run in the browser. Configure your bundler to handle TypeScript files. * Serve the bundled JavaScript and HTML from a web server (e.g., using `http-server` or a more sophisticated web server). 4. **Open the Web App in Your Browser:** * Navigate to the URL where your web app is being served. **Key Improvements and Considerations:** * **Error Handling:** Add more robust error handling to catch and handle potential issues. * **Message Serialization/Deserialization:** Ensure that messages are properly serialized (converted to a string format like JSON) before sending and deserialized (parsed from a string format) after receiving. * **Heartbeats/Keep-Alive:** Implement a heartbeat mechanism to detect broken connections and automatically reconnect. * **Authentication/Authorization:** Implement security measures to protect your MCP server and ensure that only authorized clients can connect and send commands. * **Message Queuing:** If your web app needs to send messages while disconnected, consider using a message queue to store messages and send them when the connection is re-established. * **MCP Protocol Definition:** Clearly define the MCP protocol (message formats, types, and expected behavior) to ensure compatibility between the web app and the Node.js server. Consider using a schema definition language like JSON Schema or Protocol Buffers. * **TypeScript Configuration:** Configure your `tsconfig.json` file appropriately for your project. This example provides a starting point. You'll need to adapt it to your specific requirements and the details of your MCP protocol. Remember to replace the hypothetical `mcp-client` with a real implementation or your own custom logic. Good luck!

Search Intent MCP

Layanan berbasis MCP yang menganalisis kata kunci pencarian pengguna untuk menentukan maksud mereka, memberikan klasifikasi, penalaran, referensi, dan saran pencarian untuk mendukung analisis SEO.

Sora MCP Server

Integrates with OpenAI's Sora 2 API to generate, remix, and manage AI-generated videos from text prompts. Supports video creation, status monitoring, downloading, and remixing through natural language commands.

FastMCP Document Analyzer

A comprehensive document analysis server that performs sentiment analysis, keyword extraction, readability scoring, and text statistics while providing document management capabilities including storage, search, and organization.

Basic MCP Server

A minimal Model Context Protocol server demonstrating basic MCP capabilities with example tools, resources, and prompts. Built as a starting template for developers to create their own MCP servers using the Smithery SDK.

Keboola Explorer MCP Server

This server facilitates interaction with Keboola's Storage API, enabling users to browse and manage project buckets, tables, and components efficiently through Claude Desktop.

Coconuts MCP Server

Enables management of Google Maps saved places through a SQLite database. Allows users to store, query, and organize their Google Maps places data locally.

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.

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.

MCP Server Tester

Alat pengujian otomatis untuk server Model Context Protocol (MCP) - MASIH DALAM PROSES PENGERJAAN

Thoughtspot

Thoughtspot

Email MCP Server

Ini adalah server MCP yang dirancang untuk menangani komunikasi email, mendukung berbagai protokol dan fitur email.

Godot Scene Analyzer

Analyzes Godot game projects to enforce ECS architecture patterns, automatically detecting when scene scripts contain game logic that should be in the ECS layer and validating separation between presentation and logic code.

Stochastic Thinking MCP Server

Provides advanced probabilistic decision-making algorithms including MDPs, MCTS, Multi-Armed Bandits, Bayesian Optimization, and Hidden Markov Models to help AI assistants explore alternative solutions and optimize long-term decisions.

Neil Mcp Server Include Mysql

include: mcp-mysql

ai-scheduler-mcp

Tentu, berikut terjemahan dari teks tersebut ke dalam Bahasa Indonesia: "Server MCP yang mendukung SSE untuk penjadwalan, menggunakan Google Tasks API dan Google Calendar API."

Anki MCP Server

A Model Context Protocol server that bridges Claude AI with Anki flashcard app, allowing users to create and manage flashcards using natural language commands.

MCP File Operations Server

Enables secure file management operations within a documents folder, including reading, writing, listing, deleting files and creating directories. Supports all file types with path validation to prevent access outside the designated documents directory.

MCP Echo Env

Echoes environment variables (PWD and WORKSPACE_SLUG) to verify that MCP clients properly propagate workspace context to server processes.

MCPLab

Berikut adalah contoh, kode, desain, dan tutorial tentang server-klien MCP (Model Context Protocol): Karena "MCP (Model Context Protocol)" bukanlah protokol yang umum dikenal atau standar, saya akan berasumsi bahwa ini adalah protokol khusus yang Anda maksud. Oleh karena itu, saya akan memberikan contoh umum tentang bagaimana membangun sistem server-klien dengan protokol khusus, dan bagaimana Anda dapat menyesuaikannya untuk kebutuhan "Model Context Protocol" Anda. **Konsep Dasar Server-Klien dengan Protokol Khusus** 1. **Definisi Protokol:** Tentukan format pesan yang akan dikirim dan diterima antara server dan klien. Ini termasuk: * **Header:** Informasi tentang pesan (misalnya, jenis pesan, panjang pesan). * **Payload:** Data aktual yang dikirim (misalnya, data model, perintah). 2. **Server:** * Mendengarkan koneksi dari klien. * Menerima pesan dari klien. * Memproses pesan. * Mengirim respons ke klien. 3. **Klien:** * Menghubungkan ke server. * Mengirim pesan ke server. * Menerima respons dari server. * Memproses respons. **Contoh Sederhana (Python)** Contoh ini menggunakan socket untuk komunikasi. **Server (server.py):** ```python import socket import threading HOST = '127.0.0.1' # Alamat IP server PORT = 65432 # Port yang digunakan server def handle_client(conn, addr): print(f"Terhubung oleh {addr}") while True: data = conn.recv(1024) # Menerima data hingga 1024 byte if not data: break # Proses data yang diterima (contoh: echo) decoded_data = data.decode('utf-8') print(f"Menerima: {decoded_data}") conn.sendall(data) # Mengirim data kembali ke klien conn.close() print(f"Koneksi dengan {addr} ditutup") with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server mendengarkan di {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() ``` **Klien (client.py):** ```python import socket HOST = '127.0.0.1' # Alamat IP server PORT = 65432 # Port yang digunakan server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) message = "Halo, Server!" s.sendall(message.encode('utf-8')) data = s.recv(1024) print(f"Menerima: {data.decode('utf-8')}") ``` **Penjelasan:** * **`socket`:** Modul untuk komunikasi jaringan. * **`HOST` dan `PORT`:** Alamat dan port server. * **Server:** * Membuat socket, mengikatnya ke alamat dan port, dan mulai mendengarkan koneksi. * Menerima koneksi baru dalam loop tak terbatas. * Membuat thread baru untuk menangani setiap koneksi klien. * Fungsi `handle_client` menerima data dari klien, mencetaknya, dan mengirimkannya kembali (echo). * **Klien:** * Membuat socket dan terhubung ke server. * Mengirim pesan ke server. * Menerima respons dari server. * Mencetak respons. **Menyesuaikan untuk "Model Context Protocol" (MCP)** Untuk menyesuaikan contoh ini untuk MCP, Anda perlu mendefinisikan format pesan MCP Anda. Berikut adalah beberapa pertimbangan: * **Jenis Pesan:** Tentukan jenis pesan yang akan dikirim (misalnya, `UPDATE_MODEL`, `REQUEST_DATA`, `ERROR`). * **Format Data:** Tentukan format data yang akan dikirim (misalnya, JSON, Protocol Buffers, format biner khusus). * **Header:** Sertakan header dalam pesan Anda yang berisi informasi seperti jenis pesan, panjang data, dan ID transaksi. **Contoh dengan Header dan Jenis Pesan (Konseptual):** Misalkan format pesan MCP Anda adalah: ``` [Jenis Pesan (1 byte)][Panjang Data (4 byte)][Data] ``` * `Jenis Pesan`: `0x01` untuk `UPDATE_MODEL`, `0x02` untuk `REQUEST_DATA`, dll. * `Panjang Data`: Panjang data dalam byte. * `Data`: Data aktual (misalnya, model yang diperbarui, permintaan data). **Contoh Kode (Server - Potongan):** ```python def handle_client(conn, addr): while True: # Menerima header (5 byte: 1 byte jenis pesan + 4 byte panjang data) header = conn.recv(5) if not header: break message_type = header[0] data_length = int.from_bytes(header[1:5], byteorder='big') # Menerima data data = conn.recv(data_length) # Proses pesan berdasarkan jenis pesan if message_type == 0x01: # UPDATE_MODEL # Proses data model print(f"Menerima UPDATE_MODEL: {data.decode('utf-8')}") # ... elif message_type == 0x02: # REQUEST_DATA # Proses permintaan data print(f"Menerima REQUEST_DATA") # ... # Kirim respons response_data = "Data yang diminta".encode('utf-8') response_length = len(response_data) response_header = bytes([0x03]) + response_length.to_bytes(4, byteorder='big') # 0x03 untuk RESPONSE_DATA conn.sendall(response_header + response_data) else: print(f"Jenis pesan tidak dikenal: {message_type}") conn.close() ``` **Contoh Kode (Klien - Potongan):** ```python # Mengirim UPDATE_MODEL message_type = 0x01 model_data = "Data model baru".encode('utf-8') data_length = len(model_data) header = bytes([message_type]) + data_length.to_bytes(4, byteorder='big') s.sendall(header + model_data) # Mengirim REQUEST_DATA message_type = 0x02 data_length = 0 # Tidak ada data untuk REQUEST_DATA header = bytes([message_type]) + data_length.to_bytes(4, byteorder='big') s.sendall(header) # Menerima respons header = s.recv(5) message_type = header[0] data_length = int.from_bytes(header[1:5], byteorder='big') data = s.recv(data_length) print(f"Menerima respons: {data.decode('utf-8')}") ``` **Desain Arsitektur** * **Lapisan Presentasi (Klien):** Menangani interaksi pengguna dan menampilkan data. * **Lapisan Aplikasi (Klien & Server):** Menangani logika bisnis dan implementasi protokol MCP. * **Lapisan Data (Server):** Mengelola penyimpanan dan pengambilan data model. * **Lapisan Jaringan (Klien & Server):** Menangani komunikasi jaringan menggunakan socket atau library jaringan lainnya. **Tutorial dan Sumber Daya Tambahan** * **Dokumentasi Socket Python:** [https://docs.python.org/3/library/socket.html](https://docs.python.org/3/library/socket.html) * **Tutorial Socket Programming:** Cari tutorial online tentang "Python socket programming" atau "network programming in Python". * **Protocol Buffers (Jika Anda memilih untuk menggunakannya):** [https://developers.google.com/protocol-buffers](https://developers.google.com/protocol-buffers) * **ZeroMQ (Alternatif untuk Socket):** [https://zeromq.org/](https://zeromq.org/) **Penting:** * **Keamanan:** Jika Anda mengirimkan data sensitif, pertimbangkan untuk menggunakan enkripsi (misalnya, TLS/SSL). * **Penanganan Kesalahan:** Implementasikan penanganan kesalahan yang kuat untuk menangani koneksi yang terputus, data yang rusak, dan kesalahan lainnya. * **Skalabilitas:** Jika Anda mengharapkan banyak klien, pertimbangkan untuk menggunakan arsitektur yang lebih skalabel (misalnya, menggunakan thread atau asynchronous I/O). * **Abstraksi:** Gunakan abstraksi yang tepat untuk memisahkan logika protokol MCP dari implementasi jaringan yang mendasarinya. Ini akan membuat kode Anda lebih mudah diuji dan dipelihara. Ingatlah bahwa ini hanyalah contoh dasar. Anda perlu menyesuaikannya agar sesuai dengan kebutuhan spesifik "Model Context Protocol" Anda. Semakin detail Anda dalam mendefinisikan protokol Anda, semakin mudah untuk mengimplementasikannya. Good luck!

Water Bar Email MCP Server

Enables sending branded wellness booking confirmation emails through Resend integration. Supports multiple email flows including AOI experience bookings with AI-suggested drink pairings and timeline layouts.

GUARDRAIL: Security Framework for Large Language Model Applications

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