Discover Awesome MCP Servers

MCP Claude Spotify

An integration that allows Claude Desktop to interact with Spotify, enabling users to control playback, search music, manage playlists, and get recommendations through natural language commands.

MCP Jieba Server

Provides high-performance Chinese text segmentation, POS tagging, and keyword extraction using Rust-based Jieba implementation. Supports both local STDIO and remote HTTP deployment modes.

MBTA Worcester Line MCP Server

Provides real-time train schedule information and live predictions for all 18 stations on the MBTA Worcester Line. It enables users to query upcoming departures and filter by direction or date through natural language.

Pega DX MCP Server

Transforms complex Pega Platform interactions into intuitive, conversational experiences by exposing Pega DX APIs through the standardized Model Context Protocol, enabling AI applications to interact with Pega through natural language.

MWAA MCP Server

Enables management of Amazon Managed Workflows for Apache Airflow (MWAA) environments and operations including DAG management, workflow execution monitoring, and access to Airflow connections and variables through a unified interface.

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.

PostgreSQL MCP Server

Provides AI assistants with safe, controlled access to PostgreSQL databases with read-only defaults, granular permissions, query safety features, and schema introspection capabilities.

Microsoft 365 Core MCP Server

Provides comprehensive management of Microsoft 365 services including Exchange, SharePoint, Teams, Azure AD, Intune device management, security & compliance frameworks, and universal access to 1000+ Microsoft Graph API endpoints with advanced features like batch operations, delta queries, and real-time webhooks.

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.

Search Intent MCP

Um serviço baseado em MCP (Micro Control Point) que analisa palavras-chave de pesquisa do usuário para determinar sua intenção, fornecendo classificações, raciocínio, referências e sugestões de pesquisa para apoiar a análise de SEO.

Nearest Tailwind Colors

Finds the closest Tailwind CSS palette colors to any given CSS color value. Supports multiple color spaces and customizable result filtering to help match designs to Tailwind's color system.

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.

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.

Local RAG

Privacy-first local document search using semantic search. Runs entirely on your machine with no cloud services, supporting PDF, DOCX, TXT, and Markdown files.

aws-pricing-mcp

aws-pricing-mcp

Base MCP Server

Enables AI applications to interact with the Base blockchain network, allowing wallet management, smart contract deployment, token transfers, NFT operations, DeFi interactions with Morpho vaults, and onramping funds via Coinbase.

Chrome MCP Server

Enables AI assistants to control and automate your Chrome browser directly, leveraging existing login states and configurations for tasks like content analysis, semantic search across tabs, screenshots, network monitoring, and interactive operations.

MCP PDF

Enables creative PDF generation with full design control including colors, shapes, emoji, and Unicode support. Supports everything from simple documents to artistic masterpieces using PDFKit's powerful API.

Discourse MCP

Enables AI agents to interact with Discourse forums through search, reading topics/posts, managing categories and tags, chat channels, and optionally creating content with safeguarded write operations.

Hurl OpenAPI MCP Server

Enables AI models to load and inspect OpenAPI specifications, generate Hurl test scripts, and access API documentation for automated testing and API interaction through natural language.

Logseq MCP Server

Connects AI assistants to Logseq knowledge graphs to read, write, and search pages, blocks, and journals via the Model Context Protocol. It features 17 tools for full graph management, including CRUD operations, batch block insertion, and full-text search.

Docker MCP Server

Enables AI assistants to manage Docker containers, images, networks, volumes, and Compose services through the Model Context Protocol. It supports system operations, command execution within containers, and integration with Docker Hub and GitHub Container Registry.

Comax Payment Link MCP

Allows integration with Comax ERP/payment systems to create payment links, manage orders, and retrieve customer information using the MCP protocol.

Qdrant Sync MCP Server

Enables bidirectional synchronization of vector database collections between local and remote Qdrant instances with tools for comparison, dry-run previews, and sync operations in both directions.

Arche Browser

An MCP server for comprehensive browser automation and full local PC control via shell commands and Python execution. It enables tasks like web navigation, file system management, and remote access through SSE with token authentication.

MCP Storyblok Server

A comprehensive server enabling natural language interaction with Storyblok CMS for managing stories, assets, components, releases, and other content through a modular architecture.

OpenAPI MCP Server

Um servidor que permite que Modelos de Linguagem Grandes (LLMs) descubram e interajam com APIs REST definidas por especificações OpenAPI através do Protocolo de Contexto do Modelo.