Discover Awesome MCP Servers

Paws-on-MCP

A comprehensive Model Context Protocol (MCP) server implementing the latest MCP specification with tools, resources, prompts, and enhanced sampling capabilities that features HackerNews and GitHub API integrations for AI-powered analysis.

Todo App

Esta aplicación fue construida completamente con Cursor, utilizando el servidor Box MCP para encontrar un PRD y las guías de codificación.

Chronos MCP Server

Here's the translation of "Simple .NET Core based mcp server for retrieving the current time.": **Servidor MCP simple basado en .NET Core para obtener la hora actual.** Here's a breakdown of the translation: * **Simple:** Simple * **.NET Core based:** basado en .NET Core * **mcp server:** servidor MCP (MCP is often left as is, as it's an acronym) * **for retrieving:** para obtener * **the current time:** la hora actual

JR East Delay Information MCP Server

An MCP server that provides real-time delay information for JR East train lines, accessible via MCP clients like Claude Desktop through the 'getDelays' tool.

Gemini Agent MCP Server

Provides a Model Context Protocol interface to the Gemini CLI, enabling AI agents to call the Gemini model and interact with development tools like code linting, GitHub operations, and documentation generation. Includes security measures to prevent unauthorized file access through path validation.

MCP Server with SSE

Enables real-time data streaming through Server-Sent Events with timestamp broadcasting and server monitoring capabilities. Optimized for deployment on Render.com with health checks and status endpoints.

MCP n8n API Server

Servidor MCP para la integración de la API de n8n - Conectar Claude AI a flujos de trabajo de n8n

App Market Intelligence

Un servidor MCP que proporciona inteligencia de mercado integral al analizar datos tanto de la App Store de Apple como de la Google Play Store, permitiendo a los usuarios investigar aplicaciones, rastrear tendencias del mercado, estudiar a la competencia y comprender los comentarios de los usuarios en los mercados móviles.

SSH MCP Server

An advanced SSH session manager that allows Claude to establish and manage multiple SSH connections, execute remote commands, and monitor connection health through the Model Context Protocol.

3D Printing MCP By OctoEverywhere

3D Printing MCP By OctoEverywhere

MCP QR Code Server

A server that connects large language models to QR code generation capabilities via Model Context Protocol, supporting multiple content types (URLs, WiFi credentials, contacts, text), output formats, and customization options.

Volcengine Knowledge Base MCP

Un servidor MCP de escritorio de Claude que proporciona funcionalidad de búsqueda en bases de conocimiento y chat para bases de conocimiento de Volcengine, permitiendo a los usuarios buscar y chatear con sus repositorios de conocimiento externos.

Qlik MCP Server

Permite a Claude interactuar con aplicaciones de Qlik Cloud y extraer datos de visualizaciones a través de la API de Qlik Cloud.

Amazon Leadership Principles MCP Server

Serves as a Model Context Protocol server that provides tools to look up Amazon Leadership Principles and access video transcripts for integration with Amazon Q CLI.

Port MCP Server

Un servidor MCP que permite a Claude interactuar con el agente de IA de Port.io, permitiendo a los usuarios activar el agente con instrucciones y recibir respuestas estructuradas que incluyen estado, salida y elementos de acción.

MCP TypeScript Template

A TypeScript template for building remote Model Context Protocol servers with modern tooling including Vite, Express, ESLint, Prettier, and Docker support. Includes an example echo tool to demonstrate MCP tool implementation.

mcpMulti.py

Un bucle de chat simple que incluye múltiples servidores MCP.

IcebergMCP

An MCP server that enables natural language interaction with Apache Iceberg data lakehouses, allowing users to query table metadata, schemas, and properties through Claude, Cursor, or other MCP clients.

Hue MCP Server

A Model Context Protocol server that enables AI assistants to control Philips Hue smart lighting systems through natural language commands.

MCP Filesystem Python

A secure MCP server enabling read-only access and file search capabilities within a specified directory, while respecting .gitignore patterns.

bilibili MCP Server

A Model Context Protocol server that allows AI assistants to retrieve user information, search videos by ID, and find content by keywords on bilibili.com.

Cloud Logging API Server

An MCP server that enables interaction with Google Cloud Logging API, allowing users to write, read, and manage log entries and configurations through natural language.

OpenAI MCP Server

Permite la integración con modelos de OpenAI a través del protocolo MCP, admitiendo respuestas concisas y detalladas para su uso con Claude Desktop.

rapidapi

Okay, here's a breakdown of how to integrate RapidAPI for testing, along with considerations and examples: **Understanding the Goal** The core idea is to use RapidAPI to: 1. **Access APIs:** RapidAPI provides a marketplace of APIs. You want to use these APIs in your tests. 2. **Mock APIs (Potentially):** While less common, you *could* use RapidAPI to create a mock API endpoint for testing purposes, although it's not its primary strength. Dedicated mocking tools are often better for this. 3. **Test API Integrations:** You want to verify that your application correctly interacts with APIs available through RapidAPI. **General Steps** 1. **Sign Up for RapidAPI:** * Go to [https://rapidapi.com/](https://rapidapi.com/) and create an account. You'll need to choose a plan (they often have a free tier). 2. **Find the API You Want to Test:** * Browse the RapidAPI marketplace and find the API you want to use in your tests. Consider: * **Relevance:** Does it provide data or functionality that your application uses? * **Free Tier/Pricing:** Make sure you can use it within your budget, especially for automated testing that might run frequently. * **Documentation:** Good documentation is essential for writing tests. 3. **Subscribe to the API:** * On the API's page, click "Subscribe to Test". * Choose a pricing plan. The "Basic" (free) plan is often sufficient for initial testing. 4. **Get Your API Key (X-RapidAPI-Key):** * After subscribing, you'll find your API key (usually labeled `X-RapidAPI-Key`) in the API's "Code Snippets" section or in your RapidAPI dashboard. **This key is crucial for authenticating your requests.** Treat it like a password! 5. **Choose a Testing Framework/Language:** * Select the testing framework and programming language you're most comfortable with. Common choices include: * **JavaScript (Node.js):** Jest, Mocha, Jasmine, Supertest * **Python:** pytest, unittest, requests * **Java:** JUnit, TestNG, Rest Assured * **C#:** NUnit, xUnit, RestSharp 6. **Write Your Tests:** * This is the core part. Here's a general outline: * **Import necessary libraries:** For example, `requests` in Python or `node-fetch` in JavaScript. * **Construct the API request:** Use the API's documentation to determine the correct endpoint URL, parameters, headers, and request body (if needed). * **Set the `X-RapidAPI-Key` header:** This is how you authenticate with RapidAPI. Also, set the `X-RapidAPI-Host` header. * **Send the request:** Use your chosen library to make the HTTP request (GET, POST, PUT, DELETE, etc.). * **Assert the response:** Check the HTTP status code, response headers, and response body to ensure they meet your expectations. **Example (Python with `pytest` and `requests`)** ```python import pytest import requests import os # For accessing environment variables # Load API key from environment variable (safer than hardcoding) RAPIDAPI_KEY = os.environ.get("RAPIDAPI_KEY") RAPIDAPI_HOST = "your-api-host.p.rapidapi.com" # Replace with the actual host @pytest.fixture def api_url(): """Fixture to define the API endpoint URL.""" return "https://your-api-host.p.rapidapi.com/your-endpoint" # Replace with the actual endpoint def test_api_status_code(api_url): """Test that the API returns a 200 OK status code.""" headers = { "X-RapidAPI-Key": RAPIDAPI_KEY, "X-RapidAPI-Host": RAPIDAPI_HOST } response = requests.get(api_url, headers=headers) assert response.status_code == 200 def test_api_response_data(api_url): """Test that the API returns valid JSON data.""" headers = { "X-RapidAPI-Key": RAPIDAPI_KEY, "X-RapidAPI-Host": RAPIDAPI_HOST } response = requests.get(api_url, headers=headers) response_json = response.json() # Attempt to parse as JSON assert isinstance(response_json, dict) # Check if it's a dictionary (JSON object) # Add more specific assertions based on the expected data structure # For example: # assert "some_key" in response_json # assert response_json["some_key"] == "expected_value" def test_api_with_parameters(api_url): """Test the API with query parameters.""" headers = { "X-RapidAPI-Key": RAPIDAPI_KEY, "X-RapidAPI-Host": RAPIDAPI_HOST } params = {"param1": "value1", "param2": "value2"} response = requests.get(api_url, headers=headers, params=params) assert response.status_code == 200 # Add assertions based on how the API should behave with these parameters ``` **Important Considerations and Best Practices** * **Environment Variables:** Never hardcode your API key directly into your code. Store it as an environment variable and access it using `os.environ.get("RAPIDAPI_KEY")` (or the equivalent in your language). This is crucial for security. * **Error Handling:** Wrap your API calls in `try...except` blocks (or similar) to handle potential errors like network issues, invalid API keys, or API downtime. Log these errors appropriately. * **Rate Limiting:** Be aware of the API's rate limits. RapidAPI enforces rate limits to prevent abuse. Implement retry logic with exponential backoff if you encounter rate limit errors (HTTP 429). Consider using a library like `tenacity` in Python to handle retries. * **Test Data:** Use realistic test data that covers different scenarios (valid data, invalid data, edge cases). * **Test Isolation:** Ideally, your tests should be independent of each other. Avoid relying on the state of previous tests. Use fixtures or setup/teardown methods to ensure a clean environment for each test. * **Mocking (Alternative):** If you need to completely isolate your tests from the real API (e.g., for offline testing or to avoid hitting rate limits during development), consider using a mocking library like `unittest.mock` (Python), `Jest` (JavaScript), or `Mockito` (Java). You would then mock the `requests.get` (or equivalent) function to return predefined responses. However, this means you're not actually testing the real API integration. * **CI/CD Integration:** Integrate your tests into your CI/CD pipeline to automatically run them whenever you make changes to your code. * **API Stability:** Be aware that APIs can change. Monitor your tests and update them if the API's behavior changes. Consider using API versioning if the API provides it. * **Logging:** Log API requests and responses during testing to help debug issues. * **`X-RapidAPI-Host` Header:** Don't forget to set the `X-RapidAPI-Host` header. This tells RapidAPI which API you're trying to access. The value is usually the domain name of the API endpoint. **Example (JavaScript with `node-fetch` and `Jest`)** ```javascript const fetch = require('node-fetch'); const apiKey = process.env.RAPIDAPI_KEY; // Get API key from environment variable const apiHost = 'your-api-host.p.rapidapi.com'; // Replace with the actual host const apiUrl = 'https://your-api-host.p.rapidapi.com/your-endpoint'; // Replace with the actual endpoint describe('API Tests', () => { it('should return a 200 OK status code', async () => { const response = await fetch(apiUrl, { method: 'GET', headers: { 'X-RapidAPI-Key': apiKey, 'X-RapidAPI-Host': apiHost, }, }); expect(response.status).toBe(200); }); it('should return valid JSON data', async () => { const response = await fetch(apiUrl, { method: 'GET', headers: { 'X-RapidAPI-Key': apiKey, 'X-RapidAPI-Host': apiHost, }, }); const data = await response.json(); expect(typeof data).toBe('object'); // Check if it's an object (JSON) // Add more specific assertions based on the expected data structure // For example: // expect(data).toHaveProperty('some_key'); // expect(data.some_key).toBe('expected_value'); }); it('should handle API errors gracefully', async () => { // Simulate an error by using an invalid API key or endpoint const invalidApiKey = 'invalid_api_key'; const response = await fetch(apiUrl, { method: 'GET', headers: { 'X-RapidAPI-Key': invalidApiKey, 'X-RapidAPI-Host': apiHost, }, }); // Check for an error status code (e.g., 401 Unauthorized) expect(response.status).toBeGreaterThanOrEqual(400); // Optionally, check for a specific error message in the response // const errorData = await response.json(); // expect(errorData).toHaveProperty('message', 'Invalid API key'); }); }); ``` **In summary:** 1. Sign up for RapidAPI and subscribe to the API you want to test. 2. Get your API key. 3. Choose a testing framework and language. 4. Write tests that make API requests, set the `X-RapidAPI-Key` and `X-RapidAPI-Host` headers, and assert the responses. 5. Handle errors, rate limits, and API changes gracefully. 6. Use environment variables to store your API key securely. 7. Integrate your tests into your CI/CD pipeline. Remember to replace the placeholder values (API key, host, endpoint) with your actual values. Good luck!

ZeroBounce MCP Server

A Model Context Protocol server that allows interaction with the ZeroBounce email validation service, enabling users to validate individual emails, check account credits, and perform bulk validations.

Supabase Memory MCP Server

Provides memory/knowledge graph storage capabilities using Supabase, enabling multiple Claude instances to safely share and maintain a knowledge graph with features like entity storage, concurrent access safety, and full text search.

CrewAI MCP Server

Exposes CrewAI tools through a REST API that allows Claude and other LLMs to access web search functionality, data analysis capabilities, and custom CrewAI tools.