Discover Awesome MCP Servers

MCP MySQL Server

Enables AI assistants to safely query MySQL databases with read-only access by default, supporting table listing, structure inspection, and SQL queries with optional write operation control.

OSRS-STAT

A Model Context Protocol (MCP) server that provides real-time player statistics and ranking data of 'Old School RuneScape', supporting multiple game modes and player comparison functions.

Agent Interviews

Agent Interviews

Semantic Scholar MCP Server

Semantic Scholar API, providing comprehensive access to academic paper data, author information, and citation networks.

Todoist Meeting MCP

Connects Claude to Todoist for transforming meeting notes into actionable tasks with inferred due dates and priorities. It enables full task lifecycle management, including creating subtasks, listing projects, and completing tasks through natural language.

MCP demo (DeepSeek as Client's LLM)

Okay, I understand. You want me to provide instructions on how to run a Minimal Communication Protocol (MCP) client and server demo, using the DeepSeek API for some aspect of the communication. Since I don't know the specifics of your MCP implementation or how you intend to use the DeepSeek API, I'll provide a general outline and examples. You'll need to adapt this to your specific code and environment. **Assumptions:** * You have a basic understanding of Python and networking concepts (sockets). * You have a DeepSeek API key and know how to use it. * You have a working MCP client and server implementation (even a very basic one). * You want to use the DeepSeek API for something like: * Generating responses on the server side. * Analyzing messages sent between the client and server. * Generating test data for the client and server. **General Outline:** 1. **Set up your environment:** * Install necessary libraries (e.g., `socket`, `requests` for DeepSeek API). * Set your DeepSeek API key as an environment variable or store it securely. 2. **Basic MCP Client and Server (Without DeepSeek):** * Create a simple server that listens for connections and receives messages. * Create a simple client that connects to the server and sends messages. * Test that the basic communication works. 3. **Integrate DeepSeek API:** * Decide *where* and *how* you want to use the DeepSeek API. * Add the necessary code to call the DeepSeek API. * Handle the API response and integrate it into your MCP communication. 4. **Run the Demo:** * Start the server. * Start the client. * Observe the communication and the DeepSeek API interaction. **Example Code (Python):** **1. Environment Setup:** ```bash # Install necessary libraries pip install requests ``` **2. Basic MCP Server (server.py):** ```python import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) if not data: break message = data.decode('utf-8') print(f"Received: {message}") conn.sendall(data) # Echo back the message ``` **3. Basic MCP Client (client.py):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) message = "Hello, server!" s.sendall(message.encode('utf-8')) data = s.recv(1024) print(f"Received: {data.decode('utf-8')}") ``` **4. Integrating DeepSeek API (Example: Server-Side Response Generation):** ```python import socket import requests import os # For accessing environment variables HOST = '127.0.0.1' PORT = 65432 DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY") # Get API key from environment def generate_deepseek_response(prompt): """Calls the DeepSeek API to generate a response.""" if not DEEPSEEK_API_KEY: return "Error: DeepSeek API key not found. Please set the DEEPSEEK_API_KEY environment variable." url = "YOUR_DEEPSEEK_API_ENDPOINT" # Replace with the actual DeepSeek API endpoint headers = { "Authorization": f"Bearer {DEEPSEEK_API_KEY}", "Content-Type": "application/json" } data = { "prompt": prompt, "max_tokens": 50 # Adjust as needed # Add other parameters as required by the DeepSeek API } try: response = requests.post(url, headers=headers, json=data) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) json_response = response.json() return json_response["choices"][0]["text"].strip() # Adjust based on API response format except requests.exceptions.RequestException as e: return f"Error calling DeepSeek API: {e}" except (KeyError, IndexError) as e: return f"Error parsing DeepSeek API response: {e}" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) if not data: break message = data.decode('utf-8') print(f"Received: {message}") # Use DeepSeek API to generate a response based on the received message deepseek_prompt = f"Respond to the following message: {message}" deepseek_response = generate_deepseek_response(deepseek_prompt) print(f"DeepSeek Response: {deepseek_response}") conn.sendall(deepseek_response.encode('utf-8')) # Send the DeepSeek response back ``` **Important Considerations and Adaptations:** * **Replace Placeholders:** Fill in the `YOUR_DEEPSEEK_API_ENDPOINT` with the actual DeepSeek API endpoint. Adjust the `data` dictionary in `generate_deepseek_response` to match the API's required parameters. Also, adjust the parsing of the `json_response` to match the API's response format. * **Error Handling:** The example includes basic error handling for the DeepSeek API call. Add more robust error handling as needed. * **API Rate Limits:** Be mindful of the DeepSeek API's rate limits. Implement appropriate delays or retry mechanisms to avoid exceeding the limits. * **Security:** Never hardcode your API key directly into your code. Use environment variables or a secure configuration file. * **DeepSeek API Usage:** The example uses the DeepSeek API to generate a response to the client's message. You can adapt this to other use cases, such as: * **Analyzing the message:** Send the message to the DeepSeek API for sentiment analysis or topic extraction. * **Generating test data:** Use the DeepSeek API to create realistic test messages for your client and server. * **Validating messages:** Use the DeepSeek API to check if a message conforms to a specific format or contains certain keywords. * **MCP Protocol:** This example uses a very basic "echo" protocol. Adapt the code to your specific MCP protocol. You might need to handle different message types, headers, and data formats. * **Asynchronous Operations:** For more complex applications, consider using asynchronous operations (e.g., `asyncio`) to handle multiple client connections and API calls concurrently. **How to Run the Demo:** 1. **Save the code:** Save the server code as `server.py` and the client code as `client.py`. 2. **Set the API key:** Set the `DEEPSEEK_API_KEY` environment variable: ```bash export DEEPSEEK_API_KEY="YOUR_DEEPSEEK_API_KEY" # Replace with your actual API key ``` 3. **Run the server:** ```bash python server.py ``` 4. **Run the client:** ```bash python client.py ``` You should see the client connect to the server, send a message, and receive a response generated by the DeepSeek API. The server will print the received message and the DeepSeek API response. Remember to adapt this example to your specific MCP implementation and DeepSeek API use case. Good luck!

Synology Download Station MCP Server

A Model Context Protocol server that enables AI assistants to manage downloads, search for torrents, and monitor download statistics on a Synology NAS.

Oracle HCM Cloud MCP Server by CData

Oracle HCM Cloud MCP Server by CData

heap-seance

MCP server that provides 8 tools for Java memory leak investigation: \- Class histograms, GC pressure snapshots, JFR recordings, heap dumps, MAT leak suspects analysis, async-profiler allocation profiles \- Structured confidence-based verdicts (none/low/medium/high) requiring independent signal corroboration \- Designed for use inside Claude Code with two slash commands

ServiceDesk Plus MCP Server

A Model Context Protocol server for integrating with ServiceDesk Plus On-Premise that provides comprehensive CMDB functionality, allowing users to manage tickets, assets, software licenses, contracts, vendors, and administrative settings through natural language.

Harvest MCP Server

Provides MCP integration for Harvest's time tracking, project management, and invoicing functionality, enabling natural language interaction with Harvest API through tools for managing clients, time entries, projects, tasks, and users.

Swagger to MCP

Automatically converts Swagger/OpenAPI specifications into dynamic MCP tools, enabling interaction with any REST API through natural language by loading specs from local files or URLs.

claude-peers

Enables discovery and instant communication between multiple local Claude Code instances running across different projects. It allows agents to list active peers, share work summaries, and send messages through a local broker daemon.

SkyeNet-MCP-ACE

Enables AI agents to execute server-side JavaScript and perform CRUD operations directly on ServiceNow instances with context bloat reduction features for efficient token usage.

mcp-shell

Give hands to AI. MCP server to run shell commands securely, auditably, and on demand.

Layout Detector MCP

Analyzes webpage screenshots to extract precise layout information by locating image assets and calculating spatial relationships, enabling AI assistants to accurately recreate layouts with proper semantic structure using computer vision.

rxjs-mcp-server

Execute, debug, and visualize RxJS streams directly from AI assistants like Claude.

Agent Progress Tracker MCP Server

Enables AI agents to track, search, and retrieve their progress across projects with persistent memory using SQLite storage and LLM-powered summarization. Supports logging completed work, searching previous entries, and retrieving context for multi-step or multi-agent workflows.

YouTube MCP Server

Enables YouTube content browsing, video searching, and metadata retrieval via the YouTube Data API v3. It also facilitates fetching video transcripts for summarization and analysis within MCP-compatible AI clients.

Access Context Manager API MCP Server

An MCP server that provides access to Google's Access Context Manager API, enabling management of service perimeters and access levels through natural language.

OneTech MCP Server

Enables AI assistants to extract and document Mendix Studio Pro modules by interrogating local .mpr files. Generates comprehensive JSON documentation of domain models, pages, microflows, and enumerations without sending data to the cloud.

Reddit MCP Server

Provides access to Reddit's API for retrieving posts, comments, user information, and search functionality. Supports multiple authentication methods and comprehensive Reddit data operations including subreddit browsing, post retrieval, and user profile access.

KDB MCP Service

Enables AI agents to interact with KDB+ databases through standardized MCP tools, supporting full CRUD operations, schema introspection, and multi-database connections with connection pooling for efficient time-series and financial data management.

Godot MCP

Provides a comprehensive integration between LLMs and the Godot Engine, enabling AI assistants to intelligently manipulate project files, scripts, and the live editor. It supports advanced workflows including version-aware documentation querying, automated E2E game testing, and real-time visual context capture.

GitPilot MCP

A lightweight MCP server that enables AI assistants to manage local Git repositories by executing commands like status, add, and commit. It streamlines development workflows by providing repository context and diffs directly to the assistant.

go-mcp-server-mds

Aquí tienes una implementación en Go de un servidor del Protocolo de Contexto de Modelo (MCP) que sirve archivos Markdown con soporte para frontmatter desde un sistema de archivos: ```go package main import ( "encoding/json" "fmt" "io/ioutil" "log" "net/http" "os" "path/filepath" "strings" "github.com/gomarkdown/markdown" "gopkg.in/yaml.v2" ) // Configuración para el servidor MCP. type Config struct { Port int `yaml:"port"` // Puerto en el que escucha el servidor. ContentDir string `yaml:"content_dir"` // Directorio donde se encuentran los archivos Markdown. BaseURL string `yaml:"base_url"` // URL base para los endpoints del MCP. DefaultTitle string `yaml:"default_title"` // Título por defecto si no se encuentra en el frontmatter. } // Frontmatter extraído de los archivos Markdown. type Frontmatter struct { Title string `yaml:"title"` Description string `yaml:"description"` Tags []string `yaml:"tags"` // Agrega otros campos que necesites. } // Contexto del modelo que se devuelve como respuesta del MCP. type ModelContext struct { Title string `json:"title"` Description string `json:"description"` Content string `json:"content"` // Contenido HTML renderizado. Tags []string `json:"tags"` // Agrega otros campos que necesites. } // loadConfig carga la configuración desde un archivo YAML. func loadConfig(filename string) (Config, error) { var config Config yamlFile, err := ioutil.ReadFile(filename) if err != nil { return config, fmt.Errorf("error leyendo el archivo de configuración: %w", err) } err = yaml.Unmarshal(yamlFile, &config) if err != nil { return config, fmt.Errorf("error deserializando el archivo YAML: %w", err) } return config, nil } // parseMarkdownFile lee un archivo Markdown, extrae el frontmatter y convierte el contenido a HTML. func parseMarkdownFile(filename string, defaultConfig Config) (ModelContext, error) { content, err := ioutil.ReadFile(filename) if err != nil { return ModelContext{}, fmt.Errorf("error leyendo el archivo Markdown: %w", err) } // Separar frontmatter del contenido. parts := strings.SplitN(string(content), "---", 3) var frontmatter Frontmatter markdownContent := string(content) // Por defecto, usa todo el contenido. if len(parts) >= 3 { err = yaml.Unmarshal([]byte(parts[1]), &frontmatter) if err != nil { log.Printf("Advertencia: error deserializando el frontmatter en %s: %v", filename, err) // Continúa sin el frontmatter. } markdownContent = parts[2] } // Convertir Markdown a HTML. htmlContent := markdown.ToHTML([]byte(markdownContent), nil, nil) // Crear el contexto del modelo. modelContext := ModelContext{ Title: frontmatter.Title, Description: frontmatter.Description, Content: string(htmlContent), Tags: frontmatter.Tags, } // Usar valores por defecto si no están en el frontmatter. if modelContext.Title == "" { modelContext.Title = defaultConfig.DefaultTitle } return modelContext, nil } // mcpHandler maneja las solicitudes al endpoint del MCP. func mcpHandler(config Config) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { // Obtener el nombre del archivo desde la URL. filename := r.URL.Path[len(config.BaseURL):] // Elimina la URL base. filename = filepath.Join(config.ContentDir, filename) + ".md" // Agrega la extensión .md. // Verificar si el archivo existe. if _, err := os.Stat(filename); os.IsNotExist(err) { http.Error(w, "Archivo no encontrado", http.StatusNotFound) return } // Parsear el archivo Markdown. modelContext, err := parseMarkdownFile(filename, config) if err != nil { log.Printf("Error parseando el archivo Markdown %s: %v", filename, err) http.Error(w, "Error interno del servidor", http.StatusInternalServerError) return } // Convertir el contexto del modelo a JSON. w.Header().Set("Content-Type", "application/json") err = json.NewEncoder(w).Encode(modelContext) if err != nil { log.Printf("Error serializando a JSON: %v", err) http.Error(w, "Error interno del servidor", http.StatusInternalServerError) return } } } func main() { // Cargar la configuración. config, err := loadConfig("config.yaml") if err != nil { log.Fatalf("Error cargando la configuración: %v", err) } // Crear el manejador del MCP. mcpHandlerFunc := mcpHandler(config) // Registrar el manejador en la ruta especificada en la configuración. http.HandleFunc(config.BaseURL, mcpHandlerFunc) // Iniciar el servidor. addr := fmt.Sprintf(":%d", config.Port) log.Printf("Servidor MCP escuchando en %s", addr) log.Fatal(http.ListenAndServe(addr, nil)) } ``` **Explicación del código:** 1. **Estructuras de Datos:** * `Config`: Define la estructura para la configuración del servidor, incluyendo el puerto, el directorio de contenido, la URL base y un título por defecto. * `Frontmatter`: Representa los metadatos extraídos del frontmatter YAML en los archivos Markdown. * `ModelContext`: La estructura de datos que se devuelve como respuesta del servidor MCP. Contiene el título, la descripción, el contenido HTML renderizado y las etiquetas. 2. **`loadConfig(filename string) (Config, error)`:** * Carga la configuración desde un archivo YAML. * Utiliza la librería `gopkg.in/yaml.v2` para deserializar el archivo YAML en la estructura `Config`. * Maneja errores al leer el archivo o al deserializar el YAML. 3. **`parseMarkdownFile(filename string, defaultConfig Config) (ModelContext, error)`:** * Lee el archivo Markdown especificado. * Divide el contenido del archivo en tres partes usando `strings.SplitN(string(content), "---", 3)`. Esto asume que el frontmatter está delimitado por `---` al principio y al final. * Intenta deserializar la segunda parte (el frontmatter) en la estructura `Frontmatter` usando `yaml.Unmarshal`. * Convierte el contenido Markdown a HTML usando la librería `github.com/gomarkdown/markdown`. * Crea una instancia de `ModelContext` con los datos extraídos del frontmatter y el contenido HTML. * Si el título no está presente en el frontmatter, utiliza el título por defecto de la configuración. * Maneja errores al leer el archivo o al deserializar el frontmatter. 4. **`mcpHandler(config Config) http.HandlerFunc`:** * Esta función devuelve un `http.HandlerFunc` que maneja las solicitudes al endpoint del MCP. * Extrae el nombre del archivo de la URL de la solicitud. * Construye la ruta completa al archivo Markdown combinando el directorio de contenido de la configuración y el nombre del archivo. * Verifica si el archivo existe usando `os.Stat`. * Llama a `parseMarkdownFile` para parsear el archivo Markdown y obtener el `ModelContext`. * Convierte el `ModelContext` a JSON usando `json.NewEncoder`. * Establece el encabezado `Content-Type` a `application/json`. * Escribe la respuesta JSON al cliente. * Maneja errores si el archivo no existe, si hay un error al parsear el archivo Markdown o si hay un error al serializar a JSON. 5. **`main()`:** * Carga la configuración usando `loadConfig`. * Crea el manejador del MCP usando `mcpHandler`. * Registra el manejador en la ruta especificada en la configuración usando `http.HandleFunc`. * Inicia el servidor HTTP usando `http.ListenAndServe`. **Cómo usarlo:** 1. **Instala las dependencias:** ```bash go get gopkg.in/yaml.v2 go get github.com/gomarkdown/markdown ``` 2. **Crea un archivo `config.yaml`:** ```yaml port: 8080 content_dir: content base_url: /mcp/ default_title: "Título por Defecto" ``` * `port`: El puerto en el que el servidor escuchará. * `content_dir`: El directorio donde se almacenan tus archivos Markdown. * `base_url`: La URL base para el endpoint del MCP. Por ejemplo, si es `/mcp/`, entonces las solicitudes a `/mcp/mi-archivo` servirán el archivo `content/mi-archivo.md`. * `default_title`: El título que se usará si el frontmatter no contiene un título. 3. **Crea un directorio `content` y agrega archivos Markdown con frontmatter:** Ejemplo: `content/mi-articulo.md` ```markdown --- title: "Mi Artículo Genial" description: "Una descripción de mi artículo." tags: [go, markdown, mcp] --- # Este es el título del artículo Este es el contenido del artículo. ``` 4. **Ejecuta el servidor:** ```bash go run main.go ``` 5. **Accede al endpoint del MCP:** Abre tu navegador y ve a `http://localhost:8080/mcp/mi-articulo` (o la URL que corresponda a tu configuración y nombre de archivo). Deberías ver una respuesta JSON con el título, la descripción, el contenido HTML y las etiquetas del archivo `mi-articulo.md`. **Puntos importantes:** * **Manejo de Errores:** El código incluye manejo de errores para la lectura de archivos, el parseo de YAML y la serialización de JSON. Es importante manejar los errores adecuadamente para que el servidor sea robusto. * **Seguridad:** Este código es un ejemplo básico y no incluye medidas de seguridad. En un entorno de producción, deberías considerar medidas de seguridad como la validación de la entrada del usuario, la protección contra ataques de inyección y la autenticación/autorización. * **Rutas:** La lógica para construir las rutas de los archivos es simple. Podrías necesitar ajustarla para que se adapte a tus necesidades específicas. * **Frontmatter:** El código asume que el frontmatter está delimitado por `---`. Puedes modificarlo si usas un delimitador diferente. * **Librerías:** Asegúrate de tener instaladas las librerías `gopkg.in/yaml.v2` y `github.com/gomarkdown/markdown`. * **Configuración:** Es una buena práctica cargar la configuración desde un archivo externo para que puedas modificar el comportamiento del servidor sin tener que recompilar el código. * **Logging:** El código usa `log.Printf` para registrar mensajes. Considera usar una librería de logging más avanzada para un mejor manejo de los logs. Este ejemplo proporciona una base sólida para construir un servidor MCP que sirve archivos Markdown con soporte para frontmatter. Puedes personalizarlo y extenderlo para que se adapte a tus necesidades específicas.

MCP Mediator

Una implementación basada en Java del mediador del Protocolo de Contexto del Modelo (MCP), que proporciona una integración perfecta entre clientes y servidores MCP.

Yahoo Finance MCP Server

Provides real-time stock quotes, historical price data, financial news, and multi-stock comparisons using Yahoo Finance data. Enables users to access comprehensive financial market information through natural language queries.