Discover Awesome MCP Servers

Wolfram Alpha MCP Server

Enables users to query Wolfram Alpha's computational knowledge engine through natural language. Provides access to mathematical computations, scientific data, and factual information via the Wolfram Alpha API.

UProc MCP

Server Protokol Konteks Model UProc resmi yang memungkinkan asisten AI untuk mereferensikan dan membuat keputusan berdasarkan data web publik.

Memory Cache Server

Server Protokol Konteks Model (MCP) yang mengoptimalkan penggunaan token dengan menyimpan data dalam cache selama interaksi model bahasa, kompatibel dengan model bahasa dan klien MCP apa pun.

BookStack MCP Server

Enables AI assistants to manage BookStack documentation through natural language, supporting content browsing, search, and CRUD operations for books, chapters, and pages.

Nuxt MCP Dev

Provides MCP support for Vite and Nuxt development servers, helping AI models better understand your application structure and codebase during development.

Mandoline MCP Server

Enables AI assistants to reflect on, critique, and continuously improve their performance using Mandoline's evaluation framework. Provides tools for creating custom evaluation metrics and scoring prompt/response pairs to measure AI assistant quality.

Drug Interaction MCP Server

Enables querying of Chinese-Western medicine interactions with comprehensive drug information, risk assessment, and clinical recommendations. Supports searching medicines, checking interactions individually or in batches, and provides safety guidance with severity classifications.

MCP MediaCrea

Enables image generation, editing, and blending using Gemini 2.5 Flash capabilities, plus text generation for AI-powered creative workflows through MCP tools.

MCP Browser Debugger

Enables comprehensive web frontend debugging and analysis through DOM inspection, JavaScript execution, network monitoring, console log capture, and automated browser interactions. Supports complete web development workflows including testing, data extraction, and performance analysis.

makefilemcpserver

An MCP server that exposes Makefile targets as callable tools for AI assistants, allowing Claude and similar models to execute Make commands with provided arguments.

wiki-js-mcp

wiki-js-mcp

Next.js Docs MCP

Provides AI agents with access to a comprehensive database of 200+ Next.js documentation URLs for intelligent document selection and retrieval. Enables Claude and other AI assistants to analyze user queries and recommend the most relevant Next.js documentation pages.

YouTube Search MCP Server

Enables AI assistants to search YouTube videos with rich metadata including titles, channels, view counts, and duration. Supports multi-language search and is designed for remote deployment on the Dedalus platform.

MCP GitHub Reader

Membawa repositori GitHub ke dalam konteks menggunakan server MCP ini.

Google Calendar MCP Server

Provides AI assistants with intelligent access to Google Calendar data, enabling natural language queries about availability, upcoming events, schedule conflicts, and meeting summaries through context-aware calendar integration.

Jokes MCP Server

An MCP server that enables Microsoft Copilot Studio to fetch and deliver various types of jokes (Chuck Norris, Dad jokes, and Yo Mama jokes) from multiple online joke APIs.

WordPress MCP Server

Sebuah server Model Context Protocol (MCP) untuk berinteraksi dengan situs WordPress. Server ini menyediakan alat untuk mengambil postingan, halaman, kategori, dan informasi situs dari instalasi WordPress mana pun yang mengaktifkan REST API.

Danbooru-Turso MCP Server

Collects and stores Danbooru character data in a Turso cloud database with automatic pagination and upsert functionality for managing anime character post information.

EntityIdentification

A MCP server that helps determine if two sets of data belong to the same entity by comparing both exact and semantic equality through text normalization and language model integration.

MCP Tool Starter Kit

A feature-complete TypeScript project template for rapidly developing Model Context Protocol tools with integrated best practices for code quality, testing, and automated deployment.

Cross-System Agent Communication MCP Server

Cermin dari

ThinkDrop Vision Service

Provides screen capture, OCR text extraction, and visual language model scene understanding capabilities with continuous monitoring and automatic memory storage integration.

Local MCP-Server-with-HTTPS-and-GitHub-OAuth

Proyek ini adalah server MCP aman yang dibangun dengan Node.js dan Express. Fiturnya mencakup enkripsi HTTPS menggunakan sertifikat yang ditandatangani sendiri, autentikasi GitHub OAuth, dan langkah-langkah keamanan tambahan seperti pembatasan laju (rate limiting) dan perlindungan header HTTP.

code-rules-mcp

Here are a few ways to approach building an MCP (presumably "Message Control Protocol" or similar) server for reliably reading code rules into an Agentic AI context, along with considerations for each: **1. Simple File Server with Versioning and Validation** * **Concept:** The MCP server acts as a repository for code rules stored in files (e.g., JSON, YAML, or even plain text with a defined format). It provides endpoints to retrieve these files, with versioning to track changes and validation to ensure the rules are well-formed. * **Components:** * **Storage:** A file system or database to store the rule files. Consider using Git for version control. * **API Endpoints:** * `/rules/{rule_name}/latest`: Returns the latest version of the rule set. * `/rules/{rule_name}/{version}`: Returns a specific version of the rule set. * `/rules/{rule_name}/versions`: Lists available versions of the rule set. * **Validation:** A schema or set of checks to ensure the rule files are valid before serving them. This could involve JSON schema validation, custom parsers, or unit tests. * **Caching:** Implement caching to reduce load on the storage and improve response times. * **Pros:** * Simple to implement. * Easy to understand and manage. * Good for relatively static rule sets. * Leverages existing file management and version control tools. * **Cons:** * Less suitable for highly dynamic or complex rule sets. * Requires careful management of file formats and validation. * May not scale well for a very large number of rules or frequent updates. * **Example (Python with Flask):** ```python from flask import Flask, jsonify, abort import os import json app = Flask(__name__) RULES_DIR = "rules" # Directory to store rule files def load_rule(rule_name, version="latest"): rule_file = os.path.join(RULES_DIR, f"{rule_name}_{version}.json") if not os.path.exists(rule_file): abort(404, f"Rule '{rule_name}' version '{version}' not found.") try: with open(rule_file, "r") as f: rule_data = json.load(f) # Add validation logic here (e.g., JSON schema validation) return rule_data except json.JSONDecodeError: abort(500, f"Error decoding JSON for rule '{rule_name}' version '{version}'.") @app.route("/rules/<rule_name>/latest") def get_latest_rule(rule_name): # In a real system, you'd determine the "latest" version dynamically # (e.g., by listing files in the directory and finding the highest version number) return jsonify(load_rule(rule_name, "latest")) @app.route("/rules/<rule_name>/<version>") def get_rule_version(rule_name, version): return jsonify(load_rule(rule_name, version)) if __name__ == "__main__": # Create a sample rule file for testing if not os.path.exists(RULES_DIR): os.makedirs(RULES_DIR) with open(os.path.join(RULES_DIR, "example_rule_latest.json"), "w") as f: json.dump({"rule_name": "example_rule", "description": "A sample rule."}, f) app.run(debug=True) ``` **2. Rule Engine Integration (e.g., Drools, Jess)** * **Concept:** Integrate a dedicated rule engine into the MCP server. The server manages the rule engine and provides an API to load, update, and query rules. The Agentic AI can then send data to the server, which uses the rule engine to determine the appropriate actions. * **Components:** * **Rule Engine:** Choose a rule engine like Drools (Java), Jess (Java), or a Python-based engine. * **API Endpoints:** * `/rules/load`: Loads a new rule set into the engine. * `/rules/update`: Updates an existing rule set. * `/rules/query`: Sends data to the engine and receives the results (actions to take). * **Rule Definition Language:** Use the rule engine's specific language (e.g., Drools Rule Language - DRL). * **Data Transformation:** Potentially need to transform data from the Agentic AI's format to the format expected by the rule engine. * **Pros:** * Powerful and flexible for complex rule sets. * Rule engines provide built-in reasoning and inference capabilities. * Well-suited for dynamic rule changes. * **Cons:** * More complex to implement and manage. * Requires learning the rule engine's language and API. * Can be resource-intensive, especially for large rule sets. * **Example (Conceptual - Drools):** ```java // (Conceptual Java code using Drools) KieServices kieServices = KieServices.Factory.get(); KieContainer kieContainer = kieServices.getKieClasspathContainer(); KieSession kieSession = kieContainer.newKieSession("ksession-rules"); // ... (API endpoint to load rules from a file or database) // ... (API endpoint to receive data from the Agentic AI) // Example: Receive data from the Agentic AI DataFromAI data = new DataFromAI(); // Assume this class holds the data kieSession.insert(data); kieSession.fireAllRules(); // Execute the rules // ... (Process the results - actions taken by the rules) ``` **3. Database-Driven Rule Management** * **Concept:** Store rules in a database (e.g., PostgreSQL, MySQL, MongoDB). The MCP server provides an API to query and manage the rules in the database. * **Components:** * **Database:** Choose a suitable database. Consider a document database (like MongoDB) if the rules have a flexible structure. * **API Endpoints:** * `/rules/query`: Queries the database for rules based on specific criteria. * `/rules/create`: Creates a new rule. * `/rules/update/{rule_id}`: Updates an existing rule. * `/rules/delete/{rule_id}`: Deletes a rule. * **Query Language:** Use SQL or the database's query language to retrieve rules. * **Data Modeling:** Design a database schema to represent the rules effectively. * **Pros:** * Scalable and reliable. * Easy to query and filter rules. * Good for managing a large number of rules. * Supports complex relationships between rules. * **Cons:** * Requires database administration. * Can be more complex to set up than a simple file server. * May require more code to implement the API endpoints. **Key Considerations for All Approaches:** * **Security:** Implement proper authentication and authorization to protect the rule sets. Consider using API keys, OAuth, or other security mechanisms. * **Scalability:** Design the MCP server to handle a large number of requests and rule sets. Consider using load balancing, caching, and database optimization. * **Monitoring:** Monitor the server's performance and health. Track metrics like request latency, error rates, and resource usage. * **Error Handling:** Implement robust error handling to gracefully handle invalid requests, database errors, and other issues. * **Rule Language:** Choose a rule language that is appropriate for the complexity of the rules and the skills of the development team. Consider using a domain-specific language (DSL) to make the rules easier to understand and maintain. * **Agentic AI Integration:** Design the API to be easily integrated with the Agentic AI. Consider using a standard data format like JSON or Protocol Buffers. * **Testing:** Thoroughly test the MCP server to ensure that it is reliable and accurate. Write unit tests, integration tests, and end-to-end tests. * **Versioning:** Implement versioning to track changes to the rule sets. This allows you to roll back to previous versions if necessary. * **Validation:** Validate the rule sets to ensure that they are well-formed and consistent. This can help to prevent errors and improve the reliability of the Agentic AI. **Choosing the Right Approach:** The best approach depends on the specific requirements of your Agentic AI and the complexity of the code rules. * **Simple File Server:** Good for small, relatively static rule sets. * **Rule Engine Integration:** Best for complex, dynamic rule sets that require reasoning and inference. * **Database-Driven Rule Management:** Suitable for large, complex rule sets that need to be easily queried and managed. Remember to start with a simple approach and iterate as needed. You can always add more features and complexity as your requirements evolve. **Indonesian Translation of Key Terms:** * **MCP Server:** Server MCP * **Agentic AI:** AI Agentik * **Code Rules:** Aturan Kode * **Context:** Konteks * **Rule Engine:** Mesin Aturan * **API Endpoint:** Titik Akhir API * **Versioning:** Pengaturan Versi * **Validation:** Validasi * **Scalability:** Skalabilitas * **Monitoring:** Pemantauan * **Error Handling:** Penanganan Kesalahan * **Database:** Basis Data * **Query:** Kueri * **Authentication:** Otentikasi * **Authorization:** Otorisasi * **Load Balancing:** Penyeimbangan Beban * **Caching:** Caching (sering digunakan langsung dalam bahasa Indonesia) * **Domain-Specific Language (DSL):** Bahasa Khusus Domain (BSD) This detailed explanation should give you a solid foundation for building your MCP server. Good luck!

MCP Server for YouTube Transcript API

Implementasi Server MCP untuk Integrasi YouTube

Curl MCP Server

A Model Context Protocol server that provides secure curl command execution capabilities, allowing AI assistants to make HTTP requests with configurable parameters and built-in security protections.