Discover Awesome MCP Servers

onec-meta-mcp

MCP server for searching and analyzing 1C enterprise metadata and BSL code using a SQLite backend. Enables querying configuration structure, code routines, and performing compliance checks via natural language.

mcp-cricket

Wraps CricAPI to provide live cricket data, enabling AI agents to query cricket information through natural language or direct tool calls.

TypeScript WordPress MCP Server

MCP server for WordPress content management that provides a secure interface for AI assistants to interact with WordPress sites, enabling content creation, editing, and media management without destructive operations.

irish-competition-mcp

Query Irish competition data from CCPC (Competition and Consumer Protection Commission) — regulations, decisions, and merger control — directly from AI assistants via MCP.

Yaver

P2P dev-machine MCP for phone-driven coding agents: hot reload, builds, deploys.

Bitrise Insights MCP Server

A temporary MCP server that scrapes Bitrise Insights using Playwright to fetch flaky test data, providing tools to query workspace and app test insights until the official API is released.

PlanetScale MCP Server

Provides tools for interacting with PlanetScale databases via the Model Context Protocol, enabling database operations through natural language or API calls.

campaign_chest

Provides 35 MCP tools for automated marketing campaigns, integrating event management, booking, and email marketing into a deterministic pipeline for AI agents.

Agent Audit Trail MCP Server

Provides tamper-proof audit logging for AI agents using SHA-256 hash chains, integrity verification, and compliance reporting for the EU AI Act.

Asana MCP Server

A Type 4 OAuth MCP server for the Asana API, enabling AI assistants to manage workspaces, projects, tasks, comments, users, and teams.

AutoDev MCP Examples

Okay, here are some example MCPs (Minimum Code Proposals) that might be relevant to an "AutoDev" context. Remember, the key to a good MCP is to be **small, testable, and deliverable**. These examples are broken down into categories to give you a better idea of the range. **Category: Code Generation/Templating** * **MCP 1: Simple Function Generator:** * **Description:** Create a function that takes a function name and a list of argument names (strings) as input. It generates a basic Python function definition with those arguments, including a `pass` statement in the body. * **Input:** `function_name = "calculate_sum"`, `arguments = ["a", "b"]` * **Output:** ```python def calculate_sum(a, b): pass ``` * **Rationale:** This is a foundational step for automatically generating code skeletons. * **MCP 2: Basic Class Generator:** * **Description:** Create a function that takes a class name and a list of attribute names (strings) as input. It generates a basic Python class definition with a constructor (`__init__`) that initializes those attributes. * **Input:** `class_name = "Dog"`, `attributes = ["name", "breed"]` * **Output:** ```python class Dog: def __init__(self, name, breed): self.name = name self.breed = breed ``` * **Rationale:** Extends the function generator to object-oriented programming. * **MCP 3: Conditional Statement Generator:** * **Description:** Create a function that takes a condition (string), and two code blocks (strings) as input. It generates an `if/else` statement. * **Input:** `condition = "x > 5"`, `if_block = "print('x is greater than 5')"` , `else_block = "print('x is not greater than 5')"` * **Output:** ```python if x > 5: print('x is greater than 5') else: print('x is not greater than 5') ``` * **Rationale:** Allows for generating code with branching logic. **Category: Automated Testing** * **MCP 4: Simple Unit Test Generator (for a function):** * **Description:** Given a function name and a set of input/output pairs (as a dictionary), generate a basic unit test using the `unittest` framework. * **Input:** `function_name = "add"`, `test_cases = { (1, 2): 3, (5, -2): 3 }` * **Output:** ```python import unittest def add(a, b): # Assuming this function exists return a + b class TestAdd(unittest.TestCase): def test_case_1(self): self.assertEqual(add(1, 2), 3) def test_case_2(self): self.assertEqual(add(5, -2), 3) if __name__ == '__main__': unittest.main() ``` * **Rationale:** Automates the creation of basic tests, reducing manual effort. * **MCP 5: Test Case Generation from Docstrings:** * **Description:** Parse a function's docstring (specifically, look for examples in a defined format) and generate unit tests based on those examples. Assume a simple format like `>>> add(1, 2) \n 3`. * **Input:** A function with a docstring containing examples. * **Output:** Unit tests generated from the docstring examples. * **Rationale:** Leverages existing documentation to create tests. **Category: Code Analysis/Understanding** * **MCP 6: Function Dependency Analyzer:** * **Description:** Given a Python file, identify all the functions that are called within a specific function. * **Input:** A Python file path and a function name. * **Output:** A list of function names called by the specified function. * **Rationale:** Helps understand the relationships between different parts of the code. * **MCP 7: Variable Usage Tracker:** * **Description:** Given a Python file and a variable name, find all lines of code where that variable is used (read or written). * **Input:** A Python file path and a variable name. * **Output:** A list of line numbers where the variable is used. * **Rationale:** Aids in debugging and understanding variable scope. **Category: Refactoring** * **MCP 8: Rename Variable (Simple):** * **Description:** Given a Python file, a variable name, and a new variable name, rename all occurrences of the variable within a limited scope (e.g., within a single function). * **Input:** A Python file path, the old variable name, the new variable name, and the function name where the renaming should occur. * **Output:** The modified Python file (or a string representing the modified content). * **Rationale:** A basic refactoring operation. **Important Considerations for AutoDev MCPs:** * **Scope:** Keep the scope very narrow. Focus on a single, well-defined task. * **Error Handling:** Include basic error handling (e.g., file not found, invalid input). * **Testability:** Write unit tests for each MCP. * **Dependencies:** Minimize external dependencies. If you need a library, justify its use. * **Incremental Development:** Build upon previous MCPs. For example, you might start with a simple function generator and then add features to it in subsequent MCPs. * **Language Support:** Specify the programming language (e.g., Python). * **Assumptions:** Clearly state any assumptions you are making (e.g., "The input file is valid Python code"). * **Example Use Cases:** Provide a few example use cases to illustrate how the MCP can be used. **Example of a well-defined MCP:** **MCP Title:** Generate a simple Python function with a docstring. **Description:** This MCP creates a function that takes a function name, a list of argument names (strings), and a docstring (string) as input. It generates a basic Python function definition with those arguments and the provided docstring. **Input:** * `function_name` (string): The name of the function. * `arguments` (list of strings): A list of argument names. * `docstring` (string): The docstring for the function. **Output:** A string containing the Python code for the function. **Example:** ```python function_name = "greet" arguments = ["name"] docstring = "Greets the person passed in as a parameter" # Expected Output: # def greet(name): # \"\"\"Greets the person passed in as a parameter\"\"\" # pass ``` **Rationale:** This is a foundational step for automatically generating documented code skeletons. **Error Handling:** * Raise a `TypeError` if the input types are incorrect. **Testing:** * Unit tests will verify that the generated code is syntactically correct and that the docstring is properly included. **Dependencies:** * None **Spanish Translation:** Here's the Spanish translation of the above information: **Ejemplos de MCP para AutoDev** Aquí hay algunos ejemplos de MCP (Propuestas de Código Mínimo) que podrían ser relevantes para un contexto de "AutoDev". Recuerda, la clave para un buen MCP es ser **pequeño, comprobable y entregable**. Estos ejemplos se dividen en categorías para darte una mejor idea del rango. **Categoría: Generación/Plantillas de Código** * **MCP 1: Generador de Funciones Simple:** * **Descripción:** Crear una función que tome un nombre de función y una lista de nombres de argumentos (cadenas) como entrada. Genera una definición básica de función de Python con esos argumentos, incluyendo una declaración `pass` en el cuerpo. * **Entrada:** `function_name = "calcular_suma"`, `arguments = ["a", "b"]` * **Salida:** ```python def calcular_suma(a, b): pass ``` * **Justificación:** Este es un paso fundamental para generar automáticamente esqueletos de código. * **MCP 2: Generador de Clases Básico:** * **Descripción:** Crear una función que tome un nombre de clase y una lista de nombres de atributos (cadenas) como entrada. Genera una definición básica de clase de Python con un constructor (`__init__`) que inicializa esos atributos. * **Entrada:** `class_name = "Perro"`, `attributes = ["nombre", "raza"]` * **Salida:** ```python class Perro: def __init__(self, nombre, raza): self.nombre = nombre self.raza = raza ``` * **Justificación:** Extiende el generador de funciones a la programación orientada a objetos. * **MCP 3: Generador de Declaraciones Condicionales:** * **Descripción:** Crear una función que tome una condición (cadena) y dos bloques de código (cadenas) como entrada. Genera una declaración `if/else`. * **Entrada:** `condition = "x > 5"`, `if_block = "print('x es mayor que 5')"` , `else_block = "print('x no es mayor que 5')"` * **Salida:** ```python if x > 5: print('x es mayor que 5') else: print('x no es mayor que 5') ``` * **Justificación:** Permite generar código con lógica de ramificación. **Categoría: Pruebas Automatizadas** * **MCP 4: Generador de Pruebas Unitarias Simple (para una función):** * **Descripción:** Dado un nombre de función y un conjunto de pares de entrada/salida (como un diccionario), generar una prueba unitaria básica utilizando el framework `unittest`. * **Entrada:** `function_name = "sumar"`, `test_cases = { (1, 2): 3, (5, -2): 3 }` * **Salida:** ```python import unittest def sumar(a, b): # Asumiendo que esta función existe return a + b class TestSumar(unittest.TestCase): def test_case_1(self): self.assertEqual(sumar(1, 2), 3) def test_case_2(self): self.assertEqual(sumar(5, -2), 3) if __name__ == '__main__': unittest.main() ``` * **Justificación:** Automatiza la creación de pruebas básicas, reduciendo el esfuerzo manual. * **MCP 5: Generación de Casos de Prueba a partir de Docstrings:** * **Descripción:** Analizar el docstring de una función (específicamente, buscar ejemplos en un formato definido) y generar pruebas unitarias basadas en esos ejemplos. Asumir un formato simple como `>>> sumar(1, 2) \n 3`. * **Entrada:** Una función con un docstring que contiene ejemplos. * **Salida:** Pruebas unitarias generadas a partir de los ejemplos del docstring. * **Justificación:** Aprovecha la documentación existente para crear pruebas. **Categoría: Análisis/Comprensión de Código** * **MCP 6: Analizador de Dependencias de Funciones:** * **Descripción:** Dado un archivo de Python, identificar todas las funciones que se llaman dentro de una función específica. * **Entrada:** Una ruta de archivo de Python y un nombre de función. * **Salida:** Una lista de nombres de funciones llamadas por la función especificada. * **Justificación:** Ayuda a comprender las relaciones entre diferentes partes del código. * **MCP 7: Rastreador de Uso de Variables:** * **Descripción:** Dado un archivo de Python y un nombre de variable, encontrar todas las líneas de código donde se utiliza esa variable (lectura o escritura). * **Entrada:** Una ruta de archivo de Python y un nombre de variable. * **Salida:** Una lista de números de línea donde se utiliza la variable. * **Justificación:** Ayuda a depurar y comprender el alcance de las variables. **Categoría: Refactorización** * **MCP 8: Renombrar Variable (Simple):** * **Descripción:** Dado un archivo de Python, un nombre de variable y un nuevo nombre de variable, renombrar todas las apariciones de la variable dentro de un alcance limitado (por ejemplo, dentro de una sola función). * **Entrada:** Una ruta de archivo de Python, el nombre de variable antiguo, el nuevo nombre de variable y el nombre de la función donde debe ocurrir el cambio de nombre. * **Salida:** El archivo de Python modificado (o una cadena que representa el contenido modificado). * **Justificación:** Una operación básica de refactorización. **Consideraciones Importantes para los MCP de AutoDev:** * **Alcance:** Mantén el alcance muy limitado. Concéntrate en una sola tarea bien definida. * **Manejo de Errores:** Incluye manejo de errores básico (por ejemplo, archivo no encontrado, entrada no válida). * **Capacidad de Prueba:** Escribe pruebas unitarias para cada MCP. * **Dependencias:** Minimiza las dependencias externas. Si necesitas una biblioteca, justifica su uso. * **Desarrollo Incremental:** Construye sobre MCP anteriores. Por ejemplo, podrías comenzar con un generador de funciones simple y luego agregarle características en MCP posteriores. * **Soporte de Idiomas:** Especifica el lenguaje de programación (por ejemplo, Python). * **Suposiciones:** Indica claramente cualquier suposición que estés haciendo (por ejemplo, "El archivo de entrada es código Python válido"). * **Casos de Uso de Ejemplo:** Proporciona algunos casos de uso de ejemplo para ilustrar cómo se puede utilizar el MCP. **Ejemplo de un MCP bien definido:** **Título del MCP:** Generar una función simple de Python con un docstring. **Descripción:** Este MCP crea una función que toma un nombre de función, una lista de nombres de argumentos (cadenas) y un docstring (cadena) como entrada. Genera una definición básica de función de Python con esos argumentos y el docstring proporcionado. **Entrada:** * `function_name` (cadena): El nombre de la función. * `arguments` (lista de cadenas): Una lista de nombres de argumentos. * `docstring` (cadena): El docstring para la función. **Salida:** Una cadena que contiene el código Python para la función. **Ejemplo:** ```python function_name = "saludar" arguments = ["nombre"] docstring = "Saluda a la persona pasada como parámetro" # Salida Esperada: # def saludar(nombre): # \"\"\"Saluda a la persona pasada como parámetro\"\"\" # pass ``` **Justificación:** Este es un paso fundamental para generar automáticamente esqueletos de código documentado. **Manejo de Errores:** * Lanzar un `TypeError` si los tipos de entrada son incorrectos. **Pruebas:** * Las pruebas unitarias verificarán que el código generado sea sintácticamente correcto y que el docstring esté incluido correctamente. **Dependencias:** * Ninguna I hope these examples and the Spanish translation are helpful! Let me know if you have any other questions.

Somnia MCP Server

Enables interaction with Somnia blockchain data, providing tools to retrieve block information, token balances, transaction history, and NFT metadata through the ORMI API.

MCP-Pushover Bridge

Enables AI assistants to send push notifications to mobile devices via Pushover, allowing users to receive instant alerts for task completions, errors, reminders, and custom messages through their AI conversations.

mcp-newsapi

Enables fetching top headlines and searching news archives from NewsAPI.org, allowing AI agents to access current and historical news data.

Weather MCP Server

Enables real-time weather queries via Claude Desktop using OpenWeatherMap API, providing current conditions and 24-hour forecasts for any city.

zerodrive-mcp-server

A Model Context Protocol (MCP) server for ZeroDrive file management. It enables AI assistants like Claude to interact with ZeroDrive cloud storage through a standardized interface.

Ableton MCP Enhanced

Enables controlling Ableton Live from Cursor using natural language commands for session/transport, MIDI, arrangement, plugins, mixer, and batch operations.

Flutter Package MCP Server

Integrates the Pub.dev API with AI assistants to provide real-time Flutter package information, documentation, and trend analysis. It enables users to search for packages, compare versions, and evaluate quality scores through natural language commands.

@everhour/mcp-server

Provides complete integration with the Everhour API for time tracking, project and task management, enabling AI assistants to manage productivity workflows.

Mcp

Este es un pasatiempo para probar servidores MCP.

Fluduro

A personality-to-flower quiz application with MCP tools for interactive widgets inside ChatGPT.

Unified MCP Server

Protocol-enforced learning system combining memory-augmented reasoning with workflow automation to improve AI assistant reliability by ensuring they learn from past experiences before making code changes.

telegram-mcp

Enables users to read, search, and manage Telegram messages in channels, groups, and private chats through MCP tools.

memory-mcp-server

Bridges Claude Code and Claude.ai by exposing project memory files over MCP for shared context across both interfaces.

Mem0 Memory MCP Server

Enables AI agents to store and retrieve memories with user-specific context using Mem0, allowing them to maintain conversation history and make informed decisions based on past interactions.

Todoist MCP Server

MCP server that connects Claude to Todoist, enabling full CRUD operations on tasks, projects, sections, comments, and labels.

Invoice Agent MCP Server

Create German invoices (§14 UStG) via Claude or any MCP-compatible AI by describing the invoice in natural language.

Grupr MCP Server

MCP server to interact with Grupr agents, enabling polling new messages, posting replies, and managing event webhooks.

Safaricom Daraja MCP Server

A Model Context Protocol (MCP) server that integrates Safaricom's M-PESA Daraja API with Claude, enabling natural language payment processing and real-time transaction notifications.

MCP Sentry para Cursor

Um servidor MCP completo para integração com Sentry no Cursor, oferecendo 27 ferramentas para monitoramento de erros, performance e saúde de aplicações.