Discover Awesome MCP Servers

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.

obsidian-mcp

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

mcp-scryfall

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

MCP-workers

An MCP server that enables AI agents to search and analyze employee profiles, skills, tasks, and team structures stored in PostgreSQL, including advanced features like burnout detection and skill gap analysis.

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.

Data Science AI MCP

Data Science AI - MCP server providing AI-powered tools and automation by MEOK AI Labs

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.

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.

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.

magento-sql-mcp-server

Enables AI assistants to interact with a Magento 2 or Adobe Commerce MySQL database through 50+ read-only tools for orders, catalog, customers, CMS, configuration, indexers, and diagnostics, with support for local DDEV, Commerce Cloud, and remote/SSH connections.

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.

App Store Connect MCP Server

This MCP server provides access to Apple's App Store Connect API. It allows users to inspect apps, versions, builds, TestFlight groups, sales, users, and optionally edit metadata and manage testers.

MCP Code Mode

Enables AI agents to write and execute Python code in an isolated sandbox that can orchestrate multiple MCP tool calls, reducing context window bloat and improving efficiency for complex workflows.

KnowledgeMCP

An MCP server that enables AI assistants to perform semantic searches over local document collections using multi-context organization and automatic OCR. It supports various file formats including PDF, DOCX, and images, ensuring all data processing remains local and private.

AndroidBuilder MCP Server

Enables LLMs to interact with MIT App Inventor, AndroidBuilder, Kodular, or Niotron IDEs in real-time, controlling the Designer and Blocks workspace via Chrome DevTools Protocol.

boldsign

boldsign

DB Graph MCP Server

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

security-tools

Provides security tools (prompt injection detection, CVE lookup, version impact assessment) for MCP clients like Claude.

@cryptoapis-io/mcp-prepare-transactions

MCP server for Crypto APIs Prepare Transactions product that builds unsigned EVM transactions for native coin, fungible token (ERC-20), and NFT (ERC-721) transfers.