Discover Awesome MCP Servers

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

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.

SVG to PNG MCP Server

Um servidor de Protocolo de Contexto de Modelo que converte código SVG em imagens PNG, oferecendo dois métodos de conversão (CairoSVG e Inkscape) com suporte para diretórios de trabalho personalizados.

Setup Agent MCP

Enables AI assistants to automatically analyze GitHub repositories and set up development environments by detecting tech stacks, installing dependencies, and verifying project builds. Provides safe tools for repository cloning, file system operations, package installation, and build verification through an allowlisted command system.

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.

Storybook MCP Server

A Model Context Protocol server that integrates with Storybook to help AI tools query UI components and retrieve usage examples from static Storybook files.

Ansible MCP Server

This Model Context Protocol server enables AI assistants to interact directly with Ansible, allowing them to execute playbooks, manage inventory, check syntax, and perform other Ansible operations.

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.

MCP Server for EAI Services

Implements a Multi-Channel Platform Server that integrates with existing Enterprise Application Integration services, providing tools and endpoints to securely fetch network reports and access management features.

azure-devops-mcp

Here's a breakdown of what "Azure DevOps MCP C# server and client code" likely refers to, along with explanations and examples. It's important to understand that "MCP" (Microsoft Certified Professional) is a broad term, and Azure DevOps is a complex system. Therefore, I'll provide a general overview and then suggest how to narrow down your search for more specific code examples. **Understanding the Terms** * **Azure DevOps:** A suite of services from Microsoft that covers the entire software development lifecycle. Key components include: * **Azure Boards:** Work item tracking (tasks, bugs, user stories). * **Azure Repos:** Source code management (Git). * **Azure Pipelines:** Continuous integration and continuous delivery (CI/CD). * **Azure Test Plans:** Test management. * **Azure Artifacts:** Package management (NuGet, npm, Maven, etc.). * **MCP (Microsoft Certified Professional):** A general term for someone who has passed a Microsoft certification exam. It doesn't directly imply specific code skills. It *suggests* the person has a certain level of understanding of Microsoft technologies. * **C#:** A modern, object-oriented programming language widely used for developing applications on the .NET platform. * **Server Code:** Code that runs on a server (e.g., a web server, an application server, an Azure Function). In the context of Azure DevOps, this might be code that interacts with the Azure DevOps REST API or handles webhooks. * **Client Code:** Code that runs on a client device (e.g., a web browser, a desktop application, a mobile app). This code typically interacts with a server to retrieve data or perform actions. In the context of Azure DevOps, this might be a web application that displays work items or a command-line tool that automates tasks. **What "Azure DevOps MCP C# server and client code" Likely Means** Someone with an MCP certification who is proficient in C# might write code to: 1. **Interact with the Azure DevOps REST API:** This is the most common scenario. The Azure DevOps REST API allows you to programmatically access and manage almost everything in Azure DevOps. 2. **Create Azure DevOps Extensions:** You can extend the functionality of Azure DevOps by creating extensions that add new features to the web interface or integrate with other services. 3. **Build Custom Build/Release Tasks:** You can create custom tasks for Azure Pipelines to automate specific steps in your CI/CD process. 4. **Develop Integrations with Other Systems:** You might write code to integrate Azure DevOps with other tools, such as Slack, Microsoft Teams, or Jira. 5. **Automate Azure DevOps Administration:** You can use the REST API to automate tasks such as creating projects, managing users, and configuring permissions. **General Examples (Illustrative)** These are simplified examples to give you an idea. Real-world code would be more complex and handle error conditions, authentication, and other details. **1. Server-Side C# Code (Azure Function) to Get Work Items:** ```csharp using System; using System.IO; using System.Threading.Tasks; using Microsoft.AspNetCore.Mvc; using Microsoft.Azure.WebJobs; using Microsoft.Azure.WebJobs.Extensions.Http; using Microsoft.AspNetCore.Http; using Microsoft.Extensions.Logging; using Newtonsoft.Json; using System.Net.Http; using System.Net.Http.Headers; public static class GetWorkItems { [FunctionName("GetWorkItems")] public static async Task<IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req, ILogger log) { log.LogInformation("C# HTTP trigger function processed a request."); string organization = "your-organization"; // Replace with your Azure DevOps organization string project = "your-project"; // Replace with your Azure DevOps project string pat = "your-personal-access-token"; // Replace with your PAT string requestUrl = $"https://dev.azure.com/{organization}/{project}/_apis/wit/workitems?api-version=7.0"; using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(System.Text.ASCIIEncoding.ASCII.GetBytes($":{pat}"))); using (HttpResponseMessage response = await client.GetAsync(requestUrl)) { response.EnsureSuccessStatusCode(); // Throw exception if not successful string responseBody = await response.Content.ReadAsStringAsync(); // Deserialize the JSON response into a C# object (you'll need to define a class to represent the work item structure) // Example: // var workItems = JsonConvert.DeserializeObject<WorkItem[]>(responseBody); return new OkObjectResult(responseBody); // Return the JSON response } } } } ``` **Explanation:** * This is an Azure Function triggered by an HTTP request. * It uses the `HttpClient` class to make a GET request to the Azure DevOps REST API. * It uses a Personal Access Token (PAT) for authentication. **Important:** Never hardcode PATs in production code. Use environment variables or Azure Key Vault. * It retrieves work items from a specified organization and project. * It deserializes the JSON response (you'll need to define a `WorkItem` class to match the structure of the JSON). * It returns the JSON response as an `OkObjectResult`. **2. Client-Side C# Code (Console Application) to Create a Work Item:** ```csharp using System; using System.Net.Http; using System.Net.Http.Headers; using System.Text; using System.Threading.Tasks; using Newtonsoft.Json; public class Program { public static async Task Main(string[] args) { string organization = "your-organization"; // Replace with your Azure DevOps organization string project = "your-project"; // Replace with your Azure DevOps project string pat = "your-personal-access-token"; // Replace with your PAT string requestUrl = $"https://dev.azure.com/{organization}/{project}/_apis/wit/workitems/$Task?api-version=7.0"; using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(System.Text.ASCIIEncoding.ASCII.GetBytes($":{pat}"))); // Define the work item fields var workItem = new[] { new { op = "add", path = "/fields/System.Title", value = "My New Task" }, new { op = "add", path = "/fields/System.Description", value = "This is a description of the task." } }; string jsonContent = JsonConvert.SerializeObject(workItem); var content = new StringContent(jsonContent, Encoding.UTF8, "application/json-patch+json"); using (HttpResponseMessage response = await client.PatchAsync(requestUrl, content)) { response.EnsureSuccessStatusCode(); string responseBody = await response.Content.ReadAsStringAsync(); Console.WriteLine(responseBody); // Print the response (e.g., the created work item) } } } } ``` **Explanation:** * This is a console application. * It uses the `HttpClient` class to make a PATCH request to the Azure DevOps REST API (PATCH is used for creating or updating work items). * It uses a Personal Access Token (PAT) for authentication. * It defines the fields for the new work item (title and description). * It serializes the work item data into JSON. * It sends the JSON data in the request body. * It prints the response from the server (which will typically include the ID of the newly created work item). **Important Considerations:** * **Authentication:** Using Personal Access Tokens (PATs) is common for development and testing, but for production applications, you should use more secure authentication methods, such as Azure Active Directory (Azure AD) or Managed Identities. * **Error Handling:** The examples above lack robust error handling. You should always include `try-catch` blocks to handle exceptions and log errors. * **JSON Serialization/Deserialization:** Use a library like `Newtonsoft.Json` (Json.NET) or `System.Text.Json` to serialize and deserialize JSON data. Define C# classes that match the structure of the JSON data you're working with. * **NuGet Packages:** You'll need to install the `Newtonsoft.Json` NuGet package (or `System.Text.Json`) in your C# projects. * **API Versions:** The Azure DevOps REST API is versioned. Make sure you're using a supported API version (e.g., `api-version=7.0`). * **Rate Limiting:** Be aware of Azure DevOps rate limits. Implement retry logic to handle rate limiting errors. * **Security:** Never store sensitive information (like PATs) directly in your code. Use environment variables, Azure Key Vault, or other secure storage mechanisms. **How to Find More Specific Code Examples** To find more specific code examples, try these approaches: 1. **Microsoft Documentation:** The official Microsoft documentation for the Azure DevOps REST API is your best resource. It includes code samples in C# and other languages. Start here: [https://learn.microsoft.com/en-us/rest/api/azure/devops/](https://learn.microsoft.com/en-us/rest/api/azure/devops/) 2. **GitHub:** Search GitHub for repositories that contain Azure DevOps C# code. Use keywords like: * `azure devops rest api c#` * `azure devops extension c#` * `azure pipelines task c#` * `vsts api c#` (VSTS was the previous name for Azure DevOps) 3. **Stack Overflow:** Search Stack Overflow for questions and answers related to Azure DevOps C# development. 4. **Azure DevOps Samples:** Microsoft provides some official sample projects. Look for these on GitHub. 5. **Specific Use Cases:** Think about the specific tasks you want to automate or the integrations you want to build. Search for code examples that address those specific use cases. For example: * "C# Azure DevOps create work item" * "C# Azure DevOps get build status" * "C# Azure DevOps trigger pipeline" **Example Search on GitHub:** Go to GitHub and search for: `azure devops rest api c#` You'll find many repositories that contain C# code for interacting with the Azure DevOps REST API. Browse through the repositories to find code that matches your needs. Pay attention to the license of the code before using it in your own projects. **In summary:** The term "Azure DevOps MCP C# server and client code" is quite broad. Focus on the specific tasks you want to accomplish with Azure DevOps, and then search for code examples that address those tasks. The Microsoft documentation and GitHub are your best resources. Remember to prioritize security and error handling in your code.

DigitalOcean MCP Server

Provides access to all 471+ DigitalOcean API endpoints through an MCP server that dynamically extracts them from the OpenAPI specification, enabling search, filtering, and direct API calls with proper authentication.

MCP Fetch

Servidor de Protocolo de Contexto do Modelo que permite ao Claude Desktop (ou qualquer cliente MCP) buscar conteúdo da web e processar imagens adequadamente.

ServiceNow MCP Server

A server that integrates Claude AI with ServiceNow, enabling incident creation, service request management, email handling, and catalog browsing through natural language.

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.

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.

test-server

just a test of glama

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.

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.

Document Intelligence MCP Server

Enables Claude to read and analyze PDF documents with automatic OCR processing for scanned files. Features intelligent text extraction, caching for performance, and secure file access with search capabilities.

Universal SQL MCP Server

Enables secure interaction with multiple SQL database engines (MySQL, PostgreSQL, SQLite, SQL Server) through a standardized interface. Supports schema inspection, safe query execution, and controlled write operations with built-in security restrictions.

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.

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.