Discover Awesome MCP Servers

duck-duck-scrape-mcp

Um servidor MCP para resultados de pesquisa (grátis!) via DuckDuckGo.

test-my-mcpserver

teste

Windows MCP

A lightweight open-source server that enables AI agents to interact with the Windows operating system, allowing for file navigation, application control, UI interaction, and QA testing without requiring computer vision.

fengchong-demo

Demonstração Fengchong

MCP Rewatch

A Model Context Protocol server that enables AI coding assistants like Claude Code to manage long-running development processes, solving the problem where Claude Code cannot see output from processes like 'npm run dev' that don't exit immediately.

Clo MCP Plugin

O Clo MCP Plugin é um aplicativo C++ construído com o SDK Clo3D. Ele estabelece um servidor de socket dentro do Clo3D, permitindo que Modelos de Linguagem Grandes (LLMs) interajam e controlem o Clo3D através do Protocolo de Contexto do Modelo (MCP) para design de moda e criação de cenas avançados assistidos por IA.

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.

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.

TFT MCP Server

Este servidor permite que Claude acesse dados do jogo Teamfight Tactics (TFT), permitindo que os usuários recuperem históricos de partidas e informações detalhadas das partidas através da API da Riot Games.

Monad MCP Server

Enables interaction with the Monad testnet to check balances, examine transaction details, get gas prices, and retrieve block information.

Dynamics 365 MCP Server by CData

Dynamics 365 MCP Server by CData

DeepClaude MCP Server

This server integrates DeepSeek and Claude AI models to provide enhanced AI responses, featuring a RESTful API, configurable parameters, and robust error handling.

MySQL MCP Server

An MCP server that allows working with MySQL databases by providing tools for executing read-only SQL queries, getting table schemas, and listing database tables.

Remote MCP Server on Cloudflare

Espelho de

Sola MCP Server

A stateless HTTP server implementing the Model Context Protocol (MCP) that enables applications to interact with Social Layer platform data including events, groups, profiles, and venues via standardized endpoints.

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.

Pokémcp

Um servidor de Protocolo de Contexto de Modelo que fornece informações sobre Pokémon conectando-se à PokeAPI, permitindo que os usuários consultem dados detalhados de Pokémon, descubram Pokémon aleatórios e encontrem Pokémon por região ou tipo.

kubevirt-mcp-server

Um servidor de Protocolo de Contexto de Modelo simples 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.

VictoriaMetrics-mcp-server

VictoriaMetrics-mcp-server

100ms Raydium Sniper MCP

Permite a execução de "token sniping" de alto desempenho na Raydium DEX com suporte multi-região e integração com Claude AI, permitindo que os usuários monitorem e executem compras de tokens através de comandos em linguagem natural.

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.

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.