Discover Awesome MCP Servers

New Relic MCP Server

Run NRQL, NerdGraph, and REST v2 operations to query data, manage incidents, create synthetics, and annotate deployments — all from your MCP client.

Zephyr Scale MCP Server

Integrates with the Zephyr Scale test management tool for Jira to fetch and update test case information, including steps, labels, and priorities. It enables users to manage test cases through natural language interactions within Claude Desktop and other MCP clients.

OpenRouter Search MCP Server

Servidor MCP para la funcionalidad de búsqueda de OpenRouter

mcp-server-for-local

¡Hola a todos! Soy un servicio MCP rico en funciones, diseñado para romper las barreras entre dispositivos y servicios, brindando una experiencia conveniente a los usuarios. La herramienta del clima se vincula con la plataforma meteorológica para enviar rápidamente el clima global en tiempo real a los usuarios, ayudándolos a planificar sus viajes. La herramienta de control del navegador simula la operación manual, buscando y navegando automáticamente por las páginas web, ahorrando mucho tiempo. La herramienta de la cámara llama a la cámara local para tomar fotos y grabar videos, implementando el reconocimiento facial para garantizar la seguridad del hogar. Para lograr la colaboración de las herramientas, he construido un marco estable, y los desarrolladores pueden expandirse basándose en los servicios existentes.

pumperly-mcp

MCP server that exposes any Pumperly instance to LLMs, enabling real-time fuel price queries, station search, route planning, and geocoding.

n8n-MCP

An MCP server that empowers AI assistants to build, validate, and manage n8n workflows by providing structured access to documentation for over 1,200 nodes and thousands of templates. It enables deep integration with n8n instances for automated workflow orchestration and management through natural language.

MCP Bitpanda Server

Enables programmatic access to Bitpanda cryptocurrency exchange features including trades, wallets, and transactions via the Model Context Protocol.

Azure DevOps MCP Server

Enables AI assistants to interact with Azure DevOps repositories and pull requests, including listing PRs, fetching diffs, adding comments, and performing automated code reviews.

Postman MCP Generator

A Model Context Provider (MCP) server that exposes your automated API tools to MCP-compatible clients like Claude Desktop, allowing you to interact with APIs using natural language.

deadlink-checker-mcp

Dead link checker MCP server - find broken links, redirects, and timeouts on any website. Free tier: 30 links/scan.

GA4 MCP Server

Enables interaction with Google Analytics 4 data through the Google Analytics Data API. Built using Google ADK UI and deployed on Google Cloud Platform with proper service account authentication for GA4 data access.

STeLA MCP

Servidor MCP para operaciones del sistema local.

Weather MCP Server

Enables users to retrieve current weather information for any city location. Provides a simple interface to fetch weather data through natural language queries.

Conduit

Enables AI agents to interact with Figma in real-time through a WebSocket connection. Supports comprehensive design operations including text manipulation, layouts, components, variables, and export functionality.

MLB SportRadar MCP Server

Connects Claude to the SportRadar MLB API to access real-time baseball data including game schedules, live scores, player statistics, team standings, injury reports, and play-by-play information through natural language queries.

MCP Server Collection

The most accurate translation of "mcp服务聚合" depends on the context. Here are a few options: * **If referring to a general aggregation of MCP services:** * **Agregación de servicios MCP** * **If referring to a platform or system that aggregates MCP services:** * **Plataforma de agregación de servicios MCP** * **Sistema de agregación de servicios MCP** * **If referring to the process of aggregating MCP services:** * **Agregación de servicios MCP** (same as the first option, but emphasizes the action) Without more context, "Agregación de servicios MCP" is the safest and most general translation.

Pythagraph RED MCP Server

Enables retrieval and analysis of graph data from the Pythagraph RED API. Provides detailed graph statistics, node/edge distributions, and formatted table outputs for data visualization and analysis.

Formula1 MCP Server

Proporciona datos de carreras de Fórmula 1 en tiempo real e históricos a través del Protocolo de Contexto del Modelo, ofreciendo acceso a datos de cronometraje, estadísticas de pilotos, resultados de carreras, telemetría y más.

Path of Exile 2 Build Optimizer MCP

Enables AI-powered Path of Exile 2 character optimization through natural language queries, providing intelligent build recommendations, gear upgrades, and passive tree optimization using the official PoE API and comprehensive game database.

Spryker Search Tool MCP Server

Provides natural language search capabilities for Spryker GitHub repositories, packages, and public documentation. It enables code-level searches across Spryker organizations to help developers find relevant modules and technical information.

MCP GraphQL Query Generator

Automatically discovers GraphQL APIs through introspection and generates table-formatted queries with pagination, filters, and sorting. Supports multiple authentication types and provides both CLI and REST API interfaces for seamless integration.

Accounting MCP

A personal financial management tool that enables AI assistants to record transactions, check balances, and provide monthly financial summaries via the Model Context Protocol. It allows users to manage their expenses and income through natural language interactions using standardized MCP tools and resources.

Echo MCP Server

Okay, here's a basic outline and code example of a Model Context Protocol (MCP) server implementing an echo service using .NET Core. Since MCP is a somewhat abstract concept, I'll make some assumptions about how you want to use it. This example focuses on the core principles of receiving data, processing it (echoing), and sending it back. **Assumptions and Simplifications:** * **Transport:** I'll use TCP sockets as the underlying transport mechanism. MCP doesn't dictate the transport, but TCP is common and relatively straightforward. * **Message Framing:** I'll assume a simple line-based framing. Each message is terminated by a newline character (`\n`). This makes it easy to read and write messages. You might need to adapt this based on your specific MCP requirements. * **Error Handling:** Basic error handling is included, but a production system would need more robust error handling and logging. * **Model Context:** In this simple echo service, the "model context" is essentially the connection itself. More complex MCP implementations might involve associating data or state with each connection. * **.NET Core Version:** This example uses .NET 6 or later. **Code Example (C#):** ```csharp using System; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; namespace MCPEchoServer { class Program { static async Task Main(string[] args) { int port = 12345; // Choose a port IPAddress ipAddress = IPAddress.Any; // Listen on all interfaces TcpListener listener = new TcpListener(ipAddress, port); try { listener.Start(); Console.WriteLine($"MCP Echo Server listening on {ipAddress}:{port}"); while (true) { TcpClient client = await listener.AcceptTcpClientAsync(); Console.WriteLine($"Accepted connection from {client.Client.RemoteEndPoint}"); _ = Task.Run(() => HandleClientAsync(client)); // Handle each client in a separate task } } catch (Exception e) { Console.WriteLine($"Error: {e.Message}"); } finally { listener.Stop(); } } static async Task HandleClientAsync(TcpClient client) { try { NetworkStream stream = client.GetStream(); byte[] buffer = new byte[1024]; // Buffer for reading data StringBuilder messageBuilder = new StringBuilder(); while (true) { int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length); if (bytesRead == 0) { // Client disconnected Console.WriteLine($"Client {client.Client.RemoteEndPoint} disconnected."); break; } string receivedData = Encoding.UTF8.GetString(buffer, 0, bytesRead); messageBuilder.Append(receivedData); // Check for newline character (message delimiter) while (messageBuilder.ToString().Contains("\n")) { string message = messageBuilder.ToString().Substring(0, messageBuilder.ToString().IndexOf("\n")); messageBuilder.Remove(0, message.Length + 1); // Remove the message and the newline Console.WriteLine($"Received: {message}"); // Echo the message back to the client string echoMessage = $"{message}\n"; // Add newline back for the response byte[] echoBytes = Encoding.UTF8.GetBytes(echoMessage); await stream.WriteAsync(echoBytes, 0, echoBytes.Length); Console.WriteLine($"Sent: {echoMessage.Trim()}"); //Trim to remove the newline for console output } } } catch (Exception e) { Console.WriteLine($"Error handling client {client.Client.RemoteEndPoint}: {e.Message}"); } finally { client.Close(); } } } } ``` **Explanation:** 1. **`Main` Method:** * Sets up a `TcpListener` to listen for incoming connections on a specified port. * Enters a loop to accept incoming `TcpClient` connections. * For each accepted client, it starts a new `Task` to handle the client connection asynchronously using the `HandleClientAsync` method. This allows the server to handle multiple clients concurrently. 2. **`HandleClientAsync` Method:** * Gets the `NetworkStream` from the `TcpClient`. This stream is used for reading and writing data. * Creates a buffer to read data from the stream. * Enters a loop to continuously read data from the client. * **Reading Data:** `stream.ReadAsync` reads data from the stream into the buffer. * **Client Disconnection:** If `bytesRead` is 0, it means the client has disconnected. * **Message Assembly:** The received data is appended to a `StringBuilder` called `messageBuilder`. This is important because a single `ReadAsync` call might not receive the entire message at once. * **Message Delimiting (Framing):** The code checks if the `messageBuilder` contains a newline character (`\n`). This is how we determine the end of a message. * **Message Extraction:** If a newline is found, the message is extracted from the `messageBuilder`. * **Echoing:** The extracted message is echoed back to the client by writing it to the `NetworkStream`. A newline character is added back to the echoed message. * **Error Handling:** A `try-catch` block handles potential exceptions during the client handling process. * **Closing the Connection:** The `client.Close()` method closes the connection when the client disconnects or an error occurs. **How to Run:** 1. **Save:** Save the code as a `.cs` file (e.g., `MCPEchoServer.cs`). 2. **Create a Project:** Create a new .NET Core console application project. You can do this from the command line: ```bash dotnet new console -o MCPEchoServer cd MCPEchoServer ``` 3. **Replace Contents:** Replace the contents of `Program.cs` with the code above. 4. **Run:** Build and run the application from the command line: ```bash dotnet run ``` **Testing (using `netcat` or a similar tool):** 1. Open a terminal or command prompt. 2. Use `netcat` (or a similar tool like `telnet`) to connect to the server: ```bash nc localhost 12345 ``` 3. Type a message and press Enter. The server should echo the message back to you. For example: ``` Hello, MCP World! Hello, MCP World! ``` 4. Type another message and press Enter. 5. To disconnect, you can usually press `Ctrl+C` or `Ctrl+D`. **Important Considerations and Potential Improvements:** * **Message Framing:** The newline-based framing is simple but might not be suitable for all scenarios. Consider using a more robust framing mechanism, such as: * **Length-Prefix Framing:** Include the length of the message at the beginning of the message. * **Delimited Framing:** Use a special delimiter sequence that is unlikely to appear in the message itself. * **Error Handling:** Implement more comprehensive error handling, including logging errors to a file or database. * **Concurrency:** The current example uses `Task.Run` to handle clients concurrently. For high-performance servers, consider using asynchronous I/O (e.g., `Socket.ReceiveAsync` and `Socket.SendAsync`) directly to avoid blocking threads. The current implementation, while using `ReadAsync` and `WriteAsync`, still blocks a thread per client. True asynchronous I/O would use I/O completion ports and avoid thread blocking. * **Model Context:** Implement a more sophisticated model context management system. This might involve storing data associated with each connection in a dictionary or other data structure. Consider using a dependency injection container to manage the lifecycle of model context objects. * **Security:** If you're transmitting sensitive data, consider using TLS/SSL to encrypt the connection. * **Configuration:** Externalize configuration settings (e.g., port number, IP address) to a configuration file. * **Buffering:** Carefully manage buffer sizes to avoid buffer overflows or other issues. * **Cancellation:** Implement cancellation tokens to allow graceful shutdown of the server. * **MCP Specification:** Refer to the specific MCP specification you are implementing to ensure compliance. The term "Model Context Protocol" is somewhat generic, so understanding the specific requirements is crucial. This example provides a starting point for building an MCP echo server in .NET Core. Remember to adapt it to your specific needs and requirements. If you can provide more details about the specific MCP you're working with, I can provide more tailored guidance.

service-economics

Free service management tools — playbooks, benchmarks, and instant service health analysis. DigitalCore MCP gives you free access to service management expertise directly in your AI assistant. Run a Service Reality Check to score your service health in 60 seconds. Access strategy playbooks for ser

MCP Slack Python

An MCP server that enables interaction with Slack workspaces through tools for managing channels, sending messages, and retrieving user profiles. It leverages the Slack API and FastMCP to provide functionalities like message history lookup and reaction management.

Sugar CRM MCP Server by CData

This read-only MCP Server allows you to connect to Sugar CRM data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

snaprender-mcp

Lets AI agents like Claude capture website screenshots, check cache status, and monitor usage.

SimpleWeatherForecastServer

SimpleWeatherForecastServer

MCP Server (Mortgage Comparison Platform)

Servidor MCP canónico para analizar archivos PDF de Estimación del Préstamo (LE) y Declaración de Cierre (CD) y convertirlos en JSON compatible con MISMO, con contexto enriquecido por LLM. Creado para la automatización, el cumplimiento y la toma de decisiones impulsados por la IA en el ámbito hipotecario.