Discover Awesome MCP Servers

trip-search-mcp

Enables Claude to plan trips by performing live searches against Google Flights, hotels, vacation rentals, activities, and events, plus weather and currency conversion.

ANSYS MCP Server

Enables natural language-driven ANSYS simulations (Fluent, Mechanical, Geometry) with automatic TUI script generation for reproducibility.

io.github.DiaaAj/a-mem-mcp

A-MEM is a self-evolving memory system for coding agents that automatically organizes knowledge into a Zettelkasten-style graph with dynamic relationships, enabling semantic and structural search.

FAOSTAT MCP Server

Enables AI assistants to query the full FAOSTAT API for global food and agriculture statistics, allowing natural-language questions about crop production, trade, food security, emissions, and more.

MasterGo Magic MCP

Connects AI models to MasterGo design tools, enabling retrieval of DSL data, component documentation, and metadata from MasterGo design files for structured component development workflows.

Terraform MCP Server

Enables management of Terraform infrastructure as code through 25 comprehensive tools for operations including plan/apply/destroy, state management, workspace management, and configuration file editing.

mirador-mcp

Thin MCP adapter for Mirador Core that exposes data tools through the Core Internal API, enabling business data queries and schema exploration.

TempoGraph

Code graph context engine that parses codebases with tree-sitter (170+ languages), builds structural dependency graphs, and provides 24 MCP tools for code intelligence. One prepare_context call gives your AI agent the right files for any task. Includes focus, blast radius, hotspots, dead code detection, and hybrid search.

recon-fuzz-chimera-mcp

Recon Fuzz Chimera MCP knowledge to multi fuzzing enviornments compatibility in Solidity Smart contracts

ai-usage-metrics-mcp

A MCP server for tracking AI usage metrics and structured logs across applications. Monitor model calls, analyze usage patterns, track costs, and debug AI interactions.

Hellō Admin MCP Server

Enables AI assistants to create and manage Hellō applications with full developer context, supporting app creation, updates, secret generation, and logo management through a single unified tool.

A2AMCP

A Redis-backed MCP server that enables multiple AI agents to communicate, coordinate, and collaborate while working on parallel development tasks, preventing conflicts in shared codebases.

w3c-mcp

MCP Server for accessing W3C/WHATWG/IETF web specifications. Provides AI assistants with access to official web standards data including specifications, WebIDL definitions, CSS properties, and HTML elements.

Simple MCP POC

A proof-of-concept MCP server that enables reading local files and performing basic arithmetic operations. It provides a simple foundation for understanding how tools are exposed to MCP clients.

Codebase MCP Server

Enables AI assistants to semantically search and understand code repositories using PostgreSQL with pgvector embeddings. Provides repository indexing, natural language code search, and development task management with git integration.

MCP-Foundry

MCP Foundry

my-minimax-mcp

Wraps MiniMax AI as an autonomous code executor for Claude Code, offloading coding tasks to save Claude subscription tokens.

MCP TS Toolkit

A comprehensive MCP server providing secure tools for filesystem operations, Git management, web search, document conversion, npm/.NET project management, and AI generative capabilities (image/video/audio generation and processing) via PiAPI.ai integration.

HubAPI Auth MCP Server

An MCP server for interacting with HubSpot's authentication API, enabling secure authentication and authorization operations through natural language.

EVEE MCP Server

Provides interpretable variant effect predictions for 4.2 million ClinVar variants using the EVEE API. Enables searching, comparing, and analyzing genetic variants with AI-generated mechanistic interpretations and disruption profiles.

CorporateTravel Dispatch MCP

MCP server exposing CS Executive Services dispatch platform and airplanes.live flight tracking as portable, agent-agnostic tools.

MCP CVE Intelligence Server Lite

Provides unified access to vulnerability data from NVD, MITRE, and GitHub Security Advisories for cybersecurity intelligence.

ThinkDrop Vision Service

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

lynx-mcp

A 100% local MCP server for semantic and lexical search over your code, library docs, and PDFs, featuring hybrid BM25 and dense retrieval, syntax aware chunking, and an optional code knowledge graph. It also ships a Coral integration, so you can expose your code search as SQL and join it with live data, all without anything leaving your machine.

FILM-FINDER MCP Server

A simple MCP server for fetching movie and TV show data from TMDB and OMDB APIs. Provides natural language capability for users to search, compare, and analyze movies through AI assistants.

mcptokens

Provides tool to count token cost of any MCP server's tool definitions, enabling agents to assess cost before enabling.

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!

LLM Wiki Harness

Enables building and querying a local wiki knowledge base from raw source files via MCP tools and a PyQt viewer.

HubSpot MCP Server

A Type 4 OAuth MCP server that enables AI assistants to interact with HubSpot CRM objects like contacts, companies, deals, and tickets.