Discover Awesome MCP Servers

ProtonMail Pro MCP

Enables comprehensive ProtonMail management through SMTP and IMAP, supporting email sending/reading, folder operations, analytics, and contact tracking with advanced search and automation capabilities.

VictoriaMetrics-mcp-server

VictoriaMetrics-mcp-server

MCP MySQL Server

Enables Claude Desktop to interact with MySQL databases through secure query execution, schema discovery, and multi-database support with configurable read/write permissions and built-in SQL injection protection.

Kubernetes MCP Server

Enables comprehensive Kubernetes cluster management through kubectl operations and Helm chart management. Supports resource operations, logging, scaling, rollouts, and diagnostics with multiple transport modes and security features.

Crypto Price & Market Analysis MCP Server

Provides comprehensive cryptocurrency analysis using the CoinCap API, offering real-time price data, market analysis across exchanges, and historical price trends for any cryptocurrency.

float-mcp

A community MCP server for float.com.

DeepSeek MCP Server

Okay, here's a basic outline and code snippet for a simple MCP (Minecraft Protocol) server in Go that redirects questions to Deepseek models. This is a starting point and will require significant expansion to be fully functional. **Important Considerations:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex. This example handles a very basic handshake and chat message. You'll need to implement more of the protocol to handle player connections, world data, etc. Libraries like `go-mc` can help. * **Deepseek API Integration:** You'll need to obtain an API key from Deepseek and integrate their API into the `handleChatMessage` function. The example uses a placeholder. * **Error Handling:** The code includes basic error handling, but you should add more robust error handling and logging. * **Security:** This is a very basic example and doesn't include any security measures. You should add appropriate security measures, such as authentication and authorization, before deploying this server. * **Performance:** Consider using goroutines and channels to handle multiple connections concurrently. * **Dependencies:** You'll need to install the `go-mc` library. **Code (main.go):** ```go package main import ( "bufio" "encoding/json" "fmt" "log" "net" "os" "strings" "github.com/Tnze/go-mc/net/packet" ) const ( serverAddress = "0.0.0.0:25565" // Listen on all interfaces, port 25565 deepseekAPIEndpoint = "YOUR_DEEPSEEK_API_ENDPOINT" // Replace with your Deepseek API endpoint deepseekAPIKey = "YOUR_DEEPSEEK_API_KEY" // Replace with your Deepseek API key ) func main() { listener, err := net.Listen("tcp", serverAddress) if err != nil { log.Fatalf("Failed to listen: %v", err) } defer listener.Close() fmt.Printf("Server listening on %s\n", serverAddress) for { conn, err := listener.Accept() if err != nil { log.Printf("Failed to accept connection: %v", err) continue } go handleConnection(conn) } } func handleConnection(conn net.Conn) { defer conn.Close() fmt.Printf("Accepted connection from %s\n", conn.RemoteAddr()) // Handle Handshake and Status (very basic) if err := handleHandshake(conn); err != nil { log.Printf("Handshake error: %v", err) return } // Main loop to read messages reader := bufio.NewReader(conn) for { message, err := reader.ReadString('\n') if err != nil { log.Printf("Error reading message: %v", err) return } message = strings.TrimSpace(message) if message == "" { continue // Ignore empty messages } fmt.Printf("Received message: %s\n", message) response, err := handleChatMessage(message) if err != nil { log.Printf("Error processing message: %v", err) response = "Error processing your request." } // Send the response back to the client _, err = conn.Write([]byte(response + "\n")) // Minecraft uses \n as a delimiter if err != nil { log.Printf("Error sending response: %v", err) return } } } func handleHandshake(conn net.Conn) error { // Read the handshake packet var p packet.Packet if _, err := p.ReadFrom(conn); err != nil { return fmt.Errorf("read handshake packet: %w", err) } var protocolVersion int32 var serverAddress string var serverPort uint16 var nextState int32 if err := p.Scan( &protocolVersion, &serverAddress, &serverPort, &nextState, ); err != nil { return fmt.Errorf("scan handshake packet: %w", err) } fmt.Printf("Protocol Version: %d, Server Address: %s, Server Port: %d, Next State: %d\n", protocolVersion, serverAddress, serverPort, nextState) // You might want to validate the protocol version here // Respond to the client based on the next state switch nextState { case 1: // Status // Respond with server status (e.g., player count, MOTD) statusResponse := `{ "version": { "name": "Go-Deepseek-Bridge", "protocol": 757 }, "players": { "max": 100, "online": 0, "sample": [] }, "description": { "text": "A Minecraft server powered by Deepseek!" } }` // Write the length of the JSON string as a VarInt var statusPacket packet.Packet statusPacket.ID = 0x00 // Status Response packet ID statusPacket.Data = []byte(statusResponse) if _, err := statusPacket.WriteTo(conn); err != nil { return fmt.Errorf("write status response: %w", err) } // Handle Ping if _, err := p.ReadFrom(conn); err != nil { return fmt.Errorf("read ping packet: %w", err) } var payload int64 if err := p.Scan(&payload); err != nil { return fmt.Errorf("scan ping packet: %w", err) } // Respond with the same payload var pongPacket packet.Packet pongPacket.ID = 0x01 // Pong packet ID pongPacket.Data = packet.Pack(payload) if _, err := pongPacket.WriteTo(conn); err != nil { return fmt.Errorf("write pong response: %w", err) } return nil case 2: // Login // Handle login process (e.g., authentication) // For simplicity, we'll just accept the connection var loginStartPacket packet.Packet if _, err := loginStartPacket.ReadFrom(conn); err != nil { return fmt.Errorf("read login start packet: %w", err) } var username string if err := loginStartPacket.Scan(&username); err != nil { return fmt.Errorf("scan login start packet: %w", err) } fmt.Printf("Player %s is trying to log in\n", username) // Send Login Success packet loginSuccess := map[string]interface{}{ "uuid": "00000000-0000-0000-0000-000000000000", // Dummy UUID "username": username, } loginSuccessJSON, err := json.Marshal(loginSuccess) if err != nil { return fmt.Errorf("marshal login success json: %w", err) } var loginSuccessPacket packet.Packet loginSuccessPacket.ID = 0x02 // Login Success packet ID loginSuccessPacket.Data = loginSuccessJSON if _, err := loginSuccessPacket.WriteTo(conn); err != nil { return fmt.Errorf("write login success packet: %w", err) } return nil default: return fmt.Errorf("unknown next state: %d", nextState) } } func handleChatMessage(message string) (string, error) { // **Replace this with your Deepseek API call** // Example: // response, err := callDeepseekAPI(message) // if err != nil { // return "", err // } // return response, nil // Placeholder response return fmt.Sprintf("Deepseek says: You asked: %s", message), nil } // Placeholder for Deepseek API call func callDeepseekAPI(message string) (string, error) { // Implement your Deepseek API call here // Use the deepseekAPIEndpoint and deepseekAPIKey constants // Example using os.Getenv (for API key security): // apiKey := os.Getenv("DEEPSEEK_API_KEY") // if apiKey == "" { // return "", fmt.Errorf("DEEPSEEK_API_KEY environment variable not set") // } // This is just a placeholder. You'll need to use an HTTP client // (e.g., net/http) to make a request to the Deepseek API. return fmt.Sprintf("Deepseek API (placeholder) says: Processing: %s", message), nil } ``` **To run this code:** 1. **Install Go:** Make sure you have Go installed. 2. **Install go-mc:** `go get github.com/Tnze/go-mc/net/packet` 3. **Replace Placeholders:** Fill in the `deepseekAPIEndpoint` and `deepseekAPIKey` constants with your actual Deepseek API credentials. **Do not commit your API key directly to your code repository!** Use environment variables or a configuration file. 4. **Run the server:** `go run main.go` 5. **Connect with Minecraft:** Start your Minecraft client and connect to `localhost:25565`. **Explanation:** 1. **`main` Function:** * Sets up a TCP listener on port 25565. * Accepts incoming connections in a loop. * Spawns a goroutine for each connection to handle it concurrently. 2. **`handleConnection` Function:** * Handles a single client connection. * Reads messages from the client. * Calls `handleChatMessage` to process the message and get a response from Deepseek (placeholder). * Sends the response back to the client. 3. **`handleHandshake` Function:** * Handles the initial handshake process of the Minecraft protocol. * Reads the handshake packet. * Parses the protocol version, server address, port, and next state. * Responds to the client based on the next state: * **Status (1):** Sends a server status response (MOTD, player count). * **Login (2):** Handles the login process (very basic, just accepts the connection). 4. **`handleChatMessage` Function:** * This is where you'll integrate with the Deepseek API. * Currently, it's a placeholder that simply returns a message indicating that Deepseek is processing the request. * **You need to replace this with your actual Deepseek API call.** 5. **`callDeepseekAPI` Function:** * A placeholder function that shows where you would make the HTTP request to the Deepseek API. * **You need to implement the actual API call here.** Use the `net/http` package to make the request. Remember to handle errors and parse the JSON response from Deepseek. **Next Steps:** 1. **Implement Deepseek API Integration:** Replace the placeholder in `handleChatMessage` and `callDeepseekAPI` with your actual Deepseek API call. Use the `net/http` package to make the request, handle errors, and parse the JSON response. 2. **Implement More of the Minecraft Protocol:** This example only handles a very basic handshake and chat message. You'll need to implement more of the protocol to handle player movement, world data, etc. Consider using a library like `go-mc` to simplify this. 3. **Error Handling:** Add more robust error handling and logging. 4. **Security:** Add appropriate security measures, such as authentication and authorization. 5. **Configuration:** Use environment variables or a configuration file to store sensitive information like API keys. 6. **Concurrency:** Use goroutines and channels to handle multiple connections concurrently. 7. **Testing:** Thoroughly test your server with a Minecraft client. **Example Deepseek API Call (Conceptual):** ```go import ( "bytes" "encoding/json" "fmt" "net/http" "os" ) func callDeepseekAPI(message string) (string, error) { apiKey := os.Getenv("DEEPSEEK_API_KEY") if apiKey == "" { return "", fmt.Errorf("DEEPSEEK_API_KEY environment variable not set") } requestBody, err := json.Marshal(map[string]string{ "prompt": message, }) if err != nil { return "", fmt.Errorf("marshal request body: %w", err) } req, err := http.NewRequest("POST", deepseekAPIEndpoint, bytes.NewBuffer(requestBody)) if err != nil { return "", fmt.Errorf("create request: %w", err) } req.Header.Set("Content-Type", "application/json") req.Header.Set("Authorization", "Bearer "+apiKey) // Or however Deepseek requires authentication client := &http.Client{} resp, err := client.Do(req) if err != nil { return "", fmt.Errorf("do request: %w", err) } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { return "", fmt.Errorf("deepseek api returned status: %s", resp.Status) } var responseData map[string]interface{} err = json.NewDecoder(resp.Body).Decode(&responseData) if err != nil { return "", fmt.Errorf("decode response body: %w", err) } // Assuming Deepseek returns the response in a field called "text" or similar responseText, ok := responseData["text"].(string) // Adjust based on Deepseek's response format if !ok { return "", fmt.Errorf("response format incorrect, 'text' field not found or not a string") } return responseText, nil } ``` **Important Notes about the Deepseek API Call:** * **Authentication:** The example assumes a Bearer token for authentication. Check the Deepseek API documentation for the correct authentication method. * **Request Body:** The example sends a JSON request with a "prompt" field. Adjust the request body to match the Deepseek API's requirements. * **Response Parsing:** The example assumes the Deepseek API returns the response in a field called "text". Adjust the response parsing to match the Deepseek API's response format. * **Error Handling:** The example includes basic error handling, but you should add more robust error handling. * **Rate Limiting:** Be aware of Deepseek's API rate limits and implement appropriate rate limiting in your code. This comprehensive response provides a solid foundation for building your Minecraft server with Deepseek integration. Remember to consult the Deepseek API documentation and the `go-mc` library documentation for more details. Good luck!

🚀 Electron Debug MCP Server

🚀 Um servidor MCP poderoso para depurar aplicações Electron com profunda integração ao Protocolo Chrome DevTools. Controle, monitore e depure aplicativos Electron através de uma API padronizada.

Ableton Copilot MCP

Um servidor de Protocolo de Contexto de Modelo que permite a interação em tempo real com o Ableton Live, permitindo que assistentes de IA controlem a criação de músicas, o gerenciamento de faixas, as operações de clipes e os fluxos de trabalho de gravação de áudio.

Vercel MCP Server

A Model Control Protocol server template deployed on Vercel that demonstrates MCP implementation with a dice rolling tool, serving as a foundation for building custom MCP servers.

ClickUp MCP Server

Enables integration with ClickUp's task management platform, allowing users to retrieve, create, update, and manage tasks and lists through the Model Context Protocol.

AutoGen MCP Server

Um servidor MCP que oferece integração com o framework AutoGen da Microsoft, permitindo conversas multiagente através de uma interface padronizada.

Brave Search With Proxy

Brave Search With Proxy

DALL-E MCP Server

An MCP (Model Context Protocol) server that allows generating, editing, and creating variations of images using OpenAI's DALL-E APIs.

OmniDocs MCP

An intelligent MCP server that enables AI agents to crawl, index, and semantically search official framework documentation using local RAG. It prevents hallucinations by providing precise, up-to-date documentation excerpts directly into the AI's context window.

Google Workspace MCP Server

Um servidor de Protocolo de Contexto de Modelo que fornece ferramentas para interagir com as APIs do Gmail e do Google Agenda, permitindo o gerenciamento programático de e-mails e eventos de calendário.

auto-mcp

Converter automaticamente funções, ferramentas e agentes para servidores MCP.

MCP Gateway

Aggregates multiple Model Context Protocol servers into a single gateway to provide unified search, description, and execution of tools. It reduces context limit issues by dynamically fetching specific tool schemas only when needed rather than loading all available tools at once.

test-server

just a test of glama

MCP Financial Datasets Server

Provides backtesting-compliant financial data including company financials, historical stock and crypto prices, and news with sentiment analysis from financialdatasets.ai API.

Grimoire

Provides D\&D 5e spell information through search and filtering tools. Access detailed spell data, class-specific spell lists, and spell school references powered by the D\&D 5e API.

TypeScript MCP Sample Server

A sample MCP server implementation in TypeScript that demonstrates tool creation with a mock AI completion endpoint. Provides a basic example for developers to learn MCP server development patterns and tool registration.

MCP Mix Server

A tutorial implementation MCP server that enables analysis of CSV and Parquet files. Allows users to summarize data and query file information through natural language interactions.

crabsmadethis/d2r-horadric-tools

Diablo II Resurrected modding toolkit — character builder, mod build/deploy pipeline, save inspector, CASC reader, and MCP server for Claude/Codex/AI integration. Linux/Steam Deck.

T1D Manager

Enables Type 1 diabetes patients and caregivers to monitor real-time blood glucose from Dexcom Share, calculate insulin doses, and receive empathetic AI-powered sick day care guidance through natural language interactions.

Cryptocurrency Market Data Server

Fornece dados do mercado de criptomoedas em tempo real e históricos através da integração com as principais bolsas. Este servidor permite que LLMs como o Claude busquem preços atuais, analisem tendências de mercado e acessem informações detalhadas de negociação.

MongoDB Mongoose MCP

Enables Claude to interact with MongoDB databases through natural language, supporting queries, aggregations, CRUD operations, and index management with optional Mongoose schema validation.

Superface MCP Server

Fornece acesso a várias ferramentas de IA através do Protocolo de Contexto de Modelo, permitindo que usuários do Claude Desktop integrem e usem as capacidades do Superface via API.

RyanNg

Cipher is an opensource memory layer specifically designed for coding agents. Compatible with Cursor, Windsurf, Claude Desktop, Claude Code, Gemini CLI, AWS's Kiro, VS Code, and Roo Code through MCP, and coding agents, such as Kimi K2.