Discover Awesome MCP Servers

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.

Salesforce MCP Server

Enables AI agents to perform secure Salesforce Lead management operations including CRUD actions, status updates, and idempotent syncing. It features TRD-compliant audit logging and OAuth 2.0 authentication to ensure reliable CRM interactions.

SolaGuard MCP Server

Provides comprehensive Biblical research tools including scripture lookup, interlinear Greek/Hebrew data, and Strong's concordance within a Protestant theological framework. It enables AI applications to perform full-text biblical searches, topical studies, and cross-referencing using authoritative theological data.

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.

mcp-swagger-schema

An MCP server that allows users to query and retrieve request and response JSON schemas directly from Swagger/OpenAPI specifications. It supports automatic reference resolution and path parameter matching to help AI models interact with API interfaces.

Modular Search MCP

A VS Code extension that integrates DuckDuckGo web search capabilities with GitHub Copilot Chat through a Model Context Protocol server.

Vibetest Use

Launches multiple Browser-Use agents to automatically test websites for UI bugs, broken links, accessibility issues, and other technical problems on both live and localhost sites.

MCP SSH Agent

A server that enables secure interaction with remote SSH hosts through standardized MCP interface, providing functions like listing hosts, executing commands, and transferring files using native SSH tools.

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.

mcp-micromanage

Uma Ferramenta de Microgerenciamento para Fluxos de Trabalho de Desenvolvimento: Ajuda o agente de codificação a planejar, rastrear e visualizar tarefas de desenvolvimento sequenciais com granularidade detalhada no nível de commit. Apresenta visualização interativa, rastreamento automatizado de status e gerenciamento estruturado de fluxo de trabalho.

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.

Panda Odoo MCP Server

Enables seamless interaction with Odoo instances through the Model Context Protocol, supporting CRUD operations, custom method execution, and real-time updates. It offers versatile communication via stdio and HTTP protocols, including support for streaming and Server-Sent Events.

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.

search-console-mcp

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

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.

AI Workspace MCP Server

Provides a secure workspace for AI-driven file management and Python script execution designed to run on Vercel. It enables tools for full file operations and code execution within a sandboxed environment.

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.

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.

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.

ssyubix-agentlink

Cross-device communication between AI agents over the public internet

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.

Daemon-MCP

Daem0n-MCP provides AI agents with persistent, semantically indexed memory to track decisions, rules, and outcomes across sessions. It actively prevents repetitive mistakes by enforcing context checks and prioritizing information about past failures during recall. Best for Claude Code.

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.

nworks

NAVER WORKS CLI + MCP server. 26 tools for messages, calendar, drive, mail, tasks, and boards. AI agents can manage NAVER WORKS directly.

hearthstone-oracle

Hearthstone MCP server with card search, deck analysis, and strategy coaching. Gives LLMs access to every Hearthstone card plus built-in strategy knowledge for deck building and gameplay advice.