Discover Awesome MCP Servers

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.

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.

mcp-scryfall

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

MCP Chat with Claude

```typescript // src/index.ts (or similar entry point) import { io, Socket } from 'socket.io-client'; // MCP Server Address (replace with your actual server address) const MCP_SERVER_URL = 'http://localhost:3000'; // Example: http://your-mcp-server.com:3000 // Interface for data being sent/received (optional, but recommended for type safety) interface MCPData { message: string; timestamp: number; // Add other properties as needed based on your MCP server's data structure } // Function to connect to the MCP server function connectToMCP(): Socket { console.log(`Connecting to MCP server at: ${MCP_SERVER_URL}`); const socket = io(MCP_SERVER_URL, { transports: ['websocket'], // Optional: Force WebSocket transport // Add other options as needed (e.g., authentication headers) }); // Event listeners for socket events socket.on('connect', () => { console.log('Connected to MCP server!'); }); socket.on('disconnect', (reason) => { console.warn(`Disconnected from MCP server: ${reason}`); }); socket.on('connect_error', (error) => { console.error('Connection error:', error); }); socket.on('mcp_data', (data: MCPData) => { // Handle data received from the MCP server console.log('Received data from MCP:', data); displayData(data); // Example: Update the UI with the received data }); return socket; } // Function to send data to the MCP server function sendDataToMCP(socket: Socket, message: string): void { const data: MCPData = { message: message, timestamp: Date.now(), }; socket.emit('client_data', data); // 'client_data' is the event name the server listens for console.log('Sent data to MCP:', data); } // Example function to update the UI (replace with your actual UI update logic) function displayData(data: MCPData): void { const dataDisplay = document.getElementById('data-display'); if (dataDisplay) { dataDisplay.textContent = `Message: ${data.message}, Timestamp: ${new Date(data.timestamp).toLocaleTimeString()}`; } else { console.warn("Element with ID 'data-display' not found."); } } // Main function to initialize the web app function main(): void { const socket = connectToMCP(); // Example: Send data when a button is clicked const sendButton = document.getElementById('send-button'); const messageInput = document.getElementById('message-input') as HTMLInputElement; // Type assertion if (sendButton && messageInput) { sendButton.addEventListener('click', () => { const message = messageInput.value; if (message) { sendDataToMCP(socket, message); messageInput.value = ''; // Clear the input field } else { alert('Please enter a message.'); } }); } else { console.error("Button with ID 'send-button' or input with ID 'message-input' not found."); } // Optional: Close the connection when the page is unloaded window.addEventListener('beforeunload', () => { socket.disconnect(); }); } // Run the main function when the DOM is ready document.addEventListener('DOMContentLoaded', main); ``` **Explanation:** 1. **Dependencies:** This code requires the `socket.io-client` library. Install it using npm or yarn: ```bash npm install socket.io-client # or yarn add socket.io-client ``` 2. **`MCP_SERVER_URL`:** This constant holds the address of your Node.js MCP server. **Replace `http://localhost:3000` with the actual URL of your server.** This is crucial for the connection to work. 3. **`MCPData` Interface (Optional but Recommended):** This interface defines the structure of the data being exchanged between the client and the server. It's good practice to use interfaces for type safety in TypeScript. Adjust the properties to match the actual data format used by your MCP server. 4. **`connectToMCP()` Function:** - Creates a `socket` instance using `io(MCP_SERVER_URL, options)`. - `transports: ['websocket']`: This option forces the connection to use the WebSocket transport. This is generally the most reliable and efficient transport for real-time communication. You can remove this if you want Socket.IO to automatically negotiate the best transport. - **Event Listeners:** Sets up event listeners for important socket events: - `connect`: Called when the connection to the server is successfully established. - `disconnect`: Called when the connection is lost. The `reason` argument provides information about why the disconnection occurred. - `connect_error`: Called if there's an error during the connection attempt. - `mcp_data`: **This is the most important event listener.** It's called when the server sends data to the client using the `mcp_data` event. The `data` argument contains the data sent by the server. The code then calls `displayData()` to update the UI with the received data. - Returns the `socket` instance so you can use it to send data. 5. **`sendDataToMCP()` Function:** - Creates a `MCPData` object with the message and a timestamp. - `socket.emit('client_data', data)`: Sends the data to the server using the `emit()` method. The first argument (`'client_data'`) is the **event name** that the server is listening for. The second argument (`data`) is the data to send. **Make sure the event name matches what your Node.js MCP server is expecting.** 6. **`displayData()` Function:** - This is a placeholder function that shows how to update the UI with the received data. **Replace this with your actual UI update logic.** The example code finds an element with the ID `data-display` and updates its `textContent`. If the element is not found, it logs a warning to the console. 7. **`main()` Function:** - Calls `connectToMCP()` to establish the connection to the server. - Sets up an event listener for a button click. When the button is clicked, it gets the message from the input field, calls `sendDataToMCP()` to send the data to the server, and clears the input field. - **Error Handling:** Includes checks to ensure that the button and input elements exist before adding the event listener. If they don't exist, it logs an error to the console. - **`beforeunload` Event Listener (Optional):** This event listener is called when the user is about to leave the page (e.g., by closing the tab or navigating to another page). It calls `socket.disconnect()` to close the connection to the server. This is good practice to prevent resource leaks. 8. **`DOMContentLoaded` Event Listener:** - This event listener ensures that the `main()` function is called only after the DOM (Document Object Model) is fully loaded. This is important because the code needs to access elements in the DOM (e.g., the button and input field). **HTML (Example):** You'll need an HTML file to load the TypeScript code and provide the UI elements. Here's a basic example: ```html <!DOCTYPE html> <html> <head> <title>Web App - MCP Client</title> <script src="index.js"></script> <!-- Replace with your compiled JavaScript file --> </head> <body> <h1>MCP Client</h1> <label for="message-input">Message:</label> <input type="text" id="message-input" placeholder="Enter your message"> <button id="send-button">Send</button> <h2>Received Data:</h2> <div id="data-display"></div> <script> // You might need to adjust the path to your compiled JavaScript file // depending on your build setup. If you're using a bundler like Webpack // or Parcel, the script tag will likely be different. </script> </body> </html> ``` **Important Considerations:** * **Node.js MCP Server:** This code assumes you have a Node.js MCP server running that uses `socket.io`. You'll need to create that server separately. See the example in the previous response for a basic server implementation. * **Event Names:** The event names (`'mcp_data'` and `'client_data'`) must match the event names used in your Node.js MCP server. * **Data Format:** The `MCPData` interface and the data being sent/received must match the data format used by your MCP server. * **Error Handling:** The code includes basic error handling, but you should add more robust error handling to handle potential issues such as connection errors, data validation errors, and UI update errors. * **Security:** If you're transmitting sensitive data, make sure to use HTTPS to encrypt the connection between the client and the server. Also, consider implementing authentication and authorization to protect your server from unauthorized access. * **Build Process:** You'll need to compile the TypeScript code to JavaScript before you can run it in a browser. You can use the TypeScript compiler (`tsc`) or a bundler like Webpack or Parcel. The example HTML assumes that the compiled JavaScript file is named `index.js`. * **CORS (Cross-Origin Resource Sharing):** If your web app and MCP server are running on different domains or ports, you'll need to configure CORS on your MCP server to allow requests from your web app's origin. The Node.js MCP server example in the previous response shows how to do this. **Steps to Run:** 1. **Create a Node.js MCP Server:** Implement a Node.js server using `socket.io` (see the previous response for an example). 2. **Create the HTML file:** Create an HTML file (e.g., `index.html`) with the content shown above. 3. **Create the TypeScript file:** Create a TypeScript file (e.g., `src/index.ts`) with the code shown above. 4. **Install Dependencies:** Run `npm install socket.io-client` in your web app's directory. 5. **Compile the TypeScript:** Compile the TypeScript code to JavaScript using `tsc src/index.ts`. You might need to configure a `tsconfig.json` file for more complex projects. 6. **Serve the HTML file:** Serve the HTML file using a web server (e.g., `npx serve .`). 7. **Run the Node.js MCP Server:** Start your Node.js MCP server. 8. **Open the HTML file in your browser:** Open the HTML file in your browser (e.g., `http://localhost:5000`). Now, when you enter a message in the input field and click the "Send" button, the message should be sent to the Node.js MCP server, and the server should echo the message back to the client, which will then display the message in the "Received Data" section.

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.

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.

mcp-osrs

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

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.

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.

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.

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.

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.

Krutrim Cloud MCP Server

Enables AI assistants like Cursor, Claude, and Codex to interact with Krutrim Cloud, providing discovery and controlled operations for VPCs, compute, storage, networking, Kubernetes, KPods, and IAM, with safety controls such as confirmation and read-only mode.

Arachne MCP

Self-hosted web-intelligence server for Hermes Agent and other MCP clients, featuring hybrid HTTP+browser crawling, document parsing, search, structured extraction, and change detection.

LangGraph FastAPI MCP Server

Enables LLM-powered agents to securely communicate with and orchestrate downstream microservices via FastAPI endpoints exposed as MCP tools.

mysql-mcp

Enables AI clients to interact with MySQL databases through read-only queries, with optional write capabilities in a controlled, auto-rolled-back manner.

climate-risk-mcp-server

Provides AI agents with access to CO2 emissions data, climate projections, and risk assessments for heat, flooding, and drought, supporting ESG analysis and CSRD compliance.

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.