Discover Awesome MCP Servers

Polygon-io MCP Server

Polygon-io MCP Server

Project Tracking MCP Server

Enables project and task management through a lightweight SQLite database, allowing users to create projects, add categorized tasks, track status changes, and get project statistics through natural language commands.

GSC-MCP-Server

Connects Google Search Console to MCP clients to query search analytics, manage sitemaps, and perform URL inspections. It enables users to identify SEO opportunities and generate performance reports through natural language interactions.

mcp-server-demo

✨ MCP 서버 데모

TanStack MCP Server

Wraps the TanStack CLI to provide programmatic access to documentation, library listings, and project scaffolding for the TanStack ecosystem. It enables AI assistants to search documentation and create new TanStack applications through the Model Context Protocol.

mcp-server-chart

mcp-server-chart

Whoop MCP Server

Integrates WHOOP biometric data into Claude and other MCP-compatible applications, providing access to sleep analysis, recovery metrics, strain tracking, and biological age data through natural language queries.

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!

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.

Up Bank MCP Server

An MCP wrapper for Up Bank's API that allows Claude and other MCP-enabled clients to manage accounts, transactions, categories, tags, and webhooks from Up Bank.

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.

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.

lint-mcp

Enables intelligent Go code quality checking with smart change detection through golangci-lint integration. Automatically detects branch development scope and focuses on current changes to avoid historical code issues.

Magento 2 Development MCP Server

Enables AI agents to interact with Magento 2 development environments through comprehensive tools for module management, database operations, cache control, configuration management, and system diagnostics. Supports complete development workflows from module creation to deployment and troubleshooting.

MCP Server Basic

A basic MCP server example that provides simple arithmetic tools (addition and subtraction) and personalized greeting resources. Serves as a foundation for learning MCP server implementation and development.

mcp-nativewind

Tailwind 컴포넌트를 NativeWind 4로 변환합니다.

Chess MCP Server

Enables Large Language Models to play chess agentically with real-time HTML board visualization and a hybrid AI engine featuring ten difficulty levels. It supports interactive games between users and agents, including a web dashboard to monitor active matches.

MindBridge MCP Server

애플리케이션을 여러 LLM 제공업체(OpenAI, Anthropic, Google, DeepSeek, Ollama 등)에 연결하고, 스마트 모델 오케스트레이션 기능을 통해 다양한 추론 작업에 따라 모델 간 동적 전환을 가능하게 하는 AI 라우터입니다.

MCP-RLM

An implementation of the Recursive Language Models architecture that enables AI agents to process massive documents by programmatically decomposing them into sub-queries. It allows for cost-effective and accurate reasoning across millions of tokens by treating long-form data as an external environment for root and worker models.

Shopify MCP Server

GraphQL API를 통해 Shopify 스토어와 상호 작용할 수 있도록 제품, 고객, 주문 등을 관리하는 도구를 제공합니다.

IPA MCP Server

Enables management of FreeIPA resources including user groups, host groups, HBAC, and sudo rules via the FreeIPA JSON-RPC API. It provides comprehensive tools for automating access control and infrastructure provisioning in FreeIPA-managed environments.

Todoist MCP Server

A self-hosted MCP server that wraps the official Todoist AI package to provide over 35 tools for managing tasks and projects. It features a Dockerized setup with automatic TLS, enabling seamless integration with AI clients like Claude and Cursor.

agentos-mcp-server

Governance kernel for AI agents — policy enforcement, code safety verification, multi-model hallucination detection (CMVK), trust attestation (IATP), and immutable audit trails. Works with Claude Desktop, Cursor, and any MCP client.

Unrestricted Development MCP Server

Provides unrestricted access to your development environment with filesystem operations and shell command execution capabilities, including sudo support for local development machines.

Findymail MCP Server

An MCP server integrating with Findymail API that enables email validation and finding work emails using names, companies, or profile URLs.

tsrs-mcp-server

Tushare Rust MCP 서버

OpenSCAD MCP Server

Enables AI assistants to render 3D models from OpenSCAD code, generating single views or multiple perspectives with full camera control. Supports animations, custom parameters, and returns base64-encoded PNG images for seamless integration.

shivonai-mcp

저희 MCP 도구는 AI 기반 자동 인터뷰 서비스의 기능을 향상시켜 원활하고 맥락에 맞는 지원자 평가 프로세스를 보장하도록 설계되었습니다. 이러한 도구는 고급 AI 모델을 활용하여 응답을 분석하고, 역량을 평가하며, 실시간 피드백을 제공합니다.

macOS Defaults MCP Server

Enables reading and writing macOS system defaults and settings through commands equivalent to the defaults command-line tool. Supports listing domains, searching for settings, and modifying system preferences programmatically.