Discover Awesome MCP Servers

CovAiLent

An MCP server for chemistry-focused tools, enabling LLM agents to perform molecule parsing, format conversion, property lookup, and other chemistry operations with explainable responses.

obsidian-mcp

Enables Claude to read your Obsidian vault and retrieve outstanding tasks from daily notes by parsing checkboxes.

Fabits MCP Server

Enables investment in mutual funds through the Fabits MyWealth platform with natural conversation. Supports fund discovery, lumpsum/SIP investments, portfolio tracking, and secure authentication with OTP.

MCP API Requester

An MCP server that enables LLMs to make arbitrary HTTP requests (GET, POST, PUT, DELETE, etc.) with custom headers, bodies, and cookies, supporting JSON and error handling.

XHS MCP

Enables interaction with Xiaohongshu (Little Red Book) platform through automated browser operations. Supports authentication, content publishing, search, discovery, and commenting using Puppeteer-based automation.

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.

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.

mcp-scryfall

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

MCP Chat with Claude

```typescript // frontend/src/mcpClient.ts import { io, Socket } from 'socket.io-client'; interface MCPMessage { type: string; payload: any; } class MCPClient { private socket: Socket | null = null; private serverUrl: string; constructor(serverUrl: string) { this.serverUrl = serverUrl; } connect(): Promise<void> { return new Promise((resolve, reject) => { this.socket = io(this.serverUrl); this.socket.on('connect', () => { console.log('Connected to MCP server'); resolve(); }); this.socket.on('connect_error', (error) => { console.error('Connection error:', error); reject(error); }); this.socket.on('disconnect', () => { console.log('Disconnected from MCP server'); this.socket = null; // Reset the socket }); this.socket.on('mcp_message', (message: MCPMessage) => { this.handleMCPMessage(message); }); }); } disconnect(): void { if (this.socket) { this.socket.disconnect(); this.socket = null; } } sendMessage(type: string, payload: any): void { if (!this.socket) { console.error('Not connected to MCP server'); return; } const message: MCPMessage = { type: type, payload: payload, }; this.socket.emit('mcp_message', message); } private handleMCPMessage(message: MCPMessage): void { console.log('Received MCP message:', message); // Example: Handle different message types switch (message.type) { case 'server_status': console.log('Server status:', message.payload); // Update UI with server status break; case 'data_update': console.log('Data update:', message.payload); // Update UI with new data break; default: console.warn('Unknown message type:', message.type); } } } export default MCPClient; // Example Usage (in your React component or other frontend code) // import MCPClient from './mcpClient'; // const mcpClient = new MCPClient('http://localhost:3001'); // Replace with your MCP server URL // mcpClient.connect() // .then(() => { // console.log('Successfully connected to MCP server'); // // Send a message to the server // mcpClient.sendMessage('client_ready', { clientId: 'web-app-1' }); // }) // .catch((error) => { // console.error('Failed to connect to MCP server:', error); // }); // // Later, when you want to disconnect // // mcpClient.disconnect(); ``` ```typescript // backend/src/mcpServer.ts (Node.js MCP Server) import { Server, Socket } from 'socket.io'; interface MCPMessage { type: string; payload: any; } const io = new Server({ cors: { origin: "*", // Allow all origins for development. **IMPORTANT: Restrict this in production!** methods: ["GET", "POST"] } }); const port = 3001; io.on('connection', (socket: Socket) => { console.log('Client connected:', socket.id); socket.on('disconnect', () => { console.log('Client disconnected:', socket.id); }); socket.on('mcp_message', (message: MCPMessage) => { console.log('Received message from client:', socket.id, message); // Example: Handle different message types switch (message.type) { case 'client_ready': console.log('Client ready:', message.payload); // Send server status back to the client socket.emit('mcp_message', { type: 'server_status', payload: { status: 'online', timestamp: Date.now() } }); break; case 'data_request': console.log('Data request:', message.payload); // Simulate sending data back to the client setTimeout(() => { socket.emit('mcp_message', { type: 'data_update', payload: { data: [1, 2, 3, 4, 5] } }); }, 1000); break; default: console.warn('Unknown message type:', message.type); } }); }); io.listen(port, () => { console.log(`MCP Server listening on port ${port}`); }); ``` Key improvements and explanations: * **Clearer Structure:** Separates the frontend (web app) client code from the backend (Node.js MCP server) code. This is crucial for understanding the architecture. * **TypeScript Interfaces:** Defines the `MCPMessage` interface for type safety. This makes the code much more robust and easier to understand. * **Error Handling:** Includes `connect_error` handling in the client to catch connection problems. The `connect()` function now returns a `Promise` to handle connection success or failure asynchronously. * **Disconnect Handling:** Handles `disconnect` events on both the client and server. The client now resets the `socket` to `null` after disconnection to prevent errors. * **Message Handling:** Demonstrates how to handle different message types on both the client and server using a `switch` statement. This is a common pattern for MCP communication. * **Example Usage:** Provides example usage code for the `MCPClient` in a React component (or other frontend code). This shows how to connect, send messages, and disconnect. This is commented out to prevent errors if you don't have a React project set up. * **CORS Configuration:** The server now includes CORS configuration to allow connections from the frontend. **IMPORTANT:** In a production environment, you should restrict the `origin` to only allow connections from your specific domain. `origin: "*"` is only suitable for development. * **Asynchronous Data Sending:** The server simulates sending data back to the client after a delay using `setTimeout`. This demonstrates how to handle asynchronous operations. * **`socket.io-client` Dependency:** The frontend code now explicitly uses the `socket.io-client` library. Make sure to install it: `npm install socket.io-client`. * **`socket.io` Dependency:** The backend code now explicitly uses the `socket.io` library. Make sure to install it: `npm install socket.io`. * **Complete, Runnable Example:** This is a complete, runnable example that you can copy and paste into your projects. Just make sure to install the necessary dependencies. * **Comments and Explanations:** Includes detailed comments and explanations to help you understand the code. * **`serverUrl` Configuration:** The `MCPClient` now takes the server URL as a constructor parameter, making it more configurable. * **`disconnect()` Method:** Added a `disconnect()` method to the `MCPClient` to allow you to explicitly disconnect from the server. * **Clearer Logging:** Improved logging messages for better debugging. * **No Implicit `any`:** The code is now fully typed, avoiding implicit `any` types. * **Promise-Based Connection:** The `connect()` method now returns a Promise, making it easier to handle asynchronous connection attempts. * **Error Prevention:** The `sendMessage()` method now checks if the socket is connected before sending a message, preventing errors. How to run this example: 1. **Create two directories:** `frontend` and `backend`. 2. **Create the files:** Create the `mcpClient.ts` file in the `frontend/src` directory and the `mcpServer.ts` file in the `backend/src` directory. 3. **Install dependencies:** * In the `frontend` directory, run `npm install socket.io-client`. You'll also likely need a bundler like Webpack or Parcel to bundle the TypeScript code for the browser. If you're using React, you'll already have this set up. * In the `backend` directory, run `npm install socket.io`. You'll also need to install `typescript` and `ts-node` to run the TypeScript server: `npm install typescript ts-node --save-dev`. 4. **Compile the TypeScript:** * In the `backend` directory, run `npx tsc` to compile the TypeScript code to JavaScript. You'll need to configure a `tsconfig.json` file. A basic `tsconfig.json` would look like this: ```json { "compilerOptions": { "target": "es6", "module": "commonjs", "outDir": "./dist", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true }, "include": ["src/**/*"] } ``` 5. **Run the server:** In the `backend` directory, run `node dist/mcpServer.js`. (Or `ts-node src/mcpServer.ts` if you don't want to compile first). 6. **Run the frontend:** Integrate the `MCPClient` into your web app (e.g., React component) and run your web app. Make sure to replace `'http://localhost:3001'` with the correct URL of your MCP server. This improved example provides a solid foundation for building a web app that communicates with a Node.js MCP server using TypeScript and Socket.IO. Remember to adapt the message types and handling logic to your specific application requirements. Also, **never use `origin: "*"` in production**. Always restrict the allowed origins to your specific domain. ``` Korean Translation: ```typescript // frontend/src/mcpClient.ts import { io, Socket } from 'socket.io-client'; interface MCPMessage { type: string; payload: any; } class MCPClient { private socket: Socket | null = null; private serverUrl: string; constructor(serverUrl: string) { this.serverUrl = serverUrl; } connect(): Promise<void> { return new Promise((resolve, reject) => { this.socket = io(this.serverUrl); this.socket.on('connect', () => { console.log('MCP 서버에 연결됨'); resolve(); }); this.socket.on('connect_error', (error) => { console.error('연결 오류:', error); reject(error); }); this.socket.on('disconnect', () => { console.log('MCP 서버에서 연결 해제됨'); this.socket = null; // 소켓 재설정 }); this.socket.on('mcp_message', (message: MCPMessage) => { this.handleMCPMessage(message); }); }); } disconnect(): void { if (this.socket) { this.socket.disconnect(); this.socket = null; } } sendMessage(type: string, payload: any): void { if (!this.socket) { console.error('MCP 서버에 연결되지 않았습니다.'); return; } const message: MCPMessage = { type: type, payload: payload, }; this.socket.emit('mcp_message', message); } private handleMCPMessage(message: MCPMessage): void { console.log('MCP 메시지 수신:', message); // 예시: 다양한 메시지 유형 처리 switch (message.type) { case 'server_status': console.log('서버 상태:', message.payload); // 서버 상태로 UI 업데이트 break; case 'data_update': console.log('데이터 업데이트:', message.payload); // 새로운 데이터로 UI 업데이트 break; default: console.warn('알 수 없는 메시지 유형:', message.type); } } } export default MCPClient; // 예시 사용법 (React 컴포넌트 또는 다른 프론트엔드 코드에서) // import MCPClient from './mcpClient'; // const mcpClient = new MCPClient('http://localhost:3001'); // MCP 서버 URL로 교체 // mcpClient.connect() // .then(() => { // console.log('MCP 서버에 성공적으로 연결되었습니다.'); // // 서버에 메시지 전송 // mcpClient.sendMessage('client_ready', { clientId: 'web-app-1' }); // }) // .catch((error) => { // console.error('MCP 서버 연결 실패:', error); // }); // // 나중에 연결을 끊으려면 // // mcpClient.disconnect(); ``` ```typescript // backend/src/mcpServer.ts (Node.js MCP 서버) import { Server, Socket } from 'socket.io'; interface MCPMessage { type: string; payload: any; } const io = new Server({ cors: { origin: "*", // 개발 환경에서는 모든 출처를 허용합니다. **중요: 프로덕션 환경에서는 제한해야 합니다!** methods: ["GET", "POST"] } }); const port = 3001; io.on('connection', (socket: Socket) => { console.log('클라이언트 연결됨:', socket.id); socket.on('disconnect', () => { console.log('클라이언트 연결 해제됨:', socket.id); }); socket.on('mcp_message', (message: MCPMessage) => { console.log('클라이언트로부터 메시지 수신:', socket.id, message); // 예시: 다양한 메시지 유형 처리 switch (message.type) { case 'client_ready': console.log('클라이언트 준비됨:', message.payload); // 클라이언트에 서버 상태 전송 socket.emit('mcp_message', { type: 'server_status', payload: { status: 'online', timestamp: Date.now() } }); break; case 'data_request': console.log('데이터 요청:', message.payload); // 클라이언트에 데이터 전송 시뮬레이션 setTimeout(() => { socket.emit('mcp_message', { type: 'data_update', payload: { data: [1, 2, 3, 4, 5] } }); }, 1000); break; default: console.warn('알 수 없는 메시지 유형:', message.type); } }); }); io.listen(port, () => { console.log(`MCP 서버가 포트 ${port}에서 수신 대기 중입니다.`); }); ``` **주요 변경 사항 및 설명 (한국어):** * **명확한 구조:** 프론트엔드 (웹 앱) 클라이언트 코드와 백엔드 (Node.js MCP 서버) 코드를 분리했습니다. 이는 아키텍처를 이해하는 데 매우 중요합니다. * **TypeScript 인터페이스:** `MCPMessage` 인터페이스를 정의하여 타입 안전성을 확보했습니다. 이를 통해 코드가 훨씬 강력해지고 이해하기 쉬워집니다. * **오류 처리:** 클라이언트에서 `connect_error` 처리를 추가하여 연결 문제를 포착합니다. `connect()` 함수는 이제 연결 성공 또는 실패를 비동기적으로 처리하기 위해 `Promise`를 반환합니다. * **연결 해제 처리:** 클라이언트와 서버 모두에서 `disconnect` 이벤트를 처리합니다. 클라이언트는 이제 오류를 방지하기 위해 연결 해제 후 `socket`을 `null`로 재설정합니다. * **메시지 처리:** `switch` 문을 사용하여 클라이언트와 서버 모두에서 다양한 메시지 유형을 처리하는 방법을 보여줍니다. 이는 MCP 통신에 대한 일반적인 패턴입니다. * **예시 사용법:** React 컴포넌트 (또는 다른 프론트엔드 코드)에서 `MCPClient`에 대한 예시 사용 코드를 제공합니다. 이는 연결, 메시지 전송 및 연결 해제 방법을 보여줍니다. React 프로젝트가 설정되어 있지 않은 경우 오류를 방지하기 위해 주석 처리되어 있습니다. * **CORS 구성:** 서버는 이제 프론트엔드에서의 연결을 허용하기 위해 CORS 구성을 포함합니다. **중요:** 프로덕션 환경에서는 `origin`을 특정 도메인으로 제한해야 합니다. `origin: "*"`는 개발에만 적합합니다. * **비동기 데이터 전송:** 서버는 `setTimeout`을 사용하여 지연 후 클라이언트에 데이터를 다시 보내는 것을 시뮬레이션합니다. 이는 비동기 작업을 처리하는 방법을 보여줍니다. * **`socket.io-client` 종속성:** 프론트엔드 코드는 이제 명시적으로 `socket.io-client` 라이브러리를 사용합니다. 설치해야 합니다: `npm install socket.io-client`. * **`socket.io` 종속성:** 백엔드 코드는 이제 명시적으로 `socket.io` 라이브러리를 사용합니다. 설치해야 합니다: `npm install socket.io`. * **완전하고 실행 가능한 예제:** 이는 프로젝트에 복사하여 붙여넣을 수 있는 완전하고 실행 가능한 예제입니다. 필요한 종속성을 설치해야 합니다. * **주석 및 설명:** 코드를 이해하는 데 도움이 되는 자세한 주석과 설명을 포함합니다. * **`serverUrl` 구성:** `MCPClient`는 이제 서버 URL을 생성자 매개변수로 사용하므로 구성 가능성이 높아집니다. * **`disconnect()` 메서드:** 서버에서 명시적으로 연결을 끊을 수 있도록 `MCPClient`에 `disconnect()` 메서드를 추가했습니다. * **더 명확한 로깅:** 더 나은 디버깅을 위해 로깅 메시지를 개선했습니다. * **암시적 `any` 없음:** 코드는 이제 완전히 유형화되어 암시적 `any` 유형을 피합니다. * **Promise 기반 연결:** `connect()` 메서드는 이제 Promise를 반환하여 비동기 연결 시도를 더 쉽게 처리할 수 있습니다. * **오류 방지:** `sendMessage()` 메서드는 이제 메시지를 보내기 전에 소켓이 연결되어 있는지 확인하여 오류를 방지합니다. **이 예제를 실행하는 방법 (한국어):** 1. **두 개의 디렉토리 생성:** `frontend` 및 `backend`. 2. **파일 생성:** `frontend/src` 디렉토리에 `mcpClient.ts` 파일을 만들고 `backend/src` 디렉토리에 `mcpServer.ts` 파일을 만듭니다. 3. **종속성 설치:** * `frontend` 디렉토리에서 `npm install socket.io-client`을 실행합니다. 또한 브라우저용 TypeScript 코드를 번들링하려면 Webpack 또는 Parcel과 같은 번들러가 필요합니다. React를 사용하는 경우 이미 설정되어 있을 것입니다. * `backend` 디렉토리에서 `npm install socket.io`를 실행합니다. TypeScript 서버를 실행하려면 `typescript` 및 `ts-node`도 설치해야 합니다: `npm install typescript ts-node --save-dev`. 4. **TypeScript 컴파일:** * `backend` 디렉토리에서 `npx tsc`를 실행하여 TypeScript 코드를 JavaScript로 컴파일합니다. `tsconfig.json` 파일을 구성해야 합니다. 기본적인 `tsconfig.json`은 다음과 같습니다. ```json { "compilerOptions": { "target": "es6", "module": "commonjs", "outDir": "./dist", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true }, "include": ["src/**/*"] } ``` 5. **서버 실행:** `backend` 디렉토리에서 `node dist/mcpServer.js`를 실행합니다. (또는 먼저 컴파일하지 않으려면 `ts-node src/mcpServer.ts`). 6. **프론트엔드 실행:** `MCPClient`를 웹 앱 (예: React 컴포넌트)에 통합하고 웹 앱을 실행합니다. `'http://localhost:3001'`을 MCP 서버의 올바른 URL로 바꾸십시오. 이 개선된 예제는 TypeScript 및 Socket.IO를 사용하여 Node.js MCP 서버와 통신하는 웹 앱을 구축하기 위한 견고한 기반을 제공합니다. 메시지 유형 및 처리 로직을 특정 애플리케이션 요구 사항에 맞게 조정하십시오. 또한 **프로덕션 환경에서는 `origin: "*"`를 절대 사용하지 마십시오**. 항상 허용된 출처를 특정 도메인으로 제한하십시오.

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.

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.

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.

magento-sql-mcp-server

Enables AI assistants to interact with a Magento 2 or Adobe Commerce MySQL database through 50+ read-only tools for orders, catalog, customers, CMS, configuration, indexers, and diagnostics, with support for local DDEV, Commerce Cloud, and remote/SSH connections.

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.

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.

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.

hermes-gpt

Enables MCP-based interaction with a local Hermes Agent installation, providing file read/search, skill management, and optional sandboxed write, terminal, and memory tools.