Discover Awesome MCP Servers

Graphiti MCP Pro

Enhanced memory repository MCP service that enables building and querying temporally-aware knowledge graphs from user interactions and enterprise data. Features asynchronous processing, task management tools, multi-model compatibility, and a comprehensive visual management interface.

Better Notion MCP

Markdown-first MCP server for Notion that provides 7 composite action-based tools consolidating 28+ REST API endpoints, enabling AI agents to efficiently manage pages, databases, blocks, and content with automatic pagination and bulk operations.

StashDog MCP Server

Enables AI assistants to manage StashDog inventory through natural language commands, supporting item management, collections, tags, smart search, and URL imports with secure authentication.

Updation MCP

A production-grade, LLM-agnostic MCP server that integrates AI models with tools for managing subscriptions, organizations, and payments via the Updation API. It features Redis-backed conversation memory, structured logging, and role-based access control for secure, scalable orchestration.

Lotlytics — Real Estate Market Data

Live real estate market data for 895 US metros. Ask your AI assistant about home prices, rental yields, investment health scores, migration trends, and affordability. Free tier covers top 50 markets (no account needed). Premium tier unlocks all 895 markets, HUD Fair Market Rents, side-by-side market comparison, and filtered market search.

MCP Fantastical Server

Enables natural language calendar management through Fantastical on macOS, allowing users to create events, view schedules, search appointments, and navigate their calendar without leaving their AI conversation.

Penpot MCP Server

Enables AI agents to programmatically access self-hosted Penpot instances to read, create, modify, and export design elements through natural language. It provides 66 tools for managing projects, shapes, design tokens, and comments using a dual-access strategy of direct database reads and RPC API writes.

MCP Server Basic Example

A demonstration implementation of a Model Context Protocol server that provides simple mathematical tools (add, subtract) and personalized greeting resources.

Mcp Weather

Un servidor MCP sencillo que proporciona información meteorológica.

Outline Wiki MCP Server

Enables LLMs to interact with Outline wiki for document management, search, collections, and comments, with optional AI-powered features including RAG-based Q\&A and content summarization.

AFFiNE MCP Server

Enables interaction with AFFiNE workspaces through GraphQL API to manage documents, search content, handle comments, and access version history. Supports comprehensive workspace operations including document publishing, comment management, and user authentication via session cookies or personal access tokens.

Morse Code MCP Server

Aquí tienes un proyecto de servidor de código Morse basado en Python: **Título:** Servidor de Código Morse Python **Descripción:** Este proyecto crea un servidor simple en Python que puede recibir texto, convertirlo a código Morse y enviarlo de vuelta al cliente. También puede recibir código Morse y convertirlo a texto. **Funcionalidades:** * **Servidor Socket:** Escucha las conexiones entrantes de los clientes. * **Conversión Texto a Morse:** Convierte texto plano a código Morse. * **Conversión Morse a Texto:** Convierte código Morse a texto plano. * **Manejo de Múltiples Clientes (Opcional):** Puede manejar múltiples conexiones de clientes simultáneamente usando hilos o asincronía. * **Protocolo Simple:** Define un protocolo simple para la comunicación entre el cliente y el servidor (por ejemplo, enviar el texto/código Morse seguido de un carácter de fin de línea). **Requisitos:** * Python 3.x * Biblioteca `socket` (viene con Python) * (Opcional) Biblioteca `threading` o `asyncio` para manejo de múltiples clientes. **Estructura del Proyecto:** ``` morse_server/ ├── server.py # Código principal del servidor ├── morse_code.py # Módulo para la conversión de código Morse └── README.md # Instrucciones y documentación ``` **Contenido de los Archivos:** **`morse_code.py`:** ```python MORSE_CODE_DICT = { 'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.', 'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.', 'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-', 'Y': '-.--', 'Z': '--..', '1': '.----', '2': '..---', '3': '...--', '4': '....-', '5': '.....', '6': '-....', '7': '--...', '8': '---..', '9': '----.', '0': '-----', ', ': '--..--', '.': '.-.-.-', '?': '..--..', '/': '-..-.', '-': '-....-', '(': '-.--.', ')': '-.--.-' } def text_to_morse(text): """Convierte texto a código Morse.""" morse_code = '' for char in text.upper(): if char in MORSE_CODE_DICT: morse_code += MORSE_CODE_DICT[char] + ' ' else: morse_code += ' ' # Espacio para caracteres desconocidos return morse_code.strip() def morse_to_text(morse_code): """Convierte código Morse a texto.""" reverse_morse_dict = {value: key for key, value in MORSE_CODE_DICT.items()} text = '' for code in morse_code.split(): if code in reverse_morse_dict: text += reverse_morse_dict[code] else: text += '?' # Signo de interrogación para código Morse desconocido return text ``` **`server.py`:** ```python import socket import threading # Opcional: para manejo de múltiples clientes from morse_code import text_to_morse, morse_to_text HOST = '127.0.0.1' # Dirección IP del servidor (localhost) PORT = 65432 # Puerto para escuchar def handle_client(conn, addr): """Maneja la comunicación con un cliente.""" print(f"Conectado por {addr}") while True: data = conn.recv(1024).decode() if not data: break print(f"Recibido de {addr}: {data}") # Determinar si es texto o código Morse (ejemplo simple: si contiene '.' o '-') if '.' in data or '-' in data: response = morse_to_text(data) else: response = text_to_morse(data) conn.sendall(response.encode()) print(f"Desconectado de {addr}") conn.close() def main(): """Función principal del servidor.""" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Servidor escuchando en {HOST}:{PORT}") while True: conn, addr = s.accept() # Iniciar un nuevo hilo para manejar el cliente thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() print(f"Conexiones activas: {threading.active_count() - 1}") if __name__ == "__main__": main() ``` **Explicación del Código:** * **`morse_code.py`:** * Define un diccionario `MORSE_CODE_DICT` que mapea caracteres a su representación en código Morse. * `text_to_morse(text)`: Convierte un texto a código Morse. Convierte el texto a mayúsculas, itera sobre cada carácter, busca su equivalente en el diccionario y lo agrega a la cadena resultante. Si un carácter no se encuentra, agrega un espacio. * `morse_to_text(morse_code)`: Convierte código Morse a texto. Crea un diccionario inverso del diccionario original. Divide el código Morse en palabras (separadas por espacios), busca cada palabra en el diccionario inverso y agrega el carácter correspondiente a la cadena resultante. Si un código Morse no se encuentra, agrega un signo de interrogación. * **`server.py`:** * Define la dirección IP (`HOST`) y el puerto (`PORT`) en los que el servidor escuchará. * `handle_client(conn, addr)`: Esta función maneja la comunicación con un cliente individual. * Recibe datos del cliente usando `conn.recv(1024)`. * Decodifica los datos recibidos (asumiendo que están codificados en UTF-8). * Determina si los datos son texto o código Morse (en este ejemplo, simplemente verifica si contienen puntos o guiones). * Llama a la función de conversión apropiada (`text_to_morse` o `morse_to_text`). * Envía la respuesta al cliente usando `conn.sendall()`. * Cierra la conexión con el cliente. * `main()`: * Crea un socket usando `socket.socket(socket.AF_INET, socket.SOCK_STREAM)`. * Enlaza el socket a la dirección IP y el puerto especificados usando `s.bind((HOST, PORT))`. * Comienza a escuchar las conexiones entrantes usando `s.listen()`. * Entra en un bucle infinito que acepta nuevas conexiones usando `s.accept()`. * Para cada conexión, crea un nuevo hilo usando `threading.Thread` y ejecuta la función `handle_client` en ese hilo. Esto permite que el servidor maneje múltiples clientes simultáneamente. **Cómo Ejecutar el Proyecto:** 1. Guarda los archivos `morse_code.py` y `server.py` en el mismo directorio. 2. Abre una terminal y navega hasta el directorio donde guardaste los archivos. 3. Ejecuta el servidor con el comando: `python server.py` **Cliente de Ejemplo (Python):** ```python import socket HOST = '127.0.0.1' # La dirección IP del servidor PORT = 65432 # El puerto usado por el servidor with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) message = input("Ingrese texto o código Morse: ") s.sendall(message.encode()) data = s.recv(1024) print(f"Recibido: {data.decode()}") ``` Guarda este código como `client.py` en un directorio diferente (o en el mismo, pero asegúrate de que no interfiera con el servidor). Ejecútalo con `python client.py`. Ingresa texto o código Morse cuando se te solicite. **Mejoras Posibles:** * **Manejo de Errores:** Agrega manejo de errores más robusto (por ejemplo, para conexiones fallidas, datos inválidos, etc.). * **Protocolo Más Robusto:** Define un protocolo más robusto para la comunicación entre el cliente y el servidor (por ejemplo, usando un encabezado para indicar la longitud del mensaje). * **Interfaz de Usuario:** Crea una interfaz de usuario gráfica (GUI) para el cliente. * **Soporte para Audio:** Agrega soporte para reproducir el código Morse como audio. * **Asincronía:** Usa `asyncio` en lugar de `threading` para un manejo más eficiente de múltiples clientes (especialmente si tienes muchas conexiones). * **Validación de Entrada:** Valida la entrada del usuario para asegurar que solo se ingresen caracteres válidos para la conversión. * **Logging:** Implementa logging para registrar eventos importantes del servidor. Este es un punto de partida. Puedes expandir este proyecto para incluir más funcionalidades y hacerlo más robusto. Recuerda que el manejo de múltiples clientes con `threading` puede tener limitaciones en Python debido al Global Interpreter Lock (GIL). Para aplicaciones de alto rendimiento, considera usar `asyncio` o multiprocessing.

LinkedIn Content Creation MCP Server

Enables creation of optimized LinkedIn posts using a component-based design system with variants, themes, and composition patterns. Supports multiple post types (text, document, poll, video, carousel) with research-backed optimization for maximum engagement.

Powertools MCP Search Server

Enables LLMs to search through AWS Lambda Powertools documentation across multiple runtimes (Python, TypeScript, Java, .NET) using a Model Context Protocol server.

Code Graph Context

Builds rich code graphs from TypeScript/NestJS codebases using AST analysis and Neo4j, enabling semantic search, natural language querying, and intelligent graph traversal to provide deep contextual understanding of code relationships and dependencies.

Cube MCP Server

Enables users to interact with Cube's AI agent for real-time analytics and data exploration through a chat interface. It supports generating data visualizations, performing SQL queries, and analyzing trends using natural language.

MCP Next.js Hook Generator

Automatically generates typed React hooks for Next.js projects by crawling API routes, GraphQL queries, and components. Analyzes pages to suggest optimal render modes (SSR/CSR/ISR) and produces documentation with performance guidance.

MCP Orchestrator

A sophisticated server that coordinates multiple LLMs (Claude, Gemini, etc.) using the Model Context Protocol to enhance reasoning capabilities through strategies like progressive deep dive and consensus-based approaches.

Monobank MCP Server

Enables interaction with Monobank personal accounts through MCP tools to fetch client information, account details, and transaction statements for specified time periods.

GoHighLevel MCP Server

Connects Claude Desktop to GoHighLevel CRM, providing 269+ tools across 19 categories for complete contact management, messaging, sales, marketing, e-commerce, and business operations through AI automation.

Tesy 56 MCP Server

Provides AI agents and LLMs access to the Tesy 56 API through standardized MCP tools for seamless integration and interaction with Tesy 56 endpoints.

Pagila MCP Server

Enables interaction with the Pagila sample PostgreSQL database through natural language queries and SQL execution, supporting safe SELECT operations and text-to-SQL conversion.

Firecrawl MCP Server

Enables web scraping, crawling, and content extraction by integrating with the Firecrawl API. It supports deep research, batch scraping, and automatic rate limiting for both cloud and self-hosted environments.

Advanced Trello MCP Server

An enhanced Model Context Protocol server providing comprehensive integration between Trello and Cursor AI with 40+ tools covering multiple Trello API categories for complete project management.

Axom MCP Server

Provides persistent SQLite-based memory and unified tool abstraction for AI agents to support long-term context and complex tool chaining. It enables automated code analysis, file operations, and environment discovery through a standardized interface.

n8n Workflow Builder

Enables AI-powered building, optimization, debugging, and management of n8n workflows directly from Claude. Features workflow analysis, execution monitoring, security audits, drift detection, and intelligent error debugging with best practices guidance.

Mattermost MCP Server

A Model Context Protocol server that enables Claude to interact with Mattermost instances, supporting post management, channel operations, user management, and reaction management.

Devici MCP Server

Enables interaction with the Devici API for managing threat models, security components, mitigations, users, teams, and collections through natural language.

MCP Inventario

Enables inventory management through MongoDB with tools for creating, listing, searching, updating, and deleting items and categories. Supports natural language interactions via Groq AI integration.