Discover Awesome MCP Servers

long-context-mcp

An MCP server implementing Recursive Language Models (RLM) to process arbitrarily large contexts through a programmatic probe, recurse, and synthesize loop. It enables LLMs to perform multi-step investigations and evidence-backed extraction across massive file sets without being limited by standard context windows.

mcp-interaction-studio

MCP server for Salesforce Interaction Studio that enables listing and managing datasets, campaigns, segments, and performance stats via natural language.

Velo Payments API MCP Server

An MCP server that enables interaction with Velo Payments APIs for global payment operations, automatically generated using AG2's MCP builder from the Velo Payments OpenAPI specification.

responsible-gambling-mcp

Enables users to calculate safe gambling budgets based on financial situation and assess gambling habits with risk levels and recommendations.

mcp-server-starter-demo

A minimal TypeScript MCP server that provides echo and text_stats tools for text validation and word/character counting over stdio.

diff-explainer

AI-powered git diff analysis with human-readable explanations, risk flags, and review checklists. Enables to explain any diff text or currently staged git changes through an MCP server.

Jira Extended MCP Server

Enables AI agents to manage Jira Cloud projects with full CRUD operations, bulk actions, sprint and release management, and issue linking using natural language.

fallcorp-mcp

Exposes foldkit's 7-prime spine, 7 κ-bands, and 6 fold operations as native tools and resources in any MCP client, enabling state folding, band classification, and crease pattern checks.

LeetCode MCP (Model Context Protocol)

Okay, I understand. You want to create a system (likely a program or script) that takes information from an MCP (presumably referring to a Minecraft Protocol) server and uses it to generate LeetCode-style notes. Here's a breakdown of how you might approach this, along with considerations and potential challenges: **Understanding the Goal** First, let's clarify what you mean by "LeetCode Notes." This could mean a few things: * **Problem Statements:** You want to generate problem descriptions based on the server's state or events. For example, "Find the shortest path to player X," or "Calculate the optimal crafting recipe for item Y." * **Algorithm Challenges:** You want to create algorithmic challenges related to Minecraft concepts. For example, "Implement a pathfinding algorithm to navigate a complex cave system," or "Design an efficient inventory management system." * **Data Structures:** You want to use Minecraft data (e.g., block data, entity data) to illustrate the use of specific data structures. For example, "Represent a chunk of Minecraft terrain using a sparse matrix," or "Use a graph to represent the network of tunnels in a mine." * **System Design:** You want to design systems that could be used in Minecraft, such as a load balancer for multiple servers or a distributed database for storing player data. **High-Level Architecture** 1. **Minecraft Server Connection:** * **Library:** Use a Minecraft Protocol library (e.g., `node-minecraft-protocol` for Node.js, `mcprotocol` for Python, or similar libraries in other languages). These libraries handle the low-level details of communicating with the Minecraft server. * **Authentication:** Handle authentication if required (e.g., using a Minecraft account). * **Data Acquisition:** Use the library to listen for relevant packets and extract the data you need. This might include: * Player positions * Block data * Entity data (mobs, items, etc.) * Chat messages * Server events (e.g., player joins, player deaths) 2. **Data Processing and Abstraction:** * **Data Structures:** Organize the data you receive from the server into appropriate data structures (e.g., lists, dictionaries, graphs). * **Abstraction:** Create an abstraction layer that translates Minecraft-specific data into more general concepts that can be used in algorithmic problems. For example: * "Block" -> "Node" * "Distance between blocks" -> "Edge weight" * "Player" -> "Agent" * **Problem Generation Logic:** This is the core of your system. Based on the processed data, generate problem statements, constraints, and test cases. This will likely involve: * **Templates:** Use templates for problem descriptions. For example: ``` "Find the shortest path from {start_block} to {end_block} avoiding {obstacles}." ``` * **Randomization:** Introduce randomness to create diverse problems. * **Difficulty Scaling:** Adjust the complexity of the problems based on parameters like the size of the search space, the number of constraints, or the difficulty of the algorithms required. 3. **LeetCode Note Generation:** * **Formatting:** Format the generated problem statements, constraints, and test cases in a way that resembles LeetCode problems. This might involve using Markdown or a similar markup language. * **Code Stubs (Optional):** Generate code stubs in common programming languages (e.g., Python, Java, C++) to help users get started. * **Solution (Optional):** Provide a sample solution to the problem. This is more complex, as you'll need to implement the algorithms yourself. **Example Scenario: Shortest Path Problem** 1. **Data Acquisition:** Get the player's current position and the position of a target block. Also, get the block data for the surrounding area to identify obstacles. 2. **Data Processing:** * Represent the Minecraft world as a graph, where each block is a node and the edges represent possible movements between blocks. * Assign weights to the edges based on the difficulty of moving between blocks (e.g., higher weight for climbing a ladder). 3. **Problem Generation:** * Use a template like: "Find the shortest path from your current location ({player_x}, {player_y}, {player_z}) to the diamond block at ({diamond_x}, {diamond_y}, {diamond_z}). You can move in any of the six cardinal directions (North, South, East, West, Up, Down). Avoid lava blocks." * Generate test cases with different starting and ending positions, and different obstacle configurations. 4. **LeetCode Note Generation:** * Format the problem statement, constraints (e.g., "The world is a 100x100x100 cube"), and test cases in Markdown. * Provide a code stub for a pathfinding algorithm (e.g., A* search). **Code Example (Conceptual - Python with `mcprotocol`):** ```python import mcprotocol import random # Replace with your server details SERVER_IP = "your_server_ip" SERVER_PORT = 25565 def connect_to_server(): client = mcprotocol.Client(SERVER_IP, SERVER_PORT) client.login("your_username", "your_password") # If needed return client def get_player_position(client): # Use mcprotocol to get the player's position # This will involve listening for the appropriate packets # and extracting the x, y, z coordinates. # (This is a simplified example - the actual implementation # will depend on the mcprotocol library.) player_x = client.player.x player_y = client.player.y player_z = client.player.z return player_x, player_y, player_z def get_block_data(client, x, y, z): # Use mcprotocol to get the block ID at the given coordinates. # (This is a simplified example - the actual implementation # will depend on the mcprotocol library.) block_id = client.world.getBlock(x, y, z) return block_id def generate_shortest_path_problem(client): player_x, player_y, player_z = get_player_position(client) diamond_x = random.randint(player_x - 50, player_x + 50) diamond_y = random.randint(player_y - 10, player_y + 10) diamond_z = random.randint(player_z - 50, player_z + 50) problem_statement = f""" **Problem:** Find the shortest path from your current location ({player_x}, {player_y}, {player_z}) to the diamond block at ({diamond_x}, {diamond_y}, {diamond_z}). **Constraints:** * You can move in any of the six cardinal directions (North, South, East, West, Up, Down). * Avoid lava blocks (block ID 10). * The world is a 100x100x100 cube centered around your starting position. **Example:** (Provide a small example with a simplified world) **Code Stub (Python):** ```python def shortest_path(start, end, world): # Implement your pathfinding algorithm here pass ``` """ return problem_statement if __name__ == "__main__": client = connect_to_server() problem = generate_shortest_path_problem(client) print(problem) client.close() ``` **Challenges and Considerations:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex and can change with updates. You'll need to stay up-to-date with the protocol and the libraries you use. * **Server Performance:** Querying the server for large amounts of data can impact performance. Be mindful of the number of requests you make. * **Problem Difficulty:** Generating problems that are both challenging and solvable is difficult. You'll need to carefully design your problem generation logic. * **Test Case Generation:** Generating good test cases is crucial for ensuring that solutions are correct. * **Abstraction Level:** Finding the right level of abstraction between Minecraft concepts and general algorithmic concepts is important. Too much detail will make the problems too specific, while too little detail will make them irrelevant. * **Ethical Considerations:** If you're using this system on a public server, be mindful of the impact on other players. Avoid generating problems that could disrupt gameplay or reveal sensitive information. **Next Steps:** 1. **Choose a Programming Language and Minecraft Protocol Library:** Python with `mcprotocol` or Node.js with `node-minecraft-protocol` are good starting points. 2. **Implement the Server Connection:** Get your program to connect to a Minecraft server and authenticate. 3. **Acquire Basic Data:** Start by getting the player's position and the block data for a small area around the player. 4. **Implement a Simple Problem Generator:** Start with a simple problem like the shortest path problem. 5. **Iterate and Refine:** Continuously improve your problem generation logic, test case generation, and formatting. This is a complex project, but it's definitely feasible. Start small, focus on one type of problem at a time, and iterate. Good luck!

delivery-intelligence-mcp

Enables delivery leads to query explainable programme health, prioritized risks, dependency impacts, change request effects, blocked decisions, and evidence-backed claims with refusal on unsupported assertions, all via deterministic tools and telemetry.

Toy MCP Server

A simple reference implementation demonstrating MCP server basics with two toy tools: generating random animals and simulating 20-sided die rolls.

flare-mcp

MCP server for Flare Network enabling natural language queries of FTSO price feeds, FAssets, balances, and FDC attestations.

Ashfords Law Firm MCP Server

Enables law firm staff to automate case intake, conflict-of-interest checks, and attorney assignment through secure MCP tools without exposing sensitive data directly to LLMs.

TestMu AI Test Manager MCP

Enables management of TestMu AI test projects, test cases, test runs, and integration with Jira, HyperExecute, and AI insights through natural language.

@nestr/mcp

MCP server that connects AI assistants like Claude to your Nestr workspace, enabling task, project, role management, and organizational insights through natural language.

web-ai-mcp

Provides free access to AI models (GPT-4o mini, Claude 3 Haiku, Llama 3.1) via DuckDuckGo AI chat without login, using stealth browser automation.

MFlowy

Enables users to interact with MFlowy, an MCP-native modular ML workflow engine with data analysis, model training, and orchestration.

insights-mcp-server

Here are a few options for translating "Red Hat Insights MCP Server POC", depending on the context and desired level of formality: * **More literal and general:** "Prueba de concepto (POC) del servidor MCP de Red Hat Insights" * **Slightly more concise:** "POC del servidor MCP de Red Hat Insights" * **If you want to emphasize the "server" aspect:** "POC del servidor MCP para Red Hat Insights" **Explanation of choices:** * **POC:** "POC" is widely understood in technical contexts and often used directly in Spanish. It stands for "Proof of Concept". * **Prueba de concepto:** This is the full Spanish translation of "Proof of Concept". Use this if you want to be more formal or if your audience might not be familiar with the abbreviation "POC". * **Servidor MCP:** "MCP Server" is likely a specific product or component name, so it's best to leave it as is. * **de Red Hat Insights / para Red Hat Insights:** Both "de" and "para" can work here. "De" implies belonging to or being part of, while "para" implies being used with or intended for. The best choice depends on the specific relationship between the MCP server and Red Hat Insights. Therefore, I would recommend using **"POC del servidor MCP de Red Hat Insights"** as a good balance between clarity and conciseness.

mcp-watermelon

MCP server for Watermelon.ai that exposes all 13 public API endpoints as tools, enabling AI assistants to manage contacts, conversations, messages, custom fields, and webhooks.

pyMSO5000 MCP Server

Enables AI agents to control Rigol MSO5000 oscilloscopes through VISA, including acquisition, channels, trigger, timebase, waveform generator, display, and front-panel controls, with risk-based permission gating for direct SCPI operations.

MCP Node Tasks 05 - Sampling

An MCP server that demonstrates sampling, enabling the server to request LLM completions from the client to assist in workflow tasks like planning work sessions.

Soma MCP Server

Enables running code against tests in an isolated sandbox to obtain PASS/FAIL verdicts with signed, offline-checkable certificates, and generating verified code with attached certificates after execution against derived tests.

Engram

A self-hosted MCP server enabling multiple AI coding agents to share state, preserve context across sessions, and coordinate with each other.

SAP Ariba Procurement MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for SAP Ariba Procurement (beta): https://www.cdata.com/download/download.aspx?sku=PAZK-V&type=beta

caniuse-mcp

An MCP server that provides browser compatibility data and web API support information using caniuse.com, MDN BCD, and Web Features, enabling developers to check feature support across browsers and against browserslist configurations.

MCP Server Implementations

Implementación de un servidor personalizado para el Protocolo de Control de Modelos (MCP) utilizando Eventos Enviados por el Servidor (SSE).

FAA Advisory Circular MCP

Enables searching, retrieving, and tracking FAA Advisory Circulars for airport operations with filtering by airport type, bookmarking, and export capabilities.

browse

Headless browser automation via MCP using Playwright WebKit.

cyberdyne-mcp

Lets an AI agent hire and pay a verified human: post real-world tasks (voice, observation, judgment) and pay in USDC via a non-custodial x402 auth-capture escrow on Base, budget frozen at deploy. Humans verify their X identity before submitting.

Interactive Feedback MCP

MCP server that enables human-in-the-loop workflow in AI-assisted development tools by allowing users to provide direct feedback to AI agents without consuming additional premium requests.