Discover Awesome MCP Servers

InstantDB MCP Server

Proporciona una interfaz de solo lectura para consultar datos de InstantDB con herramientas para ejecutar consultas y recuperar ejemplos basados en patrones predefinidos.

Axiom MCP Server

Un puerto compatible con npx de mcp-server-axiom de @Axiom

MySQL-MCP

Un conector que le da a Claude acceso directo a bases de datos MySQL a través del Protocolo de Contexto del Modelo, permitiendo consultas en lenguaje natural, exploración de esquemas y gestión de bases de datos.

CoinMarketCap MCP Server

Real-time access to cryptocurrency data from the CoinMarketCap API.

Discord MCP Server

An MCP server for interacting with Discord.

GitHub

Permite la interacción con GitHub a través de la API de GitHub, admitiendo operaciones de archivos, gestión de repositorios, búsqueda avanzada y seguimiento de incidencias con un manejo integral de errores y creación automática de ramas.

Time MCP Server

A Model Context Protocol server that provides time and timezone conversion capabilities, enabling LLMs to get current time information and perform timezone conversions using IANA timezone names.

DeepSeek MCP Server

Okay, here's a basic outline and code snippet for a simple MCP (Minecraft Protocol) server in Go that redirects questions (chat messages) to Deepseek models. This is a simplified example and will require significant expansion to be a fully functional Minecraft server proxy. **Important Considerations:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex. This example only handles a tiny subset of it (chat messages). To build a robust proxy, you'll need to implement much more of the protocol. Libraries like `go-mc` (mentioned below) can help. * **Deepseek API:** You'll need an account and API key for Deepseek. This example assumes you have that and know how to use their API. Replace `"YOUR_DEEPSEEK_API_KEY"` with your actual key. * **Error Handling:** This example has minimal error handling. Real-world code needs robust error handling. * **Security:** This is a basic example and doesn't include any security measures. Be very careful when handling network traffic, especially from untrusted sources. * **Performance:** This example is not optimized for performance. Consider using goroutines and channels for concurrent processing of packets. * **Dependencies:** You'll need to install the `go-mc` library and a JSON library. **Conceptual Outline:** 1. **Listen for Minecraft Connections:** The server listens on a specific port (e.g., 25565) for incoming connections from Minecraft clients. 2. **Handle Handshake:** The server needs to handle the initial handshake packets from the client to establish a connection. 3. **Forward Packets (Mostly):** Most packets received from the client should be forwarded directly to the real Minecraft server. 4. **Intercept Chat Messages:** The server needs to identify chat message packets. 5. **Send to Deepseek:** Extract the chat message text and send it to the Deepseek API. 6. **Process Deepseek Response:** Receive the response from Deepseek. 7. **Send Response to Minecraft Client:** Format the Deepseek response as a Minecraft chat message and send it back to the client. 8. **Forward Other Packets:** Forward any other packets received from the real Minecraft server back to the client. **Go Code Snippet (Simplified):** ```go package main import ( "bufio" "encoding/json" "fmt" "io" "log" "net" "net/http" "strings" "github.com/Tnze/go-mc/net/packet" // Using go-mc for basic packet handling ) const ( listenAddress = "0.0.0.0:25565" // Address to listen on realServerAddress = "your.real.minecraft.server:25565" // Replace with your real server deepseekAPIEndpoint = "YOUR_DEEPSEEK_API_ENDPOINT" // Replace with Deepseek API endpoint deepseekAPIKey = "YOUR_DEEPSEEK_API_KEY" // Replace with your Deepseek API key ) func main() { listener, err := net.Listen("tcp", listenAddress) if err != nil { log.Fatalf("Failed to listen: %v", err) } defer listener.Close() fmt.Printf("Listening on %s\n", listenAddress) for { conn, err := listener.Accept() if err != nil { log.Printf("Failed to accept connection: %v", err) continue } go handleConnection(conn) } } func handleConnection(clientConn net.Conn) { defer clientConn.Close() realServerConn, err := net.Dial("tcp", realServerAddress) if err != nil { log.Printf("Failed to connect to real server: %v", err) return } defer realServerConn.Close() // Handle Handshake (Simplified - needs more complete implementation) // Read handshake packet from client var p packet.Packet err = p.ReadFrom(bufio.NewReader(clientConn)) if err != nil { log.Println("Error reading handshake:", err) return } // Forward handshake to real server _, err = p.WriteTo(realServerConn) if err != nil { log.Println("Error forwarding handshake:", err) return } // Example: Basic proxy loop. Needs significant improvement. go func() { proxy(clientConn, realServerConn) }() proxy(realServerConn, clientConn) } func proxy(src net.Conn, dst net.Conn) { buf := make([]byte, 4096) // Adjust buffer size as needed for { n, err := src.Read(buf) if err != nil { if err != io.EOF { log.Println("Read error:", err) } return } // **VERY SIMPLIFIED CHAT MESSAGE DETECTION** // This is a placeholder. You need to properly parse the Minecraft packet // to identify chat messages. Use go-mc's packet reading capabilities. message := string(buf[:n]) if strings.Contains(message, "say") { // Very basic check - IMPROVE THIS! // Extract the actual message (this is just a placeholder) question := strings.SplitN(message, "say", 2)[1] question = strings.TrimSpace(question) // Send to Deepseek deepseekResponse, err := askDeepseek(question) if err != nil { log.Println("Error asking Deepseek:", err) // Optionally, forward the original message to the real server _, err = dst.Write(buf[:n]) if err != nil { log.Println("Write error:", err) } continue } // Format Deepseek response as a Minecraft chat message minecraftMessage := fmt.Sprintf(`{"text":"Deepseek: %s"}`, deepseekResponse) // Send the Deepseek response back to the client _, err = dst.Write([]byte(minecraftMessage)) // This is WRONG - needs to be a proper Minecraft chat packet if err != nil { log.Println("Write error:", err) } } else { // Forward the packet to the destination _, err = dst.Write(buf[:n]) if err != nil { log.Println("Write error:", err) return } } } } func askDeepseek(question string) (string, error) { // Implement your Deepseek API call here. This is a placeholder. // You'll need to format the request according to the Deepseek API documentation. // Example using a placeholder API call (replace with your actual Deepseek code) payload := map[string]string{"question": question} jsonPayload, err := json.Marshal(payload) if err != nil { return "", err } req, err := http.NewRequest("POST", deepseekAPIEndpoint, strings.NewReader(string(jsonPayload))) if err != nil { return "", err } req.Header.Set("Content-Type", "application/json") req.Header.Set("Authorization", "Bearer "+deepseekAPIKey) // If Deepseek requires authorization client := &http.Client{} resp, err := client.Do(req) if err != nil { return "", err } defer resp.Body.Close() body, err := io.ReadAll(resp.Body) if err != nil { return "", err } // Parse the Deepseek response (assuming it's JSON) var response map[string]interface{} err = json.Unmarshal(body, &response) if err != nil { return "", err } // Extract the answer from the Deepseek response (adjust based on the actual response format) answer, ok := response["answer"].(string) if !ok { return "", fmt.Errorf("answer not found in Deepseek response") } return answer, nil } ``` **To use this code:** 1. **Install Dependencies:** ```bash go get github.com/Tnze/go-mc/net/packet ``` 2. **Replace Placeholders:** * `your.real.minecraft.server:25565` with the address of your actual Minecraft server. * `YOUR_DEEPSEEK_API_ENDPOINT` with the Deepseek API endpoint. * `YOUR_DEEPSEEK_API_KEY` with your Deepseek API key. 3. **Run the Server:** ```bash go run main.go ``` 4. **Connect with Minecraft:** Connect your Minecraft client to `localhost:25565`. **Key Improvements Needed:** * **Complete Minecraft Protocol Implementation:** Use `go-mc` to properly handle the handshake, packet encoding/decoding, and other protocol details. This is the most significant task. You'll need to understand the Minecraft protocol specification. * **Robust Chat Message Parsing:** Instead of the simple `strings.Contains`, use `go-mc` to parse the incoming packets and identify chat message packets correctly. Extract the message text from the packet data. * **Correct Minecraft Chat Packet Formatting:** The `dst.Write([]byte(minecraftMessage))` line is incorrect. You need to create a proper Minecraft chat packet using `go-mc` to send the Deepseek response back to the client. * **Error Handling:** Add comprehensive error handling throughout the code. * **Configuration:** Make the server configurable (e.g., listen address, real server address, Deepseek API key) through command-line arguments or a configuration file. * **Concurrency:** Use goroutines and channels to handle multiple client connections concurrently. * **Logging:** Implement proper logging for debugging and monitoring. * **Rate Limiting:** Implement rate limiting to prevent abuse of the Deepseek API. * **Authentication:** Consider adding authentication to prevent unauthorized access to the proxy. This is a starting point. Building a full Minecraft proxy is a complex project. Good luck!

@tailor-platform/tailor-mcp

La utilidad de línea de comandos tailorctl, con un enfoque en la funcionalidad del servidor MCP (Protocolo de Contexto del Modelo).

Ableton Copilot MCP

Un servidor de Protocolo de Contexto de Modelo que permite la interacción en tiempo real con Ableton Live, permitiendo a los asistentes de IA controlar la creación de canciones, la gestión de pistas, las operaciones de clips y los flujos de trabajo de grabación de audio.

SVG to PNG MCP Server

Un servidor de Protocolo de Contexto de Modelo que convierte código SVG a imágenes PNG, ofreciendo dos métodos de conversión (CairoSVG e Inkscape) con soporte para directorios de trabajo personalizados.

VictoriaMetrics-mcp-server

VictoriaMetrics-mcp-server

DexScreener API Access

Una implementación de servidor MCP que permite el acceso a datos de la API de DexScreener, proporcionando información en tiempo real sobre pares DEX, perfiles de tokens y estadísticas de mercado a través de múltiples blockchains.

Prospeo MCP Server

A Model Context Protocol server that integrates with Prospeo API to find work emails and enrich LinkedIn profiles.

100ms Raydium Sniper MCP

Permite el "token sniping" de alto rendimiento en Raydium DEX con soporte multi-región e integración con Claude AI, permitiendo a los usuarios monitorear y ejecutar compras de tokens a través de comandos en lenguaje natural.

MCP Google Server

Proporciona capacidades de búsqueda web utilizando la API de Búsqueda Personalizada de Google, permitiendo a los usuarios realizar búsquedas a través de un servidor de Protocolo de Contexto de Modelo.

🚀 Electron Debug MCP Server

🚀 Un potente servidor MCP para depurar aplicaciones Electron con una profunda integración del Protocolo de Herramientas para Desarrolladores de Chrome. Controla, supervisa y depura aplicaciones Electron a través de una API estandarizada.

Pokémcp

Un servidor de Protocolo de Contexto de Modelo que proporciona información de Pokémon conectándose a la PokeAPI, permitiendo a los usuarios consultar datos detallados de Pokémon, descubrir Pokémon aleatorios y encontrar Pokémon por región o tipo.

kubevirt-mcp-server

Un servidor de Protocolo de Contexto de Modelo simple para KubeVirt

FastAPI MCP OpenAPI

A FastAPI library that provides Model Context Protocol tools for endpoint introspection and OpenAPI documentation, allowing AI agents to discover and understand API endpoints.

Tailscale MCP Server

Provides seamless integration with Tailscale's CLI commands and REST API, enabling automated network management and monitoring through a standardized Model Context Protocol interface.

Facebook Ads Library MCP Server

Enables searching and analyzing Facebook's public ads library to see what companies are currently running, including ad images/text, video links, and campaign insights.

hh-jira-mcp-server

Un servidor de Protocolo de Contexto de Modelo que permite la integración con JIRA, permitiendo a los usuarios interactuar con tareas e incidencias de JIRA a través del asistente de IA Claude.

Up Bank MCP Server

An MCP wrapper for Up Bank's API that allows Claude and other MCP-enabled clients to manage accounts, transactions, categories, tags, and webhooks from Up Bank.