Discover Awesome MCP Servers

Google Search Engine MCP Server

Enables Google search queries and webpage content extraction through an MCP server deployed on Cloudflare Workers. Supports single and batch webpage content extraction with integrated OAuth authentication.

ctxray

Context intelligence for AI coding sessions. 7 MCP tools to score, compare, compress, build, and scan prompts across 9 AI tools. Rule-based, <5ms/prompt, all analysis runs locally.

RAG Documentation

Una implementación de servidor MCP que proporciona herramientas para recuperar y procesar documentación a través de búsqueda vectorial, permitiendo a los asistentes de IA aumentar sus respuestas con contexto de documentación relevante.

MCP-ShellJS

Un servidor MCP seguro que proporciona acceso controlado a ShellJS para LLMs, permitiendo que los sistemas de IA ejecuten comandos de shell de forma segura e interactúen con el sistema de archivos dentro de un entorno de pruebas de seguridad configurable.

MCP Visual Language

Enables intelligent image analysis using GLM-4.5V model, specializing in extracting and analyzing code from screenshots with support for file paths and clipboard input.

MCP Docs RAG Server

Un servidor MCP en TypeScript que permite consultar documentos utilizando LLMs con contexto de repositorios y archivos de texto almacenados localmente a través de un sistema RAG (Generación Aumentada por Recuperación).

KnowledgeBaseMCP

Enables AI assistants to extract and analyze text content from various document formats (PDF, DOCX, PPTX, XLSX) in local knowledge bases, and create new formatted Word and Excel documents with structured data and reports.

gapup-mcp

100+ agent-payable C-suite expertises with x402 micro-payments — competitive intel, SEC filings, sanctions, KYC, clinical evidence, real estate, ESG. 183 tools, free tier 100 calls/month.

trace-mcp

Framework-aware code intelligence MCP server that builds a cross-language dependency graph from source code. 53 integrations (Laravel, Django, Rails, Spring, NestJS, Next.js, and more) across 68 languages. 100+ tools for navigation, impact analysis, refactoring, security scanning, session memory, and CI/PR reports — up to 97% token reduction.

IBM ODM Decision MCP Server

Bridges IBM Operational Decision Manager with AI assistants, enabling decisions as tools for integration with platforms like Watson Orchestrate and Claude Desktop.

mcp-mdns

MCP server that exposes mDNS service discovery functionality via the Model Context Protocol, enabling LLMs to discover and query zero-configuration network services on the local network.

arXiv MCP Server

Enables searching and retrieving academic papers from arXiv with support for advanced filtering by author, category, and date, plus full paper content extraction.

Basic MCP Server

A basic TypeScript implementation of the Model Context Protocol (MCP) server designed as a starting point for MCP development. Provides a minimal foundation for building custom MCP servers with stdio configuration for local integration with VS Code and GitHub Copilot.

MCP Server for Apache Gravitino

A FastMCP integration server that provides access to Apache Gravitino metadata management APIs, allowing users to manage catalog/schema/table metadata, tags, and user-role information through a structured interface.

CoolPC MCP Server

A Model Context Protocol server that enables Claude Desktop to query and analyze Taiwan CoolPC computer component prices, helping users generate custom PC quotes through AI assistance.

MCP Multi-Context 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 comprehensive documentation with AI-powered guidance.

Nostr MCP Server

Espejo de

SQLite Database Demo

Aquí hay algunos ejemplos de cómo construir un servidor, un cliente y pruebas en el contexto del protocolo de modelo (MCP). Ten en cuenta que "MCP" es un término bastante genérico, así que asumiré que te refieres a un protocolo que define cómo un cliente y un servidor intercambian información sobre modelos (por ejemplo, modelos de aprendizaje automático). **Ejemplo 1: Un MCP Simple para Servir un Modelo de Predicción** Este ejemplo ilustra un protocolo muy básico donde el cliente envía datos al servidor, el servidor usa un modelo para hacer una predicción y devuelve la predicción al cliente. **1. Definición del Protocolo (MCP):** * **Solicitud (Cliente -> Servidor):** * `input_data`: Un diccionario de datos de entrada para el modelo. Por ejemplo: `{"feature1": 1.0, "feature2": 2.5}` * **Respuesta (Servidor -> Cliente):** * `prediction`: La predicción del modelo. Por ejemplo: `0.85` * `status`: Un código de estado (e.g., "OK", "ERROR"). * `message` (opcional): Un mensaje de error si `status` es "ERROR". **2. Implementación del Servidor (Python con Flask):** ```python from flask import Flask, request, jsonify import pickle # Para cargar el modelo app = Flask(__name__) # Carga el modelo (reemplaza 'modelo.pkl' con tu archivo de modelo) try: with open('modelo.pkl', 'rb') as f: model = pickle.load(f) except FileNotFoundError: print("Error: No se encontró el archivo del modelo.") exit() @app.route('/predict', methods=['POST']) def predict(): try: data = request.get_json() input_data = data['input_data'] # Realiza la predicción usando el modelo prediction = model.predict([list(input_data.values())])[0] # Asume que el modelo espera una lista de valores return jsonify({'prediction': prediction, 'status': 'OK'}) except Exception as e: return jsonify({'status': 'ERROR', 'message': str(e)}) if __name__ == '__main__': app.run(debug=True) ``` **3. Implementación del Cliente (Python con Requests):** ```python import requests import json def make_prediction(input_data): url = 'http://localhost:5000/predict' # Ajusta la URL si es necesario headers = {'Content-type': 'application/json'} data = {'input_data': input_data} try: response = requests.post(url, data=json.dumps(data), headers=headers) response.raise_for_status() # Lanza una excepción para códigos de error HTTP result = response.json() return result except requests.exceptions.RequestException as e: print(f"Error de conexión: {e}") return {'status': 'ERROR', 'message': str(e)} except json.JSONDecodeError as e: print(f"Error al decodificar JSON: {e}") return {'status': 'ERROR', 'message': str(e)} # Ejemplo de uso input_data = {'feature1': 1.5, 'feature2': 3.2} result = make_prediction(input_data) if result['status'] == 'OK': print(f"Predicción: {result['prediction']}") else: print(f"Error: {result['message']}") ``` **4. Pruebas (Python con `unittest`):** ```python import unittest import requests import json class TestPredictionService(unittest.TestCase): def test_successful_prediction(self): url = 'http://localhost:5000/predict' headers = {'Content-type': 'application/json'} data = {'input_data': {'feature1': 2.0, 'feature2': 4.0}} response = requests.post(url, data=json.dumps(data), headers=headers) self.assertEqual(response.status_code, 200) # Verifica que la solicitud fue exitosa result = response.json() self.assertEqual(result['status'], 'OK') self.assertIsInstance(result['prediction'], float) # Verifica que la predicción es un número def test_error_handling(self): url = 'http://localhost:5000/predict' headers = {'Content-type': 'application/json'} data = {'input_data': {'feature1': 'invalid', 'feature2': 4.0}} # Datos inválidos response = requests.post(url, data=json.dumps(data), headers=headers) self.assertEqual(response.status_code, 200) # Aún esperamos un 200 OK (el error se maneja en el JSON) result = response.json() self.assertEqual(result['status'], 'ERROR') self.assertIn('could not convert string to float', result['message']) # Verifica el mensaje de error if __name__ == '__main__': unittest.main() ``` **Explicación del Código:** * **Servidor:** * Usa Flask para crear una API web simple. * Carga un modelo pre-entrenado (usando `pickle` como ejemplo). **Importante:** `pickle` puede ser inseguro si cargas modelos de fuentes no confiables. Considera usar formatos más seguros como `joblib` o guardar los pesos del modelo en un formato como HDF5 y reconstruir el modelo en el servidor. * Define un endpoint `/predict` que recibe datos JSON, los pasa al modelo y devuelve la predicción como JSON. * Maneja errores y devuelve un código de estado y un mensaje de error si algo sale mal. * **Cliente:** * Usa la biblioteca `requests` para enviar solicitudes POST al servidor. * Convierte los datos de entrada a JSON. * Maneja errores de conexión y errores al decodificar la respuesta JSON. * **Pruebas:** * Usa la biblioteca `unittest` para escribir pruebas automatizadas. * `test_successful_prediction`: Verifica que el servidor devuelve una predicción exitosa cuando se le dan datos válidos. * `test_error_handling`: Verifica que el servidor maneja correctamente los errores cuando se le dan datos inválidos. **Ejemplo 2: Un MCP Más Complejo para Actualizar un Modelo** Este ejemplo ilustra un protocolo donde el cliente puede enviar datos de entrenamiento al servidor para actualizar el modelo. **1. Definición del Protocolo (MCP):** * **Solicitud de Predicción (Cliente -> Servidor):** (Igual que antes) * `input_data`: Un diccionario de datos de entrada para el modelo. * **Respuesta de Predicción (Servidor -> Cliente):** (Igual que antes) * `prediction`: La predicción del modelo. * `status`: Un código de estado. * `message` (opcional): Un mensaje de error. * **Solicitud de Actualización (Cliente -> Servidor):** * `training_data`: Una lista de diccionarios, donde cada diccionario representa un ejemplo de entrenamiento. Por ejemplo: `[{"feature1": 1.0, "feature2": 2.0, "label": 0}, {"feature1": 2.0, "feature2": 3.0, "label": 1}]` * **Respuesta de Actualización (Servidor -> Cliente):** * `status`: Un código de estado ("OK", "ERROR"). * `message` (opcional): Un mensaje de error. **2. Implementación del Servidor (Python con Flask):** ```python from flask import Flask, request, jsonify import pickle import numpy as np # Para manejar datos numéricos app = Flask(__name__) # Carga el modelo try: with open('modelo.pkl', 'rb') as f: model = pickle.load(f) except FileNotFoundError: print("Error: No se encontró el archivo del modelo.") exit() @app.route('/predict', methods=['POST']) def predict(): try: data = request.get_json() input_data = data['input_data'] prediction = model.predict([list(input_data.values())])[0] return jsonify({'prediction': prediction, 'status': 'OK'}) except Exception as e: return jsonify({'status': 'ERROR', 'message': str(e)}) @app.route('/update', methods=['POST']) def update_model(): try: data = request.get_json() training_data = data['training_data'] # Prepara los datos para el entrenamiento X = np.array([list(example.values())[:-1] for example in training_data]) # Características y = np.array([example['label'] for example in training_data]) # Etiquetas # Entrena el modelo (aquí se asume un modelo con un método 'partial_fit') model.partial_fit(X, y) # 'partial_fit' es para entrenamiento incremental # Guarda el modelo actualizado with open('modelo.pkl', 'wb') as f: pickle.dump(model, f) return jsonify({'status': 'OK'}) except Exception as e: return jsonify({'status': 'ERROR', 'message': str(e)}) if __name__ == '__main__': app.run(debug=True) ``` **3. Implementación del Cliente (Python con Requests):** ```python import requests import json def make_prediction(input_data): # (Igual que antes) pass def update_model(training_data): url = 'http://localhost:5000/update' headers = {'Content-type': 'application/json'} data = {'training_data': training_data} try: response = requests.post(url, data=json.dumps(data), headers=headers) response.raise_for_status() result = response.json() return result except requests.exceptions.RequestException as e: print(f"Error de conexión: {e}") return {'status': 'ERROR', 'message': str(e)} except json.JSONDecodeError as e: print(f"Error al decodificar JSON: {e}") return {'status': 'ERROR', 'message': str(e)} # Ejemplo de uso training_data = [ {'feature1': 1.0, 'feature2': 2.0, 'label': 0}, {'feature1': 2.0, 'feature2': 3.0, 'label': 1} ] result = update_model(training_data) if result['status'] == 'OK': print("Modelo actualizado exitosamente.") else: print(f"Error al actualizar el modelo: {result['message']}") ``` **4. Pruebas (Python con `unittest`):** ```python import unittest import requests import json import pickle class TestModelUpdateService(unittest.TestCase): def setUp(self): # Guarda una copia del modelo original para restaurarlo después de la prueba with open('modelo.pkl', 'rb') as f: self.original_model = pickle.load(f) def tearDown(self): # Restaura el modelo original with open('modelo.pkl', 'wb') as f: pickle.dump(self.original_model, f) def test_successful_update(self): url = 'http://localhost:5000/update' headers = {'Content-type': 'application/json'} training_data = [ {'feature1': 3.0, 'feature2': 4.0, 'label': 0}, {'feature1': 4.0, 'feature2': 5.0, 'label': 1} ] data = {'training_data': training_data} response = requests.post(url, data=json.dumps(data), headers=headers) self.assertEqual(response.status_code, 200) result = response.json() self.assertEqual(result['status'], 'OK') # Verifica que el modelo ha cambiado (esto es una prueba simple; una prueba más robusta requeriría comparar las predicciones antes y después) with open('modelo.pkl', 'rb') as f: updated_model = pickle.load(f) self.assertNotEqual(self.original_model.__dict__, updated_model.__dict__) # Compara los diccionarios internos del objeto def test_update_error_handling(self): url = 'http://localhost:5000/update' headers = {'Content-type': 'application/json'} training_data = [ {'feature1': 'invalid', 'feature2': 4.0, 'label': 0}, # Datos inválidos {'feature1': 4.0, 'feature2': 5.0, 'label': 1} ] data = {'training_data': training_data} response = requests.post(url, data=json.dumps(data), headers=headers) self.assertEqual(response.status_code, 200) result = response.json() self.assertEqual(result['status'], 'ERROR') self.assertIn('could not convert string to float', result['message']) if __name__ == '__main__': unittest.main() ``` **Puntos Clave de este Ejemplo:** * **Endpoint `/update`:** Este endpoint recibe datos de entrenamiento y actualiza el modelo. * **Entrenamiento Incremental:** El ejemplo usa `model.partial_fit()`. Esto es *crucial* para el entrenamiento en línea, donde no tienes todos los datos disponibles de antemano. No todos los modelos tienen un método `partial_fit()`. Si tu modelo no lo tiene, tendrás que re-entrenar el modelo completo con los nuevos datos (lo cual puede ser costoso). * **Persistencia del Modelo:** Después de la actualización, el modelo se guarda de nuevo en el archivo `modelo.pkl`. * **Pruebas:** * `setUp` y `tearDown`: Estos métodos se usan para configurar y limpiar el entorno de prueba. En este caso, guardamos una copia del modelo original antes de la prueba y lo restauramos después para que las pruebas no afecten el estado del modelo a largo plazo. * La prueba `test_successful_update` verifica que el modelo se actualiza correctamente. **Importante:** La verificación de que el modelo ha cambiado es muy básica. Una prueba más robusta requeriría comparar las predicciones del modelo antes y después de la actualización para asegurarse de que las predicciones han mejorado con los nuevos datos. **Consideraciones Adicionales:** * **Seguridad:** La serialización con `pickle` puede ser peligrosa. Considera usar formatos más seguros como `joblib` o guardar los pesos del modelo en un formato como HDF5 y reconstruir el modelo en el servidor. También, valida y sanitiza los datos de entrada para prevenir ataques de inyección. * **Escalabilidad:** Para un sistema de producción, necesitarás una arquitectura más escalable. Considera usar un servidor web más robusto como Gunicorn o uWSGI, un balanceador de carga y una base de datos para almacenar los modelos. * **Control de Versiones del Modelo:** Es importante tener un sistema para controlar las versiones de tus modelos. Puedes usar un sistema de control de versiones como Git para rastrear los cambios en los archivos del modelo, o puedes usar una base de datos para almacenar los modelos y sus metadatos (versión, fecha de entrenamiento, etc.). * **Monitorización:** Monitoriza el rendimiento de tu modelo en producción. Rastrea métricas como la precisión, la latencia y el uso de recursos. Usa estas métricas para detectar problemas y mejorar el rendimiento del modelo. * **Autenticación y Autorización:** Implementa autenticación y autorización para proteger tu API. Asegúrate de que solo los usuarios autorizados puedan acceder a los endpoints de predicción y actualización. * **Validación de Datos:** Valida los datos de entrada tanto en el cliente como en el servidor. Asegúrate de que los datos tienen el formato correcto y que están dentro de los rangos esperados. Esto ayuda a prevenir errores y ataques. * **Manejo de Errores Robusto:** Implementa un manejo de errores robusto en el servidor. Captura todas las excepciones posibles y devuelve mensajes de error informativos al cliente. Registra los errores para que puedas diagnosticar y solucionar problemas. * **Documentación:** Documenta tu MCP claramente. Describe los formatos de solicitud y respuesta, los códigos de estado y los mensajes de error. Esto facilitará que otros desarrolladores usen tu API. * **Serialización:** Considera usar un formato de serialización más eficiente como Protocol Buffers o Apache Thrift, especialmente si estás manejando grandes cantidades de datos. Estos ejemplos te dan un punto de partida. La complejidad de tu MCP dependerá de los requisitos específicos de tu aplicación. Recuerda priorizar la seguridad, la escalabilidad y la mantenibilidad al diseñar tu protocolo.

JSON-RPC クライアントツール

Este es solo un proyecto privado, para tu referencia.

MCP Chat

A command-line interface application that enables interactive chat with AI models through the Anthropic API, supporting document retrieval, command-based prompts, and extensible tool integrations.

music-mcp-server

A music MCP server that enables searching and playing songs with controls like play, pause, stop, and resume.

Agent Ready

Agent Ready is an AI agent readability scanner — point it at any public URL and get back a 0–100 score plus per-check remediation hints for every failing check. This package wraps the same engine that powers agent-ready.dev as an MCP server, so Claude Desktop, Claude Code, Cursor, Cline, VS Code, and Windsurf can run scans inline and explain the results.

eip-mcp

Gives AI assistants access to the Exploit Intelligence Platform for vulnerability and exploit intelligence. Supports searching CVEs, exploits, and generating pentest findings.

Insights Knowledge Base MCP Server

A free, plug-and-play knowledge base server that provides access to 10,000+ insight reports with secure local data storage.

Web Research Assistant

Comprehensive web research toolkit with 13 tools for searching (via SearXNG), crawling, package discovery, GitHub metrics, error translation, API documentation lookup, data extraction, technology comparison, and service status checking.

GPT Image MCP Server

An MCP server for image generation, editing, and analysis using OpenAI's gpt-image-1 model, with specialized templates for YouTube thumbnails, blog headers, social media, and more.

yahoo-finance-mcp

MCP server for Thai SET/MAI stock data via Yahoo Finance API, enabling stock scanning, quotes, history, and financial statements.

Rhombus MCP Server

Enables AI assistants to interact with Rhombus physical security systems, providing access to smart cameras, access control, IoT sensors, and alarm monitoring through the Rhombus API.

nextmove-mcp

Analyzes your repository and suggests the next tasks to work on, presented as numbered options with context, enabling immediate action.