Discover Awesome MCP Servers

MCP MySQL Server

Enables interaction with MySQL databases (including AWS RDS and cloud instances) through natural language. Supports database connections, query execution, schema inspection, and comprehensive database management operations.

Meraki Magic MCP

A Python-based MCP server that enables querying Cisco's Meraki Dashboard API to discover, monitor, and manage Meraki environments.

Cursor Rust Tools

Server MCP untuk memungkinkan LLM di Cursor mengakses Rust Analyzer, Crate Docs, dan Perintah Cargo.

database

Database MCP server for MySQL, MariaDB, PostgreSQL & SQLite

Finizi B4B MCP Server

Enables AI assistants to interact with the Finizi B4B platform through 15 comprehensive tools for managing business entities, invoices, vendors, and products. Features secure JWT authentication, automatic retries, and comprehensive business data operations through natural language commands.

Bocha Search MCP

Sebuah mesin pencari yang berfokus pada AI yang memungkinkan aplikasi AI untuk mengakses pengetahuan berkualitas tinggi dari miliaran halaman web dan sumber konten ekosistem di berbagai domain termasuk cuaca, berita, ensiklopedia, informasi medis, tiket kereta api, dan gambar.

Accounting MCP Server

Enables personal financial management through AI assistants by providing tools to add transactions, check balances, list transaction history, and generate monthly summaries. Supports natural language interaction for tracking income and expenses with categorization.

Build

Okay, here's a breakdown of how you can use the TypeScript SDK (likely referring to a specific SDK, so I'll provide a general approach and then you can adapt it to your specific SDK) to create different MCP (Management Control Plane) servers. I'll cover the key concepts, common patterns, and provide a code example. **Understanding the Problem** * **MCP (Management Control Plane):** An MCP is a centralized system that manages and controls various aspects of a distributed system. It typically handles configuration, policy enforcement, monitoring, and other management tasks. * **TypeScript SDK:** A TypeScript SDK provides a set of libraries, types, and tools that simplify interacting with a specific service or platform from TypeScript code. * **Creating Different MCP Servers:** This likely means you want to instantiate and configure multiple instances of an MCP server, potentially with different settings, configurations, or roles. This could be for testing, staging, production, or for isolating different parts of your system. **General Approach** 1. **SDK Installation and Setup:** * **Install the SDK:** Use `npm` or `yarn` to install the necessary SDK package. For example: ```bash npm install @your-mcp-sdk/core # Replace with the actual SDK package name yarn add @your-mcp-sdk/core ``` * **Import the SDK:** Import the required modules into your TypeScript file. ```typescript import { MCPClient, MCPConfig } from '@your-mcp-sdk/core'; // Adjust import paths ``` 2. **Configuration:** * **Configuration Objects:** Most SDKs use configuration objects to specify the settings for the MCP server. These objects might include: * **Host/Address:** The IP address or hostname where the MCP server will listen. * **Port:** The port number the server will use. * **Authentication Credentials:** API keys, tokens, usernames, passwords, or certificates. * **TLS/SSL Settings:** Configuration for secure communication. * **Logging Levels:** Control the verbosity of logging. * **Database Connection Details:** If the MCP server uses a database. * **Feature Flags:** Enable or disable specific features. * **Environment Variables:** Consider using environment variables to store sensitive configuration data (like API keys) or to easily switch between different environments (development, staging, production). 3. **Server Instantiation:** * **Create MCPClient Instances:** Use the SDK's `MCPClient` (or similar class) to create instances of the MCP server. Pass the configuration object to the constructor. ```typescript const config1: MCPConfig = { host: '127.0.0.1', port: 8080, apiKey: 'your-api-key-1', // ... other settings }; const config2: MCPConfig = { host: '127.0.0.1', port: 8081, apiKey: 'your-api-key-2', // ... different settings }; const mcpServer1 = new MCPClient(config1); const mcpServer2 = new MCPClient(config2); ``` 4. **Server Startup:** * **Start the Servers:** Use the SDK's methods to start the MCP servers. This might involve calling a `start()` or `listen()` method. ```typescript async function startServers() { try { await mcpServer1.start(); console.log('MCP Server 1 started on port 8080'); await mcpServer2.start(); console.log('MCP Server 2 started on port 8081'); } catch (error) { console.error('Error starting servers:', error); } } startServers(); ``` 5. **Server Management (Optional):** * **Stopping Servers:** Provide a way to gracefully shut down the servers (e.g., using a `stop()` or `close()` method). * **Health Checks:** Implement health checks to monitor the status of the servers. * **Logging:** Configure logging to track server activity and errors. **Complete Example (Illustrative)** ```typescript // Assuming a hypothetical @your-mcp-sdk/core SDK import { MCPClient, MCPConfig } from '@your-mcp-sdk/core'; import * as dotenv from 'dotenv'; // For loading environment variables dotenv.config(); // Load environment variables from .env file async function createAndStartMCP(config: MCPConfig, serverName: string) { try { const mcpServer = new MCPClient(config); await mcpServer.start(); console.log(`${serverName} started on ${config.host}:${config.port}`); return mcpServer; // Return the server instance if needed } catch (error) { console.error(`Error starting ${serverName}:`, error); return null; } } async function main() { // Configuration for MCP Server 1 const config1: MCPConfig = { host: process.env.MCP1_HOST || '127.0.0.1', // Use env var or default port: parseInt(process.env.MCP1_PORT || '8080', 10), apiKey: process.env.MCP1_API_KEY || 'default-api-key-1', // ... other settings }; // Configuration for MCP Server 2 const config2: MCPConfig = { host: process.env.MCP2_HOST || '127.0.0.1', port: parseInt(process.env.MCP2_PORT || '8081', 10), apiKey: process.env.MCP2_API_KEY || 'default-api-key-2', // ... different settings }; const server1 = await createAndStartMCP(config1, 'MCP Server 1'); const server2 = await createAndStartMCP(config2, 'MCP Server 2'); // You can now interact with the servers (e.g., send commands, monitor status) // if (server1) { // // Example: server1.sendCommand('some-command'); // } // Keep the servers running (e.g., using a loop or other mechanism) // This is a simplified example; in a real application, you'd have // more robust server management. console.log("Servers are running. Press Ctrl+C to exit."); await new Promise(resolve => setTimeout(resolve, 1000000)); // Keep running for a long time } main(); ``` **Key Considerations and Best Practices** * **Error Handling:** Implement robust error handling to catch exceptions and log errors. * **Asynchronous Operations:** Use `async/await` to handle asynchronous operations (like starting the servers) gracefully. * **Configuration Management:** Use a configuration management library (like `dotenv` or `config`) to manage configuration settings. * **Logging:** Use a logging library (like `winston` or `pino`) to log server activity and errors. * **Security:** Protect sensitive configuration data (like API keys) using environment variables or secure storage mechanisms. Use TLS/SSL for secure communication. * **Dependency Injection:** Consider using dependency injection to make your code more testable and maintainable. * **Testing:** Write unit tests and integration tests to verify the functionality of your MCP servers. * **Scalability:** Design your MCP servers to be scalable and resilient. Consider using a load balancer to distribute traffic across multiple servers. * **Specific SDK Documentation:** **Crucially, refer to the documentation for the *specific* TypeScript SDK you are using.** The class names, methods, and configuration options will vary depending on the SDK. **How to Adapt This to Your Specific SDK** 1. **Identify the SDK:** Determine the exact name and version of the TypeScript SDK you are using. 2. **Read the Documentation:** Carefully read the SDK's documentation to understand how to: * Create MCP server instances. * Configure the servers. * Start and stop the servers. * Interact with the servers (e.g., send commands, monitor status). 3. **Adapt the Code:** Modify the code examples above to use the correct class names, methods, and configuration options from your SDK. 4. **Experiment:** Experiment with different configuration settings to customize the behavior of your MCP servers. **Example with a Hypothetical `MyMCP` SDK** Let's say your SDK is called `@mymcp/sdk`. The documentation might say: * To create a server: `new MyMCP.Server(config)` * To start a server: `server.listen()` * Configuration options are in the `MyMCP.ServerConfig` interface. Then your code would look like: ```typescript import * as MyMCP from '@mymcp/sdk'; async function main() { const config1: MyMCP.ServerConfig = { address: '127.0.0.1', port: 9000, // ... other options }; const server1 = new MyMCP.Server(config1); try { await server1.listen(); console.log('MyMCP Server 1 listening on port 9000'); } catch (error) { console.error('Error starting server:', error); } } main(); ``` Remember to replace the placeholder `@your-mcp-sdk/core` and `MyMCP` with the actual name of your SDK. The key is to consult the SDK's documentation for the correct usage. Good luck!

au-weather-mcp

Provides access to Australian weather data from the Bureau of Meteorology, enabling location search, forecasts, and current observations.

Iris MCP Server

A multi-backend gateway that enables access to various services like Google Drive and Notion through a single MCP connector. It currently provides comprehensive Google Drive integration for reading, writing, and managing files and folders.

safe-omada-mcp

Security-focused MCP server for TP-Link Omada Open API workflows, enabling network management via natural language.

MCP Tool Server

A Model Context Protocol server that advertises tools with JSON schemas and executes tool calls safely, enabling AI agents to perform actions on real systems.

MyWeight MCP Server

A server that connects to the Health Planet API to fetch and provide weight measurement data through any MCP-compatible client, allowing for retrieval and analysis of personal weight records.

Universal Adapter

Enables autonomous task execution by dynamically searching APIs, generating Python tools, and running them on-demand, with built-in web search, scraping, and file operations.

@theyahia/voximplant-mcp

MCP server for Voximplant API enabling calls, SMS, recordings, scenarios, and rules management with 11 tools and 2 skills.

Resend MCP Server

Enables sending emails via the Resend API from Claude, with tools for sending, checking delivery status, listing recent emails, and managing domains.

GraphMemory-IDE

An AI-assisted, long-term memory system for IDEs, powered by Kuzu graph database. GraphMemory-IDE is an MCP server that provides semantic vector search, graph-based knowledge storage, and real-time analytics.

Mirdan

Automatically enhances developer prompts with quality requirements, codebase context, and architectural patterns, then orchestrates other MCP servers to ensure AI coding assistants produce high-quality, structured code that follows best practices and security standards.

Arkana

An MCP server that provides 294 malware analysis tools behind an AI-driven interface, enabling natural language investigation of binaries.

findata-mcp

A Financial Data Quality and AI Inference Evaluation MCP server that provides tools for auditing, bias detection, model evaluation, outlier scoring, A/B testing, and KPI reporting.

x64dbg MCP server

Sebuah server MCP untuk debugger x64dbg

Prompt Bookmarks

Enables users to organize, search, and manage a shared library of prompts across AI tools via the Model Context Protocol. It supports hierarchical folder organization, tagging, and template variable substitution for dynamic prompt generation.

Android Puppeteer

Enables AI agents to interact with Android devices through visual UI element detection and automated interactions. Provides comprehensive Android automation capabilities including touch gestures, text input, screenshots, and video recording via uiautomator2.

MCP Vaultwarden Server

Enables AI agents and automation scripts to securely interact with self-hosted Vaultwarden instances through the Bitwarden CLI, automatically managing vault sessions and providing tools to read, create, update, and delete secrets programmatically.

hive-exp

An MCP server enabling AI agents to record, query, and share structured problem-solving experiences with human review and confidence decay.

wheelfor-mcp

Create, spin, and manage shareable decision wheels on wheelfor.com. Supports creating wheels from any list of options, spinning for a random result, and getting a permanent shareable URL — no account required.

rce-cho-mcp

Enables querying the Dutch RCE Cultural Heritage Objects linked data endpoint via SPARQL, with ontology guidance and query validation for safe, accurate results.

ChatRPG

A lightweight ChatGPT app that converts your LLM into a Dungeon Master!

gemini-image-mcp

Enables Claude Code to generate and edit images using Google's Gemini and Imagen models on Vertex AI, with support for multiple models, aspect ratios, and image fusion.

FastMCP Demo Server

A production-ready MCP server that provides hackathon resources and reusable starter prompts. Built with FastMCP framework and includes comprehensive deployment options for development and production environments.