Discover Awesome MCP Servers

Remote MCP Server on Cloudflare

Espelho de

GitHub

Permite a interação com o GitHub através da API do GitHub, suportando operações de arquivos, gerenciamento de repositórios, pesquisa avançada e rastreamento de issues com tratamento de erros abrangente e criação automática de branches.

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.

py-ue5-mcp-server

an ue5 mcp server that allows the user to access functions in blueprint actors

Schwab Model Context Protocol Server

Um servidor que implementa o Protocolo de Contexto de Modelo para a API da Schwab, permitindo o acesso a informações da conta, posições, cotações de ações e histórico de ordens/transações, projetado para integração com Grandes Modelos de Linguagem.

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.

MCP VectorStore Server

Provides advanced document search and processing capabilities through vector stores, including PDF processing, semantic search, web search integration, and file operations. Enables users to create searchable document collections and retrieve relevant information using natural language queries.

agentek-eth

Um servidor MCP que oferece ferramentas para pesquisa de criptomoedas e automação baseada em Ethereum.

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.

Magento 2 MCP Server

A Model Context Protocol server that connects to a Magento 2 REST API, allowing Claude and other MCP clients to query product information, customer data, and order statistics from a Magento store.

Carbon Voice

Access your Carbon Voice conversations and voice memos—retrieving messages, conversations, voice memos, and more as well as send messages to Carbon Voice users.

CoinMarketCap MCP Server

Acesso em tempo real a dados de criptomoedas da API CoinMarketCap.

🚀 MCP Gemini Search

Protocolo de Contexto de Modelo (MCP) com Gemini 2.5 Pro. Converter consultas conversacionais em pesquisas de voo usando as capacidades de chamada de função do Gemini e as ferramentas de pesquisa de voo do MCP.

Tiptap Collaboration MCP Server

Enables interaction with Tiptap collaborative document services through comprehensive document management, real-time statistics, markdown conversion, and batch operations. Supports creating, updating, searching, and managing collaborative documents with health monitoring and semantic search capabilities.

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.

MCP Chat

A server that enables users to chat with each other by repurposing the Model Context Protocol (MCP), designed for AI tool calls, into a human-to-human communication system.

Brave Search With Proxy

Brave Search With Proxy

MCP Google Server

Fornece capacidades de pesquisa na web usando a API Google Custom Search, permitindo que os usuários realizem pesquisas através de um servidor Model Context Protocol.

auto-mcp

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

TIDAL MCP: My Custom Picks

An MCP server that enables highly personalized music recommendations from TIDAL based on custom criteria, allowing users to create and manage playlists directly in their TIDAL account.

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.

InstantDB MCP Server

Fornece uma interface somente leitura para consultar dados do InstantDB com ferramentas para executar consultas e recuperar exemplos com base em padrões predefinidos.

Axiom MCP Server

Uma porta compatível com npx de @Axiom's mcp-server-axiom

MySQL-MCP

Um conector que dá ao Claude acesso direto a bancos de dados MySQL através do Protocolo de Contexto do Modelo, permitindo consultas em linguagem natural, exploração de esquemas e gerenciamento de banco de dados.

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.