Discover Awesome MCP Servers

MCP SSE Server

실시간 통신을 위해 서버 전송 이벤트(SSE)를 사용하는 모델 컨텍스트 프로토콜(MCP) 서버 구현으로, 계산 및 동적 리소스 템플릿을 위한 도구를 제공합니다.

SensorMCP Server

An MCP server that enables automated dataset creation and custom object detection model training through natural language interactions. It integrates foundation models like GroundedSAM for auto-labeling and supports training specialized YOLOv8 models using local or Unsplash images.

Cocktail

Enables natural language search for cocktail recipes and ingredient information through TheCocktailDB API. Supports searching by cocktail name, ingredient, category, or alcohol content to discover recipes and recommendations.

calldata-guardian

Decodes Ethereum calldata and returns a safety verdict with plain-English explanations of what the transaction does, flagging dangerous actions like unlimited approvals or gasless permits.

Harvest MCP Server

Integrates with Harvest time tracking to allow AI assistants to log time, view projects, manage tasks, and track work hours, with optional Azure DevOps integration for automated time logging from work items.

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.

MCP NodeJS Debugger

Allows Claude to directly debug a NodeJS server by setting breakpoints, inspecting variables and stepping through code.

AI Use Cases MCP Server

A Model Context Protocol server that collects, analyzes, and manages AI use case data from various information sources with features for web scraping, data analysis, and trend identification.

Poppify Studio

Photo-to-reel MCP for solo founders and SMBs. Upload 1–10 photos and get a captioned vertical reel for Instagram, TikTok, YouTube Shorts, or Facebook — with motion, library-matched music, and optional AI voiceover.

Housecall Pro MCP Servers

A collection of over 20 specialized MCP servers that enable LLMs to manage customers, jobs, scheduling, invoicing, materials, and more in Housecall Pro's field service management system.

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 도구 인터페이스를 통해 캡처할 수 있도록 합니다. 크기 및 출력 경로를 설정할 수 있는 옵션도 제공합니다.

Prometheus MCP Server

Enables AI assistants to execute PromQL queries and discover metrics within AWS Managed Prometheus (AMP) using SigV4 authentication. It provides tools for instant and range queries, label management, and metric discovery in secure, VPC-isolated environments.

Kubernetes MCP Server

An MCP server for generating Kubernetes manifests (deployments, services, configmaps, secrets, ingresses, namespaces) and performing kubectl operations like apply, delete, get, describe, logs, and exec.

monday MCP Server

monday MCP Server

OpenRouter MCP Server

Provides seamless access to 200+ AI models through OpenRouter's unified API, featuring multi-model collaboration, vision support, intelligent benchmarking, and collective intelligence capabilities for enhanced decision-making.

MCP RAG Server

AI 에이전트가 Sui Move 언어 문서가 포함된 FAISS 벡터 데이터베이스를 쿼리하여 검색 증강 생성을 수행할 수 있도록 하는 머신 대화 프로토콜 서버입니다.

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

Ultimate All-in-One MCP Server

A comprehensive collection of 103 tools providing capabilities for text processing, data analysis, web development, and business management in a single server. It is designed for rapid deployment to Vercel and integrates seamlessly with MCP clients like Claude and Cursor to automate diverse workflows.

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.

WhatsApp Business MCP Server

Enables interaction with WhatsApp Business tools and services through a unified API.

Expense Tracker MCP Server

Enables natural language expense management with SQLite storage, allowing users to add expenses, view totals, and list all expenses through conversational commands.

DadMCP

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

nextcloud-agent

Enables to manage Nextcloud files, user info, sharing, calendar, and contacts through optimized MCP tools with dynamic tool selection and enterprise-grade security.

RemoteZip MCP Server

Enables accessing and extracting files from remote zip archives over HTTP, HTTPS, and FTP without downloading the entire archive. Supports listing files, extracting individual files, and getting file information using partial reading techniques.

Tages

Enables AI coding agents to maintain persistent, cross-session memory of codebase architecture, naming conventions, and decisions through MCP tools. Eliminates repetitive project re-explanation by automatically injecting stored context into every session with local-first SQLite storage and optional team sharing capabilities.

mem-forensics

Enables AI agents to analyze memory dumps for forensic investigation, leveraging a fast Rust engine and full Volatility3 plugin coverage via the Model Context Protocol.

MakerPerks MCP-AQL Adapter

Enables AI agents to browse and apply for builder perks (free credits, discounts, etc.) via a single semantic endpoint, with optional user-controlled autonomy for signups.

sahmk-mcp

Official MCP server for interacting with Saudi market data (Sahmk) via natural language queries, enabling stock quotes, company info, and market summaries inside AI agents like Cursor and Claude Desktop.