Discover Awesome MCP Servers

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.

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.

Todo List MCP Server

A TypeScript-based MCP server that enables users to manage tasks through natural conversation with Claude. Features complete CRUD operations, priority management, tagging, search functionality, and intelligent productivity insights with robust Zod validation.

Google Workspace MCP Server

Gmail と Calendar API を操作するためのツールを提供する Model Context Protocol サーバー。これにより、メールやカレンダーのイベントをプログラムで管理できます。

auto-mcp

関数、ツール、エージェントを自動的に MCP サーバーに変換する

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.

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.

Axiom MCP Server

@Axiom の mcp-server-axiom の npx 互換ポート

azure-devops-mcp

Okay, I understand you're looking for Azure DevOps code examples, specifically using C#, for both a server (presumably interacting with the Azure DevOps API) and a client (likely consuming data from the server or directly from Azure DevOps). Providing a complete, ready-to-run application without knowing the specific functionality you need is impossible. However, I can give you a solid foundation with code snippets and explanations to get you started. I'll break it down into server-side and client-side examples, focusing on common tasks. **Important Considerations Before You Start:** * **Azure DevOps Organization and Project:** You'll need an Azure DevOps organization and a project within that organization to test these examples. * **Personal Access Token (PAT):** You'll need a PAT with the appropriate scopes to access the Azure DevOps API. **Treat your PAT like a password! Do not hardcode it directly into your code.** Use environment variables, configuration files, or Azure Key Vault to store it securely. The scopes you need will depend on the specific API calls you're making (e.g., `vso.work`, `vso.code`, `vso.release`). * **NuGet Packages:** You'll need to install the necessary NuGet packages. The primary one is `Microsoft.TeamFoundationServer.Client`. You might also need `Microsoft.VisualStudio.Services.Client` and potentially others depending on your specific needs. **1. Server-Side (C# - ASP.NET Core Web API Example)** This example demonstrates how to retrieve work items from Azure DevOps using the REST API. ```csharp using Microsoft.AspNetCore.Mvc; using Microsoft.TeamFoundation.WorkItemTracking.WebApi; using Microsoft.TeamFoundation.WorkItemTracking.WebApi.Models; using Microsoft.VisualStudio.Services.Common; using Microsoft.VisualStudio.Services.WebApi; using System; using System.Collections.Generic; using System.Threading.Tasks; namespace AzureDevOpsApi.Controllers { [ApiController] [Route("[controller]")] public class WorkItemsController : ControllerBase { private readonly string _organizationUrl; private readonly string _personalAccessToken; private readonly string _project; public WorkItemsController(IConfiguration configuration) // Use IConfiguration to read settings { _organizationUrl = configuration["AzureDevOps:OrganizationUrl"]; _personalAccessToken = configuration["AzureDevOps:PersonalAccessToken"]; _project = configuration["AzureDevOps:Project"]; } [HttpGet] public async Task<IActionResult> GetWorkItems() { try { // Create connection to Azure DevOps var connection = new VssConnection(new Uri(_organizationUrl), new VssBasicCredential(string.Empty, _personalAccessToken)); // Get the WorkItemTrackingHttpClient using (var workItemClient = connection.GetClient<WorkItemTrackingHttpClient>()) { // Construct WIQL (Work Item Query Language) query var wiql = new Wiql() { Query = $"Select [Id], [Title], [State] From WorkItems Where [Team Project] = '{_project}' AND [Work Item Type] = 'Task' AND [State] <> 'Closed' ORDER BY [Id]" }; // Execute the query to get work item IDs var result = await workItemClient.QueryByWiqlAsync(wiql); if (result == null || result.WorkItems == null || result.WorkItems.Count == 0) { return NotFound("No work items found."); } // Get the full work items based on the IDs List<int> workItemIds = result.WorkItems.Select(wi => wi.Id).ToList(); var workItems = await workItemClient.GetWorkItemsAsync(workItemIds); return Ok(workItems); } } catch (Exception ex) { // Log the exception properly! Console.WriteLine(ex.ToString()); return StatusCode(500, "An error occurred while retrieving work items."); } } } } ``` **Explanation:** 1. **Dependencies:** Requires `Microsoft.AspNetCore.Mvc`, `Microsoft.TeamFoundationServer.Client`, `Microsoft.VisualStudio.Services.Client`. 2. **Configuration:** The code reads the Azure DevOps organization URL, PAT, and project name from the application's configuration (e.g., `appsettings.json`). **This is crucial for security!** 3. **`VssConnection`:** Creates a connection to your Azure DevOps organization using the URL and PAT. `VssBasicCredential` is used for PAT authentication. 4. **`WorkItemTrackingHttpClient`:** Gets an instance of the Work Item Tracking HTTP client, which allows you to interact with work items. 5. **WIQL Query:** Constructs a WIQL query to select work items. WIQL is similar to SQL but specifically designed for querying work items in Azure DevOps. **Important:** Adjust the query to match your specific needs. This example retrieves all open tasks. 6. **`QueryByWiqlAsync`:** Executes the WIQL query and returns a list of work item references (IDs). 7. **`GetWorkItemsAsync`:** Retrieves the full work item details based on the IDs obtained from the query. 8. **Error Handling:** Includes basic error handling. **In a production environment, you should implement robust logging and error handling.** 9. **Return Value:** Returns an `IActionResult`. `Ok()` returns a 200 OK with the work items, and `NotFound()` returns a 404 if no work items are found. `StatusCode(500)` returns a 500 Internal Server Error in case of an exception. **appsettings.json (Example):** ```json { "Logging": { "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" } }, "AllowedHosts": "*", "AzureDevOps": { "OrganizationUrl": "https://dev.azure.com/your-organization", "PersonalAccessToken": "your-personal-access-token", "Project": "YourProjectName" } } ``` **Important:** Replace `"https://dev.azure.com/your-organization"`, `"your-personal-access-token"`, and `"YourProjectName"` with your actual values. Consider using environment variables instead of storing the PAT directly in `appsettings.json`. **2. Client-Side (C# - Console Application Example)** This example demonstrates how to consume the API endpoint created in the server-side example. ```csharp using System; using System.Net.Http; using System.Net.Http.Headers; using System.Text.Json; using System.Threading.Tasks; namespace AzureDevOpsClient { class Program { private static readonly HttpClient client = new HttpClient(); static async Task Main(string[] args) { // Replace with the actual URL of your API endpoint string apiUrl = "https://localhost:7000/WorkItems"; // Or your deployed API URL try { // Call the API string json = await GetAsync(apiUrl); // Deserialize the JSON response if (!string.IsNullOrEmpty(json)) { // Assuming the API returns a JSON array of WorkItem objects // You'll need to define a WorkItem class that matches the structure of the JSON // For example: // public class WorkItem { public int Id { get; set; } public string Title { get; set; } public string State { get; set; } } // List<WorkItem> workItems = JsonSerializer.Deserialize<List<WorkItem>>(json); // For demonstration purposes, let's just print the raw JSON Console.WriteLine(json); } else { Console.WriteLine("No data received from the API."); } } catch (Exception ex) { Console.WriteLine($"An error occurred: {ex.Message}"); } Console.ReadKey(); } static async Task<string> GetAsync(string uri) { HttpResponseMessage response = await client.GetAsync(uri); response.EnsureSuccessStatusCode(); return await response.Content.ReadAsStringAsync(); } } } ``` **Explanation:** 1. **`HttpClient`:** Creates an `HttpClient` to make HTTP requests to the API. 2. **`apiUrl`:** Replace `"https://localhost:7000/WorkItems"` with the actual URL of your deployed API endpoint. 3. **`GetAsync`:** Sends an HTTP GET request to the API endpoint. 4. **`Deserialize`:** Deserializes the JSON response from the API into a C# object. **You'll need to define a C# class (`WorkItem` in the example) that matches the structure of the JSON returned by the API.** The example shows a basic `WorkItem` class; you'll need to adjust it based on the actual fields returned by your API. 5. **Error Handling:** Includes basic error handling. 6. **Output:** Prints the deserialized work item data to the console. **Important Notes:** * **JSON Serialization/Deserialization:** The `System.Text.Json` namespace is used for JSON serialization and deserialization. You can also use `Newtonsoft.Json` if you prefer (install the `Newtonsoft.Json` NuGet package). * **`WorkItem` Class:** You'll need to define a `WorkItem` class (or a class that represents the data structure returned by your API) to properly deserialize the JSON response. The properties of the class should match the names and data types of the fields in the JSON. * **API URL:** Make sure to replace `"https://localhost:7000/WorkItems"` with the correct URL of your API endpoint. If you're running the API locally, it might be a different port number. If you've deployed the API to Azure or another hosting environment, use the deployed URL. * **Authentication (Client-Side):** If your API requires authentication (e.g., an API key or bearer token), you'll need to add the appropriate headers to the `HttpClient` request. For example, to add a bearer token: ```csharp client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "your-api-token"); ``` **Further Development:** * **Error Handling:** Implement comprehensive error handling in both the server-side and client-side code. Log errors to a file or database for debugging. * **Dependency Injection:** Use dependency injection to manage dependencies (e.g., the `WorkItemTrackingHttpClient`) in a more testable and maintainable way. * **Asynchronous Operations:** Use `async` and `await` for all I/O-bound operations (e.g., API calls) to prevent blocking the UI thread. * **Data Validation:** Validate the data received from the API to ensure it's in the expected format. * **Unit Testing:** Write unit tests to verify the functionality of your code. * **Security:** Implement proper security measures to protect your application and data. This includes using HTTPS, validating user input, and protecting against common web vulnerabilities. * **Authentication/Authorization:** Implement proper authentication and authorization mechanisms to control access to your API. * **Configuration Management:** Use a robust configuration management system to manage your application's settings. * **Logging:** Implement comprehensive logging to track application behavior and diagnose problems. * **Deployment:** Use a proper deployment pipeline to deploy your application to a production environment. **Key Improvements and Best Practices:** * **Configuration:** Use `IConfiguration` to read settings from `appsettings.json` or environment variables. This is much better than hardcoding values. * **Error Handling:** Include `try-catch` blocks and log exceptions. Don't just swallow exceptions. * **Asynchronous Operations:** Use `async` and `await` for all network operations. * **Resource Management:** Use `using` statements to ensure that resources (like `HttpClient` and `WorkItemTrackingHttpClient`) are properly disposed of. * **Security:** Never hardcode your PAT. Store it securely in environment variables or Azure Key Vault. * **WIQL:** Learn WIQL to create more complex and efficient queries. * **Data Transfer Objects (DTOs):** Consider using DTOs to represent the data that is transferred between the server and the client. This can help to decouple the client from the server and make it easier to change the server-side implementation without breaking the client. This comprehensive example provides a strong starting point for building your Azure DevOps integration with C#. Remember to adapt the code to your specific requirements and follow best practices for security, error handling, and maintainability. Good luck!

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

MicrosoftのAutoGenフレームワークとの統合を提供するMCPサーバー。標準化されたインターフェースを通じて、マルチエージェントの会話を可能にします。

Brave Search With Proxy

Brave Search With Proxy

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

はい、承知いたしました。以下に、Deepseekモデルに質問をリダイレクトする、Go言語で記述されたシンプルなMCP（Minecraft Protocol）サーバーの例を示します。 **免責事項:** これはあくまで基本的な例であり、完全なMCPサーバーの実装ではありません。認証、パケットの完全な処理、エラー処理など、多くの重要な側面が省略されています。また、Deepseekモデルへのアクセスには、適切なAPIキーと認証が必要になる場合があります。 ```go package main import ( "bufio" "encoding/json" "fmt" "io" "log" "net" "net/http" "os" "strings" ) // Deepseek APIのエンドポイントとAPIキーを設定 const ( DeepseekAPIEndpoint = "YOUR_DEEPSEEK_API_ENDPOINT" // 例: "https://api.deepseek.com/v1/chat/completions" DeepseekAPIKey = "YOUR_DEEPSEEK_API_KEY" // Deepseekから取得したAPIキー ListenAddress = "0.0.0.0:25565" // サーバーがリッスンするアドレス ) // Deepseek APIに送信するリクエストの構造体 type DeepseekRequest struct { Model string `json:"model"` Messages []ChatMessage `json:"messages"` } // Deepseek APIに送信するメッセージの構造体 type ChatMessage struct { Role string `json:"role"` Content string `json:"content"` } // Deepseek APIからのレスポンスの構造体 (必要な部分のみ) type DeepseekResponse struct { Choices []struct { Message struct { Content string `json:"content"` } `json:"message"` } `json:"choices"` } 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(conn net.Conn) { defer conn.Close() reader := bufio.NewReader(conn) for { message, err := reader.ReadString('\n') if err != nil { if err != io.EOF { log.Printf("Error reading from connection: %v", err) } break } message = strings.TrimSpace(message) fmt.Printf("Received: %s\n", message) // ここで、受信したメッセージが質問かどうかを判断するロジックを追加できます。 // 例えば、特定のプレフィックスやキーワードを探すなど。 // 今回は、すべてのメッセージを質問として扱います。 response, err := askDeepseek(message) if err != nil { log.Printf("Error asking Deepseek: %v", err) // エラーメッセージをクライアントに送信 conn.Write([]byte("Error: Failed to get response from Deepseek.\n")) continue } // Deepseekからのレスポンスをクライアントに送信 conn.Write([]byte(response + "\n")) } } func askDeepseek(question string) (string, error) { // Deepseek APIに送信するリクエストを作成 requestBody := DeepseekRequest{ Model: "deepseek-chat", // Deepseekのモデル名 (必要に応じて変更) Messages: []ChatMessage{ { Role: "user", Content: question, }, }, } // リクエストをJSONにエンコード requestBytes, err := json.Marshal(requestBody) if err != nil { return "", fmt.Errorf("failed to marshal request: %w", err) } // HTTPリクエストを作成 req, err := http.NewRequest("POST", DeepseekAPIEndpoint, strings.NewReader(string(requestBytes))) if err != nil { return "", fmt.Errorf("failed to create request: %w", err) } // ヘッダーを設定 req.Header.Set("Content-Type", "application/json") req.Header.Set("Authorization", "Bearer "+DeepseekAPIKey) // APIキーを設定 // HTTPクライアントを作成してリクエストを送信 client := &http.Client{} resp, err := client.Do(req) if err != nil { return "", fmt.Errorf("failed to send request: %w", err) } defer resp.Body.Close() // レスポンスを読み込む body, err := io.ReadAll(resp.Body) if err != nil { return "", fmt.Errorf("failed to read response body: %w", err) } // レスポンスを構造体にデコード var deepseekResponse DeepseekResponse err = json.Unmarshal(body, &deepseekResponse) if err != nil { // レスポンスのデコードに失敗した場合、生のレスポンスをログに出力 log.Printf("Failed to unmarshal response: %v\nRaw response: %s", err, string(body)) return "", fmt.Errorf("failed to unmarshal response: %w", err) } // レスポンスからコンテンツを抽出 if len(deepseekResponse.Choices) > 0 { return deepseekResponse.Choices[0].Message.Content, nil } return "No response from Deepseek.", nil } // 環境変数からAPIキーを読み込むヘルパー関数 (オプション) func getAPIKey() string { apiKey := os.Getenv("DEEPSEEK_API_KEY") if apiKey == "" { log.Fatal("DEEPSEEK_API_KEY environment variable not set.") } return apiKey } ``` **このコードの動作:** 1. **リッスン:** 指定されたアドレス（`0.0.0.0:25565`）でTCP接続をリッスンします。 2. **接続処理:** 新しい接続を受け入れると、`handleConnection`関数がゴルーチンで実行されます。 3. **メッセージの読み取り:** `handleConnection`関数は、接続から行単位でメッセージを読み取ります。 4. **Deepseekへのリダイレクト:** 受信したメッセージを`askDeepseek`関数に渡して、Deepseek APIに質問を送信します。 5. **Deepseek APIへのリクエスト:** `askDeepseek`関数は、Deepseek APIにHTTP POSTリクエストを送信し、質問をJSON形式で送信します。 `DeepseekAPIKey` は、Deepseekから取得したAPIキーに置き換えてください。 6. **レスポンスの処理:** Deepseek APIからのレスポンスを解析し、抽出されたコンテンツをクライアントに返信します。 7. **クライアントへの返信:** Deepseekからのレスポンスをクライアントに送信します。 **使用方法:** 1. **Deepseek APIキーの取得:** DeepseekからAPIキーを取得します。 2. **コードの編集:** `DeepseekAPIEndpoint` と `DeepseekAPIKey` のプレースホルダーを、実際の値に置き換えます。 3. **実行:** `go run main.go` でコードを実行します。 4. **Minecraftクライアントの接続:** Minecraftクライアントをサーバーのアドレス（`localhost:25565`など）に接続します。 5. **メッセージの送信:** Minecraftクライアントからメッセージを送信すると、サーバーはそれをDeepseekにリダイレクトし、DeepseekからのレスポンスをMinecraftクライアントに返信します。 **改善点:** * **MCPプロトコルの実装:** この例は、プレーンテキストのメッセージを処理するだけです。完全なMCPサーバーを実装するには、MCPプロトコルを理解し、適切なパケットを解析および構築する必要があります。 * **認証:** サーバーへの接続を認証するためのメカニズムを追加する必要があります。 * **エラー処理:** より堅牢なエラー処理を追加する必要があります。 * **質問の判断:** 受信したメッセージが質問かどうかを判断するためのロジックを追加する必要があります。 * **設定:** 設定ファイルまたは環境変数を使用して、Deepseek APIのエンドポイント、APIキー、およびその他の設定を構成できるようにする必要があります。 * **レート制限:** Deepseek APIのレート制限を超えないように、レート制限を実装する必要があります。 * **ロギング:** より詳細なロギングを追加する必要があります。 * **非同期処理:** より多くの同時接続を処理するために、非同期処理を使用することを検討してください。 **注意:** * このコードは、Deepseek APIの利用規約に従って使用してください。 * APIキーを安全に保管し、公開しないように注意してください。 * このコードは、教育目的でのみ提供されています。本番環境で使用する前に、十分にテストしてください。 この例が、Deepseekモデルに質問をリダイレクトするシンプルなMCPサーバーの作成の出発点となることを願っています。

🚀 Electron Debug MCP Server

🚀 Chrome DevTools Protocol との深い統合により、Electron アプリケーションのデバッグを強力にサポートする MCP サーバーです。標準化された API を通じて、Electron アプリの制御、監視、デバッグが可能です。

Ableton Copilot MCP

Ableton Liveとのリアルタイムなインタラクションを可能にするModel Context Protocolサーバー。AIアシスタントが楽曲制作、トラック管理、クリップ操作、オーディオ録音ワークフローを制御できるようになります。

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.

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.

ClickUp MCP Server

Enables comprehensive project management through ClickUp's API, supporting task creation and updates, time tracking, goal management, and team collaboration within ClickUp's hierarchical workspace structure.

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.

Remote MCP Server on Cloudflare

鏡 (Kagami)

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.

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.