Discover Awesome MCP Servers

MCP Python SDK Documentation

MIT 탈중앙화 AI, MCP 해커톤 관련 문서 읽어줘.

MongoDB MCP Server for LLMs

LLM이 자연어를 통해 컬렉션을 쿼리하고, 스키마를 검사하고, 데이터를 원활하게 관리할 수 있도록 MongoDB 데이터베이스와 직접 상호 작용할 수 있게 해주는 모델 컨텍스트 프로토콜(MCP) 서버입니다.

MCP Time Server

A Model Context Protocol server providing current time retrieval and timezone conversion using IANA timezones.

Paper Search MCP Server

Enables searching, downloading, and reading academic papers from multiple platforms including arXiv, Semantic Scholar, PubMed, bioRxiv, medRxiv, IACR, Google Scholar, RePEc/IDEAS, and Sci-Hub with PDF to Markdown conversion.

Douyin Video Analysis MCP

An MCP server that parses Douyin share links and performs intelligent content analysis using the Doubao video understanding model. It provides structured outputs including video summaries, categorized outlines, and step-by-step tutorial information.

Twilio SMS MCP Server

Enables AI agents to send, receive, schedule, and manage SMS and MMS messages using the Twilio Programmable Messaging API. It provides comprehensive tools for handling bulk messaging, conversation threads, and real-time inbox monitoring through a secure, production-grade architecture.

monday MCP Server

monday MCP Server

MCP Server for Home Assistant (HTTP Transport)

A Home Assistant Custom Component that provides an MCP server using HTTP transport, allowing AI assistants like Claude to interact with your Home Assistant instance.

MCP Secrets

A secure secrets management server that enables LLMs to execute CLI commands using injected credentials while protecting sensitive data through output redaction and user-approved session permissions. It features an encrypted vault, secret capture from command outputs, and a macOS menu bar app for native notifications and dialogs.

Synapse

Synapse indexes C# codebases into a FalkorDB-backed graph to provide deep structural insights including inheritance, interface implementations, and call chains. It enables AI assistants to query code architecture and navigate symbol relationships using an LSP-powered MCP server.

nativeMCP

이것은 C++로 작성된 MCP 시스템이며, MCP 핵심 아키텍처인 호스트, 클라이언트, 서버를 포함합니다.

ArchiMate MCP Server

Enables AI assistants to create, validate, and visualize ArchiMate 3.2 enterprise architecture diagrams through natural language. Supports all 55+ element types across 7 architectural layers with Mermaid diagram generation and XML export capabilities.

MATLAB MCP Tool

Enables interactive MATLAB development by allowing users to execute scripts and specific code sections, manage workspace variables, and capture generated plots. It integrates with the MATLAB Python Engine to provide persistent execution context for MCP-compatible clients.

mcp-tekna

Enables searching and retrieving Tekna events, news, and member benefits.

mcp-openligadb

Enables querying community-run, keyless football/soccer match data from OpenLigaDB through natural language or direct tool calls.

Pandoc Document Conversion

Enables document format conversion between various formats (Markdown, HTML, PDF, DOCX, LaTeX, EPUB, and more) using Pandoc, preserving formatting and structure while supporting both direct content transformation and file-based conversions.

Backlink SEO

Classic SEO suites charge heavily for link indexes. This MCP gives individuals and agencies a free, automatable path to: surface pages that mention a brand (linked or not), narrow guest-post and resource-page angles, see who links to competitors, verify whether a page links to you, and pull contact signals for outreach—all orchestrated by Claude or Cursor through typed tools instead of brittle cop

DMCP

An MCP server that enables AI agents to act as dynamic dungeon masters for text-based RPGs with dynamically generated rule systems and comprehensive game state management.

Gmail MCP Server

Enables AI assistants to manage Gmail by reading unread emails with automatic classification, creating AI-generated draft replies, and saving drafts directly to Gmail through the Gmail API.

MCP Interface for Teenage Engineering EP-133 K.O. II

Teenage Engineering EP-133 KO-II용 MCP 서버

DadMCP

더 나은 가정 교육을 제공하기 위한 원격 MCP 서버

ara-rgaa-mcp

Enables to manage RGAA accessibility audits on the Ara platform via MCP-compatible clients like Claude Code or Codex, supporting full CRUD operations and audit lifecycle without manual login.

Unerr

unerr is operational memory—a local runtime behind your agent's MCP enforcing shared code graphs, session memory & guardrails. No silent breakages. No context rot.

Screenshot Server

Puppeteer를 사용하여 웹 페이지 및 로컬 HTML 파일의 스크린샷을 간단한 MCP 도구 인터페이스를 통해 캡처할 수 있도록 합니다. 크기 및 출력 경로를 설정할 수 있는 옵션도 제공합니다.

bio-mcp-evo2

An MCP server that enables AI assistants to generate, score, and analyze DNA sequences using the evo2 genomic foundation model. It supports multiple execution modes including local GPU, SLURM clusters, and the Nvidia NIM cloud API for tasks like variant effect prediction and sequence embedding.

SharePoint MCP: The .NET MCP Server with Graph API & Semantic Kernel

Okay, I understand. You want to create an **Microsoft Cloud Platform (MCP)** server (though I suspect you mean a server that leverages Microsoft Cloud Platform services) to access **SharePoint Online**. Since "MCP server" isn't a standard term in this context, I'll assume you want a server-side application that can interact with SharePoint Online. Here's a breakdown of how you can achieve this, along with code examples and explanations. I'll focus on using **.NET Core/ASP.NET Core** as the server-side technology, as it's a common and well-supported choice for interacting with Microsoft services. I'll also use **Microsoft Graph API** as the preferred method for accessing SharePoint Online, as it's the recommended approach. **1. Prerequisites:** * **Azure Subscription:** You'll need an Azure subscription to register your application and manage permissions. You can get a free Azure account. * **.NET Core SDK:** Install the .NET Core SDK on your development machine. Download it from the official Microsoft website. * **Visual Studio or VS Code:** Use a code editor like Visual Studio (with the .NET workload installed) or VS Code (with the C# extension). * **SharePoint Online Site:** You'll need a SharePoint Online site to connect to. **2. Azure AD Application Registration:** This is the most crucial step. You need to register an application in Azure Active Directory (Azure AD) to represent your server application. This application will be granted permissions to access SharePoint Online. * **Go to the Azure Portal:** Sign in to the Azure portal (portal.azure.com). * **Navigate to Azure Active Directory:** Search for "Azure Active Directory" in the search bar and select it. * **App Registrations:** In the Azure AD blade, click on "App registrations" in the left-hand menu. * **New Registration:** Click on "New registration". * **Name:** Give your application a descriptive name (e.g., "SharePointOnlineServerApp"). * **Supported Account Types:** Choose "Accounts in this organizational directory only" (if you only want users within your organization to use the app) or "Accounts in any organizational directory (Any Azure AD directory - Multitenant)" (if you want users from other organizations to be able to use the app). The single-tenant option is generally simpler for initial development. * **Redirect URI (Optional):** For a server-side application, you typically *don't* need a redirect URI during the initial registration. You'll handle authentication server-side. Leave this blank for now. If you later add a web UI, you'll need to add a redirect URI. * **Register:** Click the "Register" button. **Important Information to Save:** After the application is registered, you'll see the application overview. **Save the following information:** * **Application (client) ID:** This is the unique identifier for your application. You'll need this in your code. * **Directory (tenant) ID:** This is the ID of your Azure AD tenant. You'll also need this in your code. **3. Add API Permissions:** Now, you need to grant your application the necessary permissions to access SharePoint Online data through the Microsoft Graph API. * **API Permissions:** In your application registration, click on "API permissions" in the left-hand menu. * **Add a Permission:** Click on "Add a permission". * **Microsoft Graph:** Select "Microsoft Graph". * **Delegated Permissions** or **Application Permissions:** This is a critical choice: * **Delegated Permissions:** Use these if your application will be acting *on behalf of a user*. The user will need to grant consent to the application to access their data. Examples: Reading a user's SharePoint files, updating a user's profile. * **Application Permissions:** Use these if your application needs to access SharePoint Online data *without a user being present*. This requires administrator consent. Examples: A background service that synchronizes data between SharePoint and another system. For this example, let's assume you want to read SharePoint lists and items *without* a user being present (application permissions). * **Select Permissions:** Choose the appropriate permissions. Here are some common ones: * **Application Permissions (for this example):** * `Sites.Read.All`: Allows the application to read SharePoint site collections. * `Sites.ReadWrite.All`: Allows the application to read and write SharePoint site collections. * `Sites.Manage.All`: Allows the application to manage SharePoint site collections. * `Files.Read.All`: Allows the application to read files in SharePoint. * `Files.ReadWrite.All`: Allows the application to read and write files in SharePoint. * **Delegated Permissions (if you chose that option):** * `Sites.Read.All` * `Sites.ReadWrite.All` * `Files.Read.All` * `Files.ReadWrite.All` * `User.Read` (if you need to access user information) * **Add Permissions:** Click "Add permissions". * **Grant Admin Consent:** If you selected Application Permissions, you'll need to grant admin consent. Click the "Grant admin consent for [Your Organization]" button. This requires you to be a Global Administrator or have the appropriate permissions in Azure AD. **4. Create a Client Secret (for Application Permissions):** If you're using Application Permissions, you'll need to create a client secret. This is like a password for your application. **Treat this secret very carefully!** Don't hardcode it directly into your code. Use environment variables or a secure configuration store. * **Certificates & Secrets:** In your application registration, click on "Certificates & secrets" in the left-hand menu. * **New Client Secret:** Click on "New client secret". * **Description:** Give the secret a description (e.g., "SharePoint Access Secret"). * **Expires:** Choose an expiration date. * **Add:** Click "Add". **Important:** **Copy the secret value immediately!** You won't be able to see it again after you leave the page. Store it securely. **5. Create the .NET Core/ASP.NET Core Server Application:** Now, let's create the server application. * **Create a New Project:** Open Visual Studio or VS Code and create a new ASP.NET Core Web API project. Choose a suitable name (e.g., "SharePointOnlineApi"). * **Install NuGet Packages:** You'll need the following NuGet packages: ```bash dotnet add package Microsoft.Identity.Client dotnet add package Microsoft.Graph dotnet add package Microsoft.Extensions.Configuration dotnet add package Microsoft.Extensions.Configuration.Json dotnet add package Microsoft.Extensions.Configuration.EnvironmentVariables ``` * **Configuration:** Create an `appsettings.json` file in your project to store your configuration settings (client ID, tenant ID, client secret, SharePoint site URL). **Do not commit the client secret to source control!** Use environment variables or a secure configuration store in production. ```json { "AzureAd": { "ClientId": "YOUR_CLIENT_ID", "TenantId": "YOUR_TENANT_ID", "ClientSecret": "YOUR_CLIENT_SECRET" }, "SharePoint": { "SiteUrl": "https://yourtenant.sharepoint.com/sites/YourSite" }, "Logging": { "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" } }, "AllowedHosts": "*" } ``` * **Create a Configuration Helper Class:** Create a class to load the configuration settings. ```csharp using Microsoft.Extensions.Configuration; public class AppSettings { public AzureAdSettings AzureAd { get; set; } public SharePointSettings SharePoint { get; set; } } public class AzureAdSettings { public string ClientId { get; set; } public string TenantId { get; set; } public string ClientSecret { get; set; } } public class SharePointSettings { public string SiteUrl { get; set; } } public static class ConfigurationHelper { public static AppSettings GetAppSettings() { var configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) .AddEnvironmentVariables() // Override with environment variables .Build(); return configuration.Get<AppSettings>(); } } ``` * **Create a Microsoft Graph Service:** Create a class to handle the authentication and interaction with the Microsoft Graph API. ```csharp using Microsoft.Graph; using Microsoft.Identity.Client; public class GraphService { private readonly string _clientId; private readonly string _tenantId; private readonly string _clientSecret; private readonly string _siteUrl; public GraphService(string clientId, string tenantId, string clientSecret, string siteUrl) { _clientId = clientId; _tenantId = tenantId; _clientSecret = clientSecret; _siteUrl = siteUrl; } public async Task<GraphServiceClient> GetGraphServiceClient() { IConfidentialClientApplication app = ConfidentialClientApplicationBuilder.Create(_clientId) .WithClientSecret(_clientSecret) .WithAuthority(new Uri($"https://login.microsoftonline.com/{_tenantId}")) .Build(); string[] scopes = new string[] { "https://graph.microsoft.com/.default" }; // Use .default for application permissions AuthenticationResult result = await app.AcquireTokenForClient(scopes).ExecuteAsync(); return new GraphServiceClient(new DelegateAuthenticationProvider(async (requestMessage) => { requestMessage.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("bearer", result.AccessToken); })); } public async Task<List<ListItem>> GetListItems(string listTitle) { var graphClient = await GetGraphServiceClient(); // Extract the site ID from the SiteUrl var uri = new Uri(_siteUrl); string host = uri.Host; string[] pathParts = uri.AbsolutePath.Split('/').Where(s => !string.IsNullOrEmpty(s)).ToArray(); string siteRelativePath = string.Join("/", pathParts); // Get the site ID var site = await graphClient.Sites[$"{host}:{siteRelativePath}"].Request().GetAsync(); string siteId = site.Id; // Get the list ID var list = await graphClient.Sites[siteId].Lists.Request().Filter($"displayName eq '{listTitle}'").GetAsync(); string listId = list.FirstOrDefault().Id; // Get the list items var items = await graphClient.Sites[siteId].Lists[listId].Items.Request().GetAsync(); return items.CurrentPage.ToList(); } } ``` * **Create an API Controller:** Create an API controller to expose the SharePoint data. ```csharp using Microsoft.AspNetCore.Mvc; [ApiController] [Route("[controller]")] public class SharePointController : ControllerBase { private readonly GraphService _graphService; public SharePointController() { var appSettings = ConfigurationHelper.GetAppSettings(); _graphService = new GraphService(appSettings.AzureAd.ClientId, appSettings.AzureAd.TenantId, appSettings.AzureAd.ClientSecret, appSettings.SharePoint.SiteUrl); } [HttpGet("ListItems/{listTitle}")] public async Task<IActionResult> GetListItems(string listTitle) { try { var items = await _graphService.GetListItems(listTitle); return Ok(items); } catch (Exception ex) { return StatusCode(500, $"Error: {ex.Message}"); } } } ``` * **Program.cs (Configure Services):** You might need to add the following to your `Program.cs` file (depending on your .NET version) to ensure controllers are correctly registered: ```csharp // In Program.cs (or Startup.cs for older .NET versions) builder.Services.AddControllers(); // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle builder.Services.AddEndpointsApiExplorer(); builder.Services.AddSwaggerGen(); ``` **6. Test the API:** * **Run the Application:** Run your ASP.NET Core application. * **Use a Tool like Postman or Swagger:** Use a tool like Postman or Swagger UI (if you enabled it) to send a GET request to your API endpoint (e.g., `https://localhost:<port>/SharePoint/ListItems/YourListName`). Replace `<port>` with the port your application is running on and `YourListName` with the title of a list in your SharePoint site. **Important Considerations:** * **Error Handling:** The code examples above have basic error handling. Implement more robust error handling in a production environment. * **Security:** **Never** hardcode your client secret in your code or commit it to source control. Use environment variables, Azure Key Vault, or another secure configuration store. * **Rate Limiting:** The Microsoft Graph API has rate limits. Implement retry logic and consider caching data to avoid exceeding the limits. * **Permissions:** Carefully choose the permissions your application needs. Grant only the minimum necessary permissions. * **Logging:** Implement logging to track application activity and troubleshoot issues. * **Asynchronous Operations:** Use `async` and `await` throughout your code to avoid blocking the main thread. * **Dependency Injection:** Use dependency injection to manage your dependencies and make your code more testable. * **Managed Identity:** For applications deployed to Azure, consider using Managed Identity instead of a client secret. This simplifies authentication and improves security. **Example using Managed Identity (for Azure-deployed applications):** If your application is running in Azure (e.g., on an Azure App Service or Azure VM), you can use Managed Identity to authenticate with the Microsoft Graph API. This eliminates the need to manage client secrets. 1. **Enable Managed Identity:** Enable Managed Identity for your Azure resource (e.g., App Service). In the Azure portal, go to your App Service, click on "Identity" in the left-hand menu, and turn "System assigned managed identity" to "On". 2. **Grant Permissions:** Grant the Managed Identity the necessary permissions to access SharePoint Online (as described in step 3 above). You'll need to find the Managed Identity in Azure AD (it will have the same name as your App Service) and add the API permissions. 3. **Update the Code:** Modify your `GraphService` class to use Managed Identity. You'll need to install the `Azure.Identity` NuGet package: ```bash dotnet add package Azure.Identity ``` Here's the updated `GraphService` class: ```csharp using Azure.Identity; using Microsoft.Graph; public class GraphService { private readonly string _siteUrl; public GraphService(string siteUrl) { _siteUrl = siteUrl; } public async Task<GraphServiceClient> GetGraphServiceClient() { var credential = new DefaultAzureCredential(); // Uses Managed Identity if available return new GraphServiceClient(credential); } public async Task<List<ListItem>> GetListItems(string listTitle) { var graphClient = await GetGraphServiceClient(); // Extract the site ID from the SiteUrl var uri = new Uri(_siteUrl); string host = uri.Host; string[] pathParts = uri.AbsolutePath.Split('/').Where(s => !string.IsNullOrEmpty(s)).ToArray(); string siteRelativePath = string.Join("/", pathParts); // Get the site ID var site = await graphClient.Sites[$"{host}:{siteRelativePath}"].Request().GetAsync(); string siteId = site.Id; // Get the list ID var list = await graphClient.Sites[siteId].Lists.Request().Filter($"displayName eq '{listTitle}'").GetAsync(); string listId = list.FirstOrDefault().Id; // Get the list items var items = await graphClient.Sites[siteId].Lists[listId].Items.Request().GetAsync(); return items.CurrentPage.ToList(); } } ``` And update the controller constructor: ```csharp public SharePointController() { var appSettings = ConfigurationHelper.GetAppSettings(); _graphService = new GraphService(appSettings.SharePoint.SiteUrl); // No client ID/secret needed } ``` With Managed Identity, you no longer need to store or manage client secrets. This comprehensive guide should help you create a server application that can access SharePoint Online using the Microsoft Graph API. Remember to adapt the code and configuration to your specific requirements and security best practices. Good luck!

MCP Text Editor Server

A Model Context Protocol (MCP) server that provides line-oriented text file editing capabilities through a standardized API. Optimized for LLM tools with efficient partial file access to minimize token usage.

SuperCollider MCP Server

Enables execution of SuperCollider synth code through the Model Context Protocol using supercolliderjs, allowing AI assistants to generate and run audio synthesis programs.

Filesystem MCP Server with .mcpignore

Enables secure filesystem access with privacy controls using .mcpignore files to block MCP clients from reading or writing sensitive files and directories while allowing directory browsing and search.

Yelp Fusion AI MCP Server

Enables conversational interactions with Yelp's business data through an MCP server, allowing natural language queries about local businesses, multi-turn conversations, and direct business inquiries powered by Yelp Fusion AI.