Discover Awesome MCP Servers

Local LLM MCP Server

Bridges local LLMs running in LM Studio with MCP clients like Claude Desktop to perform reasoning and analysis tasks while keeping sensitive data private. It features a suite of tools for local code review, privacy scanning, and content transformation using auto-discovered local models.

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.

aidemd-mcp/server

Structured .aide spec files that give AI agents progressive disclosure into your codebase architecture via MCP.

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.

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.

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.

Feishu MCP Server

Enables Claude to read and interact with Feishu (Lark) documents, spreadsheets, and multi-dimensional tables. It provides tools for extracting content and metadata from various Feishu resources through secure OAuth or tenant-level authentication.

TunnelHub MCP

Connects MCP clients to TunnelHub to monitor automations, inspect executions, and analyze logs or traces. It enables users to manage environments and troubleshoot integration failures through natural language commands.

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.

Expense Tracker MCP Server

Enables personal expense management with SQLite storage, allowing users to add, update, delete, list, and summarize expenses by category through natural language interactions.

MCP OpenDART

Enables AI assistants to access South Korea's financial disclosure system (OpenDART), allowing users to retrieve corporate financial reports, disclosure documents, shareholder information, and automatically extract and search financial statement notes through natural language queries.

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.

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.

Graphistry MCP

GPU-accelerated graph visualization and analytics server for Large Language Models that integrates with Model Control Protocol (MCP), enabling AI assistants to visualize and analyze complex network data.

TimeChimp MCP Server

Enables interaction with the TimeChimp API v2 to manage projects, time entries, expenses, and invoices through natural language. It supports full CRUD operations across all major TimeChimp resources, including advanced OData query filtering and pagination.

search-console-mcp

Model Context Protocol (MCP) server that provides AI agents with access to Google Search Console data.

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

```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.

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.

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.

Org-roam MCP Server

Enables interaction with org-roam knowledge bases, allowing search, retrieval, creation, and linking of notes while respecting org-roam's file structure and conventions.

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.

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

Ferramenta de teste automatizado para servidores Model Context Protocol (MCP) - TRABALHO EM ANDAMENTO

MCP Server

A local middleware Node.js application for Windows that enables seamless communication between LLM-based tools like Copilot Agents, providing access to local guide files and custom prompts through built-in tools.

kintone OAuth MCP Server on Cloudflare Workers

Enables secure interaction with kintone through OAuth authentication, supporting record operations, app configuration management, file operations, and access control without storing API keys locally.

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.

Git MCP

Enables comprehensive Git and GitHub operations through 30 DevOps tools including repository management, file operations, workflows, and advanced Git features. Provides complete Git functionality without external dependencies for seamless integration with Gitea and GitHub platforms.

Stock Analysis MCP Server

An MCP server that provides real-time stock data, technical indicators, and financial metrics using the date.590.net data source. It enables AI-powered intelligent analysis and batch reporting through integration with the Deepseek API.