Discover Awesome MCP Servers

mcp-lock

MCP servers are installed via npx -y @scope/package — which silently downloads the latest version every time your AI tool starts, with no integrity check. mcp-lock fixes this by recording exact tarball hashes on first run and detecting any changes on every run after that — the same guarantee npm ci gives you for Node.js projects.

Q1-Reviewer-MCP

An MCP server that simulates a ruthless Q1 journal reviewer to analyze academic manuscripts for red flags and generate a formatted .docx decision letter.

my-mcp-server

A minimal MCP server for task management with a widget-based UI, built using the @miragon/mcp-toolkit.

Fusion 360 MCP Integration

Enables AI assistants to interact programmatically with Autodesk Fusion 360 for creating parametric 3D models through simple API calls.

SentinelAI MCP Server

Enables secure enterprise AI agents to access internal tools like GitHub, Gmail, Calendar, file systems, databases, and knowledge bases through the Model Context Protocol, with built-in security, audit, and observability.

go-unifi-mcp

MCP server for UniFi Network Controller enabling AI assistants to manage UniFi infrastructure via natural language. It supports firewall rules, IPv6, and uses lazy/eager tool modes to minimize context usage.

expo-android

MCP server for Android emulator automation via ADB.

wctx

Wctx is an MCP server that captures structured, evidence-backed context from completed coding agent sessions and serves it to future sessions, enabling cross-repository knowledge reuse without cloud dependencies or embeddings.

warp-drive-mcp

MCP server that exposes WarpDrive and EmberData docs as tools, enabling assistants to look up real documentation instead of guessing.

CorporateTravel Dispatch MCP

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

Citation Safe

Deterministic legal citation verification for AI-generated legal briefs. Three-layer verification: CourtListener database lookup, quote-match against primary source, and LLM edge-case verification. Free tier available.

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.

Cisco IQ MCP Server

A local MCP server that exposes Cisco IQ's Assets and Assessments REST APIs as read-only MCP tools, enabling AI assistants to query asset inventory, contracts, lifecycle data, security advisories, and field notices.

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.

Abacus

An MCP server for local Excel automation, providing 88 tools for reading, manipulating, and analyzing Excel files. It supports .xlsx, .xls, and .csv formats, with a unique nine-chapter classification system.

LLM Wiki Harness

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

qualys-pci-mcp

A read-only MCP server for the Qualys PCI Merchant API that lets LLM assistants answer questions about PCI compliance posture, such as which hosts are failing PCI or listing high findings.

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!

ibkr-mcp-server

MCP server for Interactive Brokers API integration, enabling account management, trading, market data, and short selling analysis through Claude.

GitHub Repo Assistant MCP Server

Enables creating GitHub repositories under a fixed owner and pushing multiple files in a single commit via the Git Data API, designed for deployment as a Vercel serverless function.

mcpserve-py

Exposes SQLite database query tools and markdown document resources over JSON-RPC 2.0 stdio transport, enabling AI assistants to read and search documents and execute read-only SQL queries.

test-dcr-mcp-server

A spec-compliant remote MCP server with built-in OAuth 2.1 and Dynamic Client Registration, enabling Notion Custom Agents to connect via 'Sign in with OAuth' without bearer tokens. It supports SSO federation to Google and Microsoft Entra, and includes basic tools like whoami, echo, and slow_task.

Proxima Centauri

A local development gateway that routes AI queries through browser sessions or API keys, enabling free and private access to frontier LLMs within code editors. It supports multiple providers and includes a self-healing Python agent for multi-agent delegation and cross-session memory.

Notarize

Signed AI content provenance with PII scrubbing — timestamps and signs AI-generated outputs for EU AI Act and FTC compliance.

mcp-marmiton

MCP server that searches French recipes from Marmiton, reads ingredients and steps, and rescales quantities to any number of servings without requiring an API key.

zephyr-squad-server-mcp

An MCP server that enables AI agents to drive Zephyr for Jira (Server/Data Center) test management via ZAPI. It exposes operations for test cycles, folders, executions, test steps, step results, and ZQL search over stdio for use with any MCP client.

FlowMCP

The world's first AI-to-3D data visualization bridge. An MCP server with 75 tools that lets any AI assistant transform raw data into interactive 3D spatial visualizations via Flow Immersive.