Discover Awesome MCP Servers

Superprecio MCP Server

Enables AI assistants to search products, compare prices, and find the best deals across multiple supermarkets in Argentina through Superprecio's price comparison API. Transforms Claude into an expert shopping assistant for Latin American grocery shopping.

lilo-vacation-rentals

The only MCP server with AI guest risk scoring and extortion detection. Search properties, book instantly, protect hosts. 41 tools across 5 layers. Instant API key, 10 free credits.

MySQL MCP Server

Enables direct interaction with MySQL databases through SQL queries, table exploration, and schema inspection with support for prepared statements and connection pooling.

Discord MCP Server

Enables interaction with Discord channels through a bot, allowing users to send messages and files, retrieve messages with advanced filtering, and download attachments of any type.

AtlasMemory

Turn any codebase into an AI-readable neural map — with proof. Every claim linked to code anchors (line + SHA-256 hash), every context window optimized with greedy token budgeting, every session protected by drift detection. Tree-sitter indexing across 11 languages, cross-session learning, AI enrichment, and 28 MCP tools. Zero config — just connect and your AI agent remembers everything.

MCP Time Server

Provides time and date functionality with support for multiple formats and timezones, enabling users to get current time/date, format timestamps, and retrieve comprehensive datetime information.

Track-It Process Monitor

Enables Claude to monitor and inspect running processes through a lightweight wrapper that captures stdout/stderr logs and stores process metadata in SQLite. Users can track any command execution and query process status, logs, and history through natural language.

Maiga API MCP Server

Provides comprehensive integration with the Maiga API for cryptocurrency analysis, including token technicals, social sentiment tracking, and KOL insights. It enables AI assistants to retrieve market reports, trending token data, and detailed on-chain information.

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.

PrestaShop MCP Server

Provides instant, offline access to comprehensive PrestaShop development documentation including 647+ hooks, module guides, component architecture, APIs, and theme development resources for AI assistants.

Reality Calendar MCP Server

Enables interaction with tool data stored in Google Drive Excel files through cached SQLite database. Provides access to tool information and descriptions with automatic background synchronization and OpenWebUI compatibility via OpenAI proxy.

Storyblok MCP Server

Enables comprehensive management of Storyblok CMS through natural language interactions. Supports story creation and publishing, asset management, component schema updates, release workflows, and content discovery across all major Storyblok APIs.

Microsoft Copilot Studio ❤️ MCP

A lab demonstrating how to deploy a Model Context Protocol (MCP) server that provides joke functionality to Microsoft Copilot Studio and GitHub Copilot.

LicenseSpring MCP Server

An MCP server implementation that integrates with LicenseSpring APIs, providing comprehensive license management and customer operations capabilities.

Test Generator MCP Server

Enables automatic generation of test scenarios from user stories uploaded to Claude desktop. Leverages MCP integration to streamline the test case creation process for development workflows.

MCP Weather Server

Enables AI agents to access real-time and historical weather data through multiple weather APIs including OpenMeteo, Tomorrow.io, and OpenWeatherMap. Provides comprehensive meteorological information including current conditions, forecasts, historical data, and weather alerts.

revolut mcp pulse

mcprice ⚡ MCP Server for real-time stock & crypto prices in Claude Desktop / Cursor. Stocks → Yahoo Finance (no API key needed) Crypto → Binance Public API (no API key needed) Companion to: revolut-pulse (insider trades)

claude-session-continuity-mcp

Zero-config session continuity for Claude Code. Automatically captures and restores project context across sessions using Claude Hooks.

tasksync-mcp

MCP server to give new instructions to agent while its working. It uses the get_feedback tool to collect your input from the feedback.md file in the workspace, which is sent back to the agent when you save.

Algorand MCP Server

Provides 50+ tools for comprehensive Algorand blockchain development including account management, asset operations, smart contracts, atomic transactions, swap functionality via Pera Swap, and semantic search through Algorand documentation.

mcpGraph

Enables orchestration of MCP tool calls through declarative YAML-defined directed graphs with data transformation, conditional routing, and observable execution flows.

Bocha Search MCP

一个以人工智能为中心的搜索引擎，使人工智能应用程序能够访问来自数十亿网页和生态系统内容源的高质量知识，涵盖各种领域，包括天气、新闻、百科全书、医疗信息、火车票和图像。

Build

Okay, I can help you understand how to use the TypeScript SDK to create different MCP (Mesh Configuration Protocol) servers. However, I need a little more context to give you the *most* helpful answer. Specifically, tell me: 1. **Which MCP SDK are you using?** There are several possibilities, including: * **Istio's MCP SDK (likely part of the `envoyproxy/go-control-plane` project, but you'd be using the TypeScript bindings).** This is the most common use case if you're working with Istio or Envoy. * **A custom MCP implementation.** If you're building your own MCP server from scratch, you'll need to define your own data structures and server logic. * **Another MCP SDK.** There might be other, less common, MCP SDKs available. 2. **What kind of MCP server do you want to create?** What specific resources will it serve? For example: * **Route Configuration (RDS) server:** Serves route configurations to Envoy proxies. * **Cluster Configuration (CDS) server:** Serves cluster definitions to Envoy proxies. * **Listener Configuration (LDS) server:** Serves listener configurations to Envoy proxies. * **Endpoint Discovery Service (EDS) server:** Serves endpoint information to Envoy proxies. * **A custom resource server:** Serves your own custom resource types. 3. **What is your desired level of detail?** Do you want: * **A high-level overview of the process?** * **Example code snippets?** * **A complete, runnable example?** (This would be more complex and require more information from you.) **General Steps (Assuming Istio/Envoy MCP):** Here's a general outline of the steps involved in creating an MCP server using a TypeScript SDK (assuming it's based on the Envoy/Istio MCP protocol): 1. **Install the Necessary Packages:** You'll need to install the appropriate TypeScript packages. This will likely involve: * The core gRPC library for TypeScript (`@grpc/grpc-js` or similar). * The generated TypeScript code from the Protocol Buffers (`.proto`) definitions for the MCP resources you want to serve (e.g., `envoy.config.route.v3`, `envoy.config.cluster.v3`, etc.). You'll typically use `protoc` (the Protocol Buffer compiler) and a TypeScript plugin to generate these files. * Potentially, a library that provides helper functions for working with MCP. ```bash npm install @grpc/grpc-js google-protobuf # And potentially other packages depending on your setup ``` 2. **Generate TypeScript Code from Protocol Buffers:** You'll need to obtain the `.proto` files that define the MCP resources (e.g., from the `envoyproxy/go-control-plane` repository or your own custom definitions). Then, use `protoc` to generate TypeScript code from these files. This will create the TypeScript classes that represent the resource types. Example `protoc` command (you'll need to adjust this based on your `.proto` file locations and plugin configuration): ```bash protoc --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts --ts_out=. your_mcp_resource.proto ``` 3. **Implement the gRPC Service:** Create a TypeScript class that implements the gRPC service defined in the `.proto` files. This class will have methods that correspond to the MCP endpoints (e.g., `StreamRoutes`, `StreamClusters`, etc.). These methods will receive requests from Envoy proxies and return the appropriate resource configurations. 4. **Handle the MCP Stream:** The core of an MCP server is handling the bidirectional gRPC stream. Your service implementation will need to: * Receive `DiscoveryRequest` messages from the client (Envoy proxy). * Process the request, determining which resources the client is requesting. * Fetch the appropriate resource configurations from your data store (e.g., a database, a configuration file, or in-memory data). * Construct `DiscoveryResponse` messages containing the resource configurations. * Send the `DiscoveryResponse` messages back to the client. * Handle errors and stream termination gracefully. 5. **Manage Resource Versions (Important for Updates):** MCP uses versioning to ensure that clients receive consistent updates. You'll need to track the versions of your resources and include them in the `DiscoveryResponse` messages. When a client sends a `DiscoveryRequest`, it will include the version of the resources it currently has. Your server should only send updates if the client's version is out of date. 6. **Implement a Data Store (Configuration Source):** You'll need a way to store and manage the resource configurations that your MCP server serves. This could be a simple configuration file, a database, or a more complex configuration management system. 7. **Start the gRPC Server:** Use the gRPC library to start a gRPC server and register your service implementation with it. The server will listen for incoming connections from Envoy proxies. 8. **Configure Envoy to Use Your MCP Server:** Configure your Envoy proxies to connect to your MCP server. This will typically involve specifying the server's address and port in the Envoy configuration. **Example (Conceptual - Requires Adaptation):** ```typescript // Assuming you've generated TypeScript code from your .proto files // import { RouteDiscoveryServiceService, RouteDiscoveryServiceHandlers } from './route_discovery_grpc_pb'; // import { DiscoveryRequest, DiscoveryResponse } from './discovery_pb'; import * as grpc from '@grpc/grpc-js'; // Replace with your actual generated code interface DiscoveryRequest { versionInfo: string; node: any; // Replace with your Node type resourceNames: string[]; typeUrl: string; responseNonce: string; errorDetail: any; // Replace with your Status type } interface DiscoveryResponse { versionInfo: string; resources: any[]; // Replace with your Resource type typeUrl: string; nonce: string; controlPlane: any; // Replace with your ControlPlane type } interface RouteDiscoveryServiceHandlers { streamRoutes: grpc.ServerDuplexStream<DiscoveryRequest, DiscoveryResponse>; } class RouteDiscoveryServiceImpl implements RouteDiscoveryServiceHandlers { streamRoutes(stream: grpc.ServerDuplexStream<DiscoveryRequest, DiscoveryResponse>): void { stream.on('data', (request: DiscoveryRequest) => { console.log('Received request:', request); // Fetch route configurations based on the request const routes = this.fetchRoutes(request); // Construct the DiscoveryResponse const response: DiscoveryResponse = { versionInfo: 'v1', // Replace with your versioning logic resources: routes, typeUrl: 'envoy.config.route.v3.RouteConfiguration', // Replace with your resource type URL nonce: 'some-nonce', // Generate a unique nonce controlPlane: null, // Replace if you have control plane info }; stream.write(response); }); stream.on('end', () => { console.log('Stream ended'); stream.end(); }); stream.on('error', (err) => { console.error('Stream error:', err); stream.end(); }); } private fetchRoutes(request: DiscoveryRequest): any[] { // Implement your logic to fetch route configurations // based on the request parameters (e.g., resourceNames, versionInfo) // This is where you would access your data store. console.log("fetching routes"); return [ { name: 'route1', domains: ['example.com'] }, { name: 'route2', domains: ['test.com'] }, ]; // Replace with actual route configurations } } function main() { const server = new grpc.Server(); // server.addService(RouteDiscoveryServiceService, new RouteDiscoveryServiceImpl()); server.addService({streamRoutes: {path: "/envoy.service.discovery.v3.RouteDiscoveryService/StreamRoutes", requestStream: true, responseStream: true, requestSerialize: (arg: any) => Buffer.from(JSON.stringify(arg)), requestDeserialize: (arg: Buffer) => JSON.parse(arg.toString()), responseSerialize: (arg: any) => Buffer.from(JSON.stringify(arg)), responseDeserialize: (arg: Buffer) => JSON.parse(arg.toString())}}, new RouteDiscoveryServiceImpl()); server.bindAsync('0.0.0.0:50051', grpc.ServerCredentials.createInsecure(), (err, port) => { if (err) { console.error('Failed to bind:', err); return; } console.log(`Server listening on port ${port}`); server.start(); }); } main(); ``` **Important Considerations:** * **Error Handling:** Implement robust error handling to gracefully handle unexpected situations. * **Logging:** Add logging to help you debug and monitor your MCP server. * **Security:** Secure your gRPC server using TLS/SSL. * **Scalability:** Consider the scalability of your MCP server, especially if you're serving a large number of Envoy proxies. * **Testing:** Thoroughly test your MCP server to ensure that it's working correctly. **Next Steps:** 1. **Tell me which MCP SDK you're using.** 2. **Tell me what kind of MCP server you want to create.** 3. **Tell me your desired level of detail.** Once I have this information, I can provide you with more specific and helpful guidance.

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.

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.

MCP Think

A Model Context Protocol server that provides AI assistants like Claude with a dedicated space for structured thinking during complex problem-solving tasks.

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.

Model Context Protocol (MCP) Server

A Python implementation of the MCP server that enables AI models to connect with external tools and data sources through a standardized protocol, supporting tool invocation and resource access via JSON-RPC.

Elasticsearch MCP Server

Enables Claude Desktop to connect directly to Elasticsearch clusters for intelligent log analysis through natural language queries. Users can ask questions about their logs in plain English and get actionable insights without writing complex Elasticsearch queries.

mcp-server-db2i

Enables AI assistants to query and inspect IBM DB2 for i databases using read-only SQL commands and schema inspection tools. It provides secure access to table metadata, views, and indexes via the JT400 JDBC driver.