Discover Awesome MCP Servers

Provena

Enables tracking and querying the provenance of AI-generated code, showing which sources influenced each line of code.

browserd

A continuously-recording Chromium daemon exposed over MCP, enabling AI agents to query past network, console, and DOM activity and control a headed browser.

Personal Neo4j Memory Server

Provides AI assistants with persistent, graph-based memory using Neo4j, enabling semantic search and complex relationship tracking. It features specialized Cloudflare Access support for secure remote connections and isolated multi-database management for different projects.

VoxFabric

VoxFabric is an MCP server for speech I/O, enabling TTS playback via Edge TTS and optional local ASR listening from any MCP host.

Discord MCP Server

Enables interaction with Discord through the Model Context Protocol, providing access to all Discord features like channels, messages, threads, reactions, and roles. Supports secure Discord bot operations with rate limiting, caching, and comprehensive API coverage for OpenAI, LangChain, and other MCP clients.

Covalent Bond

Allows two AI coding agents on different machines to securely pair and share files, context, and conventions through an end-to-end encrypted peer-to-peer channel with human-in-the-loop consent.

figma-agent-mcp

Connects AI agents to Figma through a local WebSocket bridge, enabling read/write access to open Figma files, node manipulation, and AI-assisted rename/group features.

Semantic API

Natural language API discovery MCP server. Search 700+ API capabilities across 163 current providers, get, exact endpoints, auth setup, and code snippets. Supports auto-discovery of new APIs.

K League API MCP

Enables querying K League official data (rankings, matches, players) via SQL using natural language, with a pre-built SQLite database.

Test Runner MCP

Facilita la ejecución unificada y el análisis de resultados para varios frameworks de pruebas, incluyendo Bats, Pytest, Flutter, Jest y Go, a través de una interfaz de Protocolo de Contexto de Modelo.

GimpMCP

An MCP server that allows LLMs to control GIMP programmatically, including images, layers, selections, text, transforms, filters, and arbitrary Script-Fu code.

unreal-api-mcp

Provides accurate Unreal Engine C++ API documentation to AI agents, preventing hallucinated signatures and incorrect includes.

Procheiron

MCP server that adds a trust layer to AI agent memory, enforcing independent review and tamper-evident audit chains for any memory store. It provides tools to search, get, propose, and promote memories under governance rules.

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!

Jira MCP Server

A local MCP server for managing Jira issues, enabling creation, update, deletion, search, and commenting on issues via natural language.

claude-code-mcp

A comprehensive guide and template collection for building model Context Protocol (MCP) servers using FastMCP and deploying them to Google Cloud Run.

korean-vocational-learning-map-mcp

MCP server providing a local learning graph for the Korean vocational high school curriculum (2022 revised), including 8,425 achievement standards, topics, and 10 tools for searching standards, topics, prerequisites, and learning roadmaps.

meetmyagent-mcp

Enables AI assistants to search, browse, and list businesses, services, and products on the MeetMyAgent marketplace.

fizzy-mcp

Enables AI assistants to interact with Fizzy boards, cards, and projects through natural language, with full API coverage and multiple transport options.

mcp-arcgis-fontana

Enables searching and querying City of Fontana, California open geospatial data (parcels, zoning, public works) via ArcGIS Feature Services.

mcpMulti.py

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

Fast Embedding MCP SSE

Provides fast static embedding, similarity, and search capabilities via MCP tools and an OpenAI-compatible HTTP API using a tiny 16M-parameter English embedding model.

calcfi-mcp

24 free personal-finance and macro tools (mortgage, paycheck, tax, FRED, BLS) for LLM agents. Zero API keys, stdio transport, source-cited from IRS, Federal Reserve, BLS, Treasury, and Freddie Mac.

Senado BR — Brazilian Federal Senate Open Data

MCP server for Brazilian Federal Senate open data — 90 tools covering the legislative process, Senate administration, and citizen participation. Hosted on Cloudflare Workers (Streamable HTTP), no authentication required. Tool names and responses are in Portuguese (pt-BR), matching the official Senate data.

Ops Lense

Enables commerce operations specialists to investigate and resolve stuck orders by diagnosing issues and performing safe, bounded remediations through AI-driven tools.

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.

PayPal Account Updater Subscription Connector

Proporciona integración con el servicio Account Updater de PayPal, lo que permite a los comerciantes mantener actualizada la información de las tarjetas de pago en sus sistemas de comercio electrónico a través de la gestión de suscripciones y las notificaciones de webhook.

claude-openmax

A Claude Code runtime adapter for OpenMax/CWS that enables bidirectional messaging and exposes workspace services as MCP tools.

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.

csv-analyzer

A local MCP server for analyzing CSV files from your filesystem, particularly suited for chatbot conversation logs. Allows listing, reading, filtering, merging, and statistical analysis of CSV data via natural language.