Discover Awesome MCP Servers

MCPJungle mcp gateway

MCPJungle is a self-hosted MCP Registry and Gateway suitable for both local and enterprise deployments. It provides a single URL for your MCP clients to access servers and a central platform for you to track your MCPs and client-server interactions.

Local File Management MCP Server

Enables file system operations such as listing, reading, and creating files within a scoped local project directory. It provides a secure way to manage local files through standardized MCP tools built with FastMCP.

MCP-Airflow-API

Monitor and manage Apache Airflow clusters through natural language queries via MCP tools: DAG inspection, task monitoring, health checks, and cluster analytics without API complexity. * Guide: https://call518.medium.com/mcp-airflow-api-a-model-context-protocol-mcp-server-for-apache-airflow-5dfdfb2

Todoist MCP Server

Enables AI assistants to manage Todoist tasks, projects, sections, labels, and comments through natural language conversations, providing complete control over your productivity workflow via the Todoist API.

Shared Knowledge MCP Server

Este servidor permite que assistentes de IA (CLINE, Cursor, Windsurf, Claude Desktop) compartilhem uma base de conhecimento comum através da Geração Aumentada por Recuperação (RAG), fornecendo acesso consistente à informação em várias ferramentas.

Chrome DevTools MCP

Enables AI coding assistants to control and inspect a live Chrome browser for automation, debugging, performance analysis, network monitoring, and DOM interaction through Chrome DevTools Protocol.

Splunk MCP Server by CData

Splunk MCP Server by CData

MCP Mac Apps Server

Enables control of macOS applications through natural language, allowing users to launch apps, execute AppleScript commands, manage running applications, and open files with voice or text commands.

DiagramMCP

Enables the dynamic generation of various software development diagrams, such as flowcharts, sequence diagrams, and architecture diagrams, using Mermaid syntax. It includes tools for diagram validation and provides instructions for exporting results to multiple formats including SVG and PNG.

RL-MCP

A Model Context Protocol server that provides AI models with structured access to external data and services, acting as a bridge between AI assistants and applications, databases, and APIs in a standardized, secure way.

SalesHandy MCP Server

Enables integration with SalesHandy API to manage email campaigns, templates, and contacts through natural language commands.

VictoriaMetrics-mcp-server

VictoriaMetrics-mcp-server

News Aggregator API

A modular, scalable news aggregation backend that provides a unified interface to TheNewsAPI for retrieving current and historical news articles with advanced filtering capabilities, designed specifically for consumption by AI agents.

DexScreener API Access

Uma implementação de servidor MCP que permite o acesso a dados da API DexScreener, fornecendo informações em tempo real sobre pares DEX, perfis de tokens e estatísticas de mercado em várias 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 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.

Weather MCP Server

Provides access to US National Weather Service data including active alerts by state and short-term forecasts for specific coordinates.

Brave Search MCP Server

Enables web searching and local business discovery through the Brave Search API. Provides both general web search with pagination and filtering controls, plus local business search with automatic fallback to web results.

MySQL查询服务器

Espelho de

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.

Italian Cities MCP Server

Provides CRUD tools for managing a database of Italian cities backed by Elasticsearch. It enables AI assistants to search, create, update, and delete city records through a standardized Model Context Protocol interface.

4o-mini-search-mcp

An MCP server that enables AI models to search the web using OpenAI's 4o-mini Search model, allowing access to up-to-date information for just a few cents per search.

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.

ipybox

A Python code execution sandbox based on IPython and Docker. Stateful code execution, file transfer between host and container, configurable network access.

Sage Intacct MCP Server by CData

Sage Intacct MCP Server by CData

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!

symbols-mcp

Read, inspect and navigate codebase symbols by connecting to a Language Server

@tailor-platform/tailor-mcp

A ferramenta de linha de comando tailorctl, com foco na funcionalidade do servidor MCP (Model Context Protocol).