Discover Awesome MCP Servers

fabric-mcp

Enables interaction with Equinix Fabric via MCP protocol, providing 109 tools for managing Fabric resources with client-credentials authentication and governance.

Alpic MCP Template

A TypeScript template for building MCP servers with Streamable HTTP transport, providing example tools, resources, and prompts to help developers create custom MCP integrations.

xkcd-mcp

MCP server to fetch xkcd comics (latest, random, by number, search) and display them with rich in-chat previews via the official JSON API and explainxkcd semantic search.

LinkedIn Outreach MCP Server

AI-powered content generation for LinkedIn outreach, helping sales teams and recruiters craft personalized connection requests, InMails, posts, comments, and multi-touch outreach sequences. It's a content assistant that generates text for human review and manual sending, fully compliant with LinkedIn's Terms of Service.

Memory Engine MCP

Enables AI assistants to have a living memory with atomic knowledge storage, multi-factor recall, organic decay, automatic learning, and graph traversal via MCP.

DivLens MCP

A real-time system diagnostics MCP server that gives AI agents live access to CPU, RAM, disk, network, processes, and hardware health metrics, with zero cloud dependency.

brain

A personal memory engine and MCP server that stores durable facts in markdown files managed via git, enabling hybrid search (lexical + semantic) through an MCP interface for persistent context across LLM sessions.

cargoshipper-mcp

A comprehensive MCP server that provides Claude with direct access to Docker, DigitalOcean, and CloudFlare APIs for infrastructure management and automation.

Supabase MCP Server

Connect your Supabase projects to Cursor, Claude, Windsurf, and other AI assistants.

Git Auto Commit MCP Server

Analyzes git changes in repositories and generates conventional commit messages using OpenAI's GPT models, supporting both staged and unstaged changes with detailed summaries.

MCP Datastore Server

An MCP server that enables interaction with Google Firestore in Datastore mode for entity management and querying. It provides tools for CRUD operations, aggregation queries, and transaction execution within Google Cloud projects.

Jordan Payments MCP

Enables AI agents to accept payments in Jordan through Tap Payments hosted checkout, supporting cards and Apple Pay with tools for creating payment links and querying payment status.

OfficeRnD MCP Server

Enables AI clients to interact with OfficeRnD coworking space management platform via natural language, exposing 130+ tools for CRUD operations and business logic.

reddit-mcp

A read-only Model Context Protocol server that enables browsing subreddits, searching within subreddits, retrieving comment trees, and looking up user activity on Reddit via natural language.

Kaspa MCP Server

Model Context Protocol server for Kaspa operations using WASM SDK. Enables LLMs to interact with the Kaspa network through standardized MCP tools.

Godot MCP

Provides a comprehensive integration between LLMs and the Godot Engine, enabling AI assistants to intelligently manipulate project files, scripts, and the live editor. It supports advanced workflows including version-aware documentation querying, automated E2E game testing, and real-time visual context capture.

job-tracker-mcp

Enables users to manage job applications (add, list, update status) through natural language conversations, using Notion as the backend.

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.

tracked-search

A drop-in replacement for Claude's built-in web_search tool that automatically tracks usage and provides multiple search backends.

Mi Fitness MCP

MCP server for Mi Fitness cloud data. Provides a local SQLite-backed server to sync and query daily activity, heart rate, and body measurements.

starlink-blade-mcp

Local-first Starlink dish monitoring and control via the Model Context Protocol. Talks directly to your dish over the local gRPC interface with no cloud dependency.

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.

mssql-explorer-mcp

A read-only MCP server for exploring on-premises, multi-instance Microsoft SQL Server estates from AI clients, with read-only enforcement and Windows authentication support.

Italy Invoice MCP

Enables AI agents to issue Italian FatturaPA electronic invoices and transmit them to the SdI via Invoicetronic. Supports creating and querying invoices with Italian VAT rates.

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.

Jira Cloud MCP Server

Enables AI assistants to manage Jira Cloud projects, issues, sprints, and more through a curated set of 62 tools covering the full lifecycle of stories, epics, bugs, and sprints.

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.

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!

Postlark MCP Server

Enables AI agents to manage and publish blog posts on Postlark via tools like create_post, update_post, list_posts, and more.