Discover Awesome MCP Servers

ci-triage-mcp

Exposes a Ci-mvp security-triage pipeline as chat tools for Claude Desktop, enabling on-demand queries of Trivy/Semgrep scan results stored in S3.

PyPI Package MCP Server

Enables AI assistants to fetch, explore, and analyze source code from any Python package on PyPI, including listing files, reading specific code, and searching packages across all published versions.

Dynamics 365 MCP Server by CData

Dynamics 365 MCP Server by CData

mcp-plots

A MCP server for data visualization. It exposes tools to render charts (line, bar, pie, scatter, heatmap, etc.) from data and returns plots as either image/text/mermaid diagram.

bizdays

Provides deterministic business-day calculations for AI agents, correctly handling country-specific weekends and public holidays.

@leonardocrdso/clean-code-mcp

An MCP server that provides 63 Clean Code principles for AI-assisted code review and development.

material-icons-agent-skill

Enables AI agents to search, import, migrate, validate, and maintain official Google Material Symbols across various platforms and IDEs.

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!

🚀 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.

Forgejo MCP Server

A Model Context Protocol (MCP) server that provides Claude Desktop with tools to interact with Forgejo repositories, including listing repos, issues, and reading files.

Word of the Day MCP Server

Provides comprehensive word definitions, pronunciations, meanings, and examples for any English word using the Free Dictionary API. Includes a random word-of-the-day feature with difficulty levels for vocabulary building.

Claude Rules MCP Server

Serves 484 Claude Code skills and 17 global rules as MCP tools, enabling skill and rule retrieval, keyword search, and project-level rule discovery for any Claude client.

Demo

A Python MCP server for Cline integration, providing tools for file analysis and other tasks. Supports switching to Google Gemini API.

Gemini Embedding 2 MCP Server

A multimodal local memory MCP server that lets AI agents search across text, PDFs, images, audio, and video using Gemini Embedding 2 and a local ChromaDB.

MoA MCP Server

Enables users to leverage a mixture-of-agents architecture where multiple AI models discuss a question in parallel and a president model synthesizes the best answer.

Bonsai MCP

Connects MCP clients to a local Blender + Bonsai (BlenderBIM) session for scene inspection, IFC project querying, viewport screenshots, and executing Python code in Blender.

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.

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.

Remote MCP Server on Cloudflare

Espejo de

Node Terminal MCP

Enables AI agents to interact with terminal environments through multiple concurrent PTY sessions. Supports cross-platform terminal operations including command execution, session management, and real-time communication.

MCP ComfyUI Flux

Enables AI image generation using FLUX models through ComfyUI with GPU acceleration, supporting image generation, 4x upscaling, and background removal with optimized Docker deployment.

Codex SSH Terminal MCP

Agent-native SSH control plane with a local Web Terminal, human-in-the-loop secret input, keychain-backed profiles, and user-confirmed uploads for Codex, Claude Code, and MCP-compatible coding agents.

brand-gen

A memory-backed brand generation runtime for agent-led creative iteration. Enables AI agents to plan, generate, review, and improve brand materials with persistent brand memory and structured workflows.

SofaScore MCP

An MCP server that answers football questions with interactive widgets, centered on the 2026 FIFA World Cup using SofaScore API data.

Gemini Flash Image MCP Server

Enables text-to-image generation, image editing, and multi-image composition using Google's Gemini 2.5 Flash Image API. Supports flexible aspect ratios and character consistency across generations.

MiniMax Unified MCP

Unifies MiniMax's multimodal generation, web search, image understanding, audio, video, and music tools into a single MCP server for use with Claude and other clients.

Remote MCP Server on Cloudflare

Enables deployment of a remote MCP server on Cloudflare Workers without authentication, allowing custom tools and integration with clients like Claude Desktop.

Asana MCP Server Extended

A Model Context Protocol (MCP) server that provides comprehensive Asana integration, enabling AI assistants like Claude to interact with Asana workspaces, projects, tasks, goals, portfolios, and more.

MadeOnSol

Real-time Solana trading intelligence: track 1,069 KOL wallets with <3s latency, score 23,000+ Pump.fun deployers, surface deshred deploy signals ~500ms before on-chain confirmation, detect multi-KOL coordination, and stream every DEX trade across 9+ programs.