Discover Awesome MCP Servers

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 Unreal Server

Espelho de

Hound MCP

The dependency bloodhound for AI coding agents. Hound is a free, open-source MCP server that gives AI coding agents a nose for supply chain security. It scans packages for vulnerabilities, checks licenses, inspects dependency trees, and detects typosquatting — with zero API keys, zero config, and zero cost.

Basic MCP Server

A minimal Model Context Protocol server template demonstrating basic implementation of tools, resources, and prompts built with Smithery SDK.

NCBI Literature Search MCP Server

Provides seamless access to over 35 million PubMed scientific articles through natural language queries for research discovery and analysis. It enables tools for advanced searches, retrieving article details, and exploring related research within the life sciences and biomedical fields.

Fusion MCP

A Model Context Protocol server that connects LLMs with Autodesk Fusion, enabling CAD operations through natural language dialogue.

my-mcp

A note management MCP server that enables users to store, retrieve, and summarize personal notes via a custom URI scheme. It provides tools for adding content and prompts for generating brief or detailed summaries of stored information.

Shaka Packager MCP Server

Um servidor MCP que integra o Shaka Packager com aplicações Claude AI, permitindo que o Claude analise, transcodifique e empacote arquivos de vídeo para streaming em formatos como HLS e DASH.

Obsidian MCP Server

Allows AI models to interact with Obsidian notes through the Local REST API, enabling creation, reading, updating, searching of notes, and Git-based automatic backups.

EpicMe MCP

An application that demonstrates the future of user interactions through natural language with LLMs, enabling user registration, authentication, and data interaction exclusively via Model Context Protocol (MCP) tools.

vaultpilot-mcp

Self-custodial crypto portfolio and DeFi MCP server. Read balances and positions (Aave, Compound, Morpho, Uniswap V3, Lido, EigenLayer) across Ethereum, Arbitrum, Polygon, and Base, and prepare transactions for approval on a Ledger via WalletConnect.

MCP Beancount Tool

Enables interaction with local Beancount accounting ledgers through structured tools for viewing accounts, balances, and transactions, as well as inserting/removing transactions and answering natural-language questions via BeanQuery. Provides deterministic, validated, and auditable financial data operations with offline-first functionality.

MCP Xcode

Enables AI assistants to build, test, run, and manage Apple platform projects (iOS, macOS, tvOS, watchOS, visionOS) directly through Xcode. Provides comprehensive control over Xcode projects, Swift packages, simulators, and development workflows without leaving your editor.

us-legal-mcp

An MCP server that provides comprehensive US legislation.

Sentry MCP Server

Servidor de Protocolo de Contexto do Modelo (MCP) para o Sentry

RAGBrain MCP

Connects Claude Desktop to a RAGBrain knowledge base to enable semantic search, document retrieval, and namespace management. It allows users to browse collections, discover documents by topic, and access full text content through natural language.

Fal.ai OpenAI Image MCP Server

Enables text-to-image generation using the fal.ai GPT image-1 API. It provides a tool to generate images with customizable parameters like size, quality, and background settings via natural language prompts.

Vast.ai MCP Server

Enables comprehensive management of Vast.ai GPU cloud instances, including searching for GPU offers, creating and managing instances, executing remote commands via SSH, and monitoring background tasks for ML training workflows.

agent-browser-mcp

Exposes the local agent-browser CLI as MCP tools for browser automation and provides one-command integration with Codex. Enables navigation, interaction, page reading, tab management, and session control through natural language commands.

Google Drive MCP Server

Vamos criar um servidor MCP no Google Drive. Primeiro, vamos começar com a planilha.

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.

@excalimate/mcp-server

Turn Excalidraw diagrams into keyframe animations. AI-powered creation via MCP, E2E encrypted sharing, export to MP4/WebM/GIF/SVG.

MCP Zoom Recordings

Enables users to list and manage Zoom cloud recordings through the Model Context Protocol. It allows for searching recordings by date and retrieving specific meeting details, including download URLs for video, audio, and transcripts.

Signal MCP

Uma integração MCP para signal-cli que permite que agentes de IA enviem e recebam mensagens do Signal, com suporte para mensagens diretas, mensagens de grupo e tratamento assíncrono de mensagens.

Mcp-Omega-Brain

AI agent provenance, trust, and auditability layer. VERITAS multi-gate scoring, Cortex approval gates, S.E.A.L. hash-chain audit ledger, and semantic RAG with cryptographic provenance tracking for every decision an agent makes.

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.