Discover Awesome MCP Servers

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.

CovAiLent

An MCP server for chemistry-focused tools, enabling LLM agents to perform molecule parsing, format conversion, property lookup, and other chemistry operations with explainable responses.

QGISMCP

Server Protokol Konteks Model yang menghubungkan Claude AI ke QGIS, memungkinkan interaksi langsung dengan perangkat lunak GIS untuk pembuatan proyek, manipulasi layer, eksekusi kode, dan algoritma pemrosesan melalui perintah bahasa alami.

mcp-openfda

Enables querying openFDA drug and device data via natural language through the Pipeworx MCP gateway.

Netlify Express MCP Server

A basic serverless MCP implementation using Netlify Functions and Express. Demonstrates how to deploy and run Model Context Protocol servers in a serverless environment with proper routing configuration.

Hurl OpenAPI MCP Server

Enables AI models to load and inspect OpenAPI specifications, generate Hurl test scripts, and access API documentation for automated testing and API interaction through natural language.

emi_mcp_server

A sample MCP server that exposes tools, resources, and prompts for managing users and todos, supporting both stdio and Streamable HTTP transports.

mcp-scryfall

Provides access to Magic: The Gathering card database, enabling listing of sets and expansions.

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!

Fabits MCP Server

Enables investment in mutual funds through the Fabits MyWealth platform with natural conversation. Supports fund discovery, lumpsum/SIP investments, portfolio tracking, and secure authentication with OTP.

MCP API Requester

An MCP server that enables LLMs to make arbitrary HTTP requests (GET, POST, PUT, DELETE, etc.) with custom headers, bodies, and cookies, supporting JSON and error handling.

XHS MCP

Enables interaction with Xiaohongshu (Little Red Book) platform through automated browser operations. Supports authentication, content publishing, search, discovery, and commenting using Puppeteer-based automation.

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.

obsidian-mcp

Enables Claude to read your Obsidian vault and retrieve outstanding tasks from daily notes by parsing checkboxes.

GitMCP

Transforms any GitHub repository into a documentation hub for AI assistants, enabling up-to-date access to documentation and code to eliminate hallucinations.

Agent Data Bridge

An MCP server that provides data bridging from Spring Boot interfaces and a lightweight Python sandbox for script execution. It enables agents to fetch data as Markdown or Parquet files and perform automated data analysis within a controlled environment.

Knapcode.SampleMcpServer

A sample MCP server built with C# that demonstrates creating and packaging MCP servers, providing a random number generation tool.

KeeperGate

Enables AI agents to execute on-chain transactions through policy validation, KeeperHub orchestration, and tamper-evident evidence recording.

Recruitee MCP Server

Enables extraction and analysis of candidate profiles from Recruitee recruitment pipelines, optimized for LLM evaluation with clean, bias-free data.

loa-mcp-server

MCP server that searches Japanese addresses and returns their locations as polygons or points using the open 住所LOD dataset, enabling geocoding, reverse geocoding, batch GeoJSON export, and map visualization.

Tickory MCP Server

Scheduled scans across all Binance spot and perpetual pairs using CEL rules (RSI, volume, MAs, price action). Runs server-side 24/7, fires webhooks on match, with delivery proof and alert explainability.

MCP Server for Up-to-Date Library Documentation

Provides Large Language Models with real-time access to the latest documentation for Python libraries like Langchain, LlamaIndex, and OpenAI, enabling accurate and up-to-date code suggestions.

mcp-capstone

MCP server that provides disassembly and reverse engineering capabilities via the Capstone framework, supporting multiple architectures.

claude-usage-mcp

Reports your Claude subscription usage (5-hour and weekly limits) with a forecast and velocity recommendation, using Claude Code's existing OAuth session without requiring an API key.

space-weather-mcp

Enables space-aware daily briefings, stargazing condition reports, and astronomy picture exploration from within the IDE by connecting to NASA and weather APIs.

Aruba Fatture MCP

MCP server for interacting with Aruba Fatturazione Elettronica API, enabling users to manage electronic invoices with Claude, including sending invoices to SDI, searching, downloading, and retrieving invoice details and notifications.

rag-mcp

A RAG service based on FastMCP that enables document indexing and retrieval (keyword/vector search) through the MCP protocol.

AstrBot MCP

Provides operational control and automation tools for AstrBot developers, enabling plugin debugging, configuration management, message sending, log monitoring, and bot restart capabilities through AI agents.

mcp-osrs

MCP server for the Old School RuneScape Wiki, game data, Grand Exchange prices, and hiscores with polite client behavior.

DB Graph MCP Server

Connects to SQL databases to execute queries and return results as chart images (PNG) visible in MCP clients.