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 **MCP (Managed Code Provider) server** to access **SharePoint Online**. However, the term "MCP server" in this context is a bit ambiguous. It's more likely you're looking for a way to interact with SharePoint Online programmatically using .NET code. Here's a breakdown of how to achieve this, focusing on the most common and recommended approaches: **Understanding the Goal** The core idea is to build a server-side application (likely a web API or a background service) that can: 1. **Authenticate** with SharePoint Online. 2. **Interact** with SharePoint Online (read, write, update, delete data). 3. **Expose** this functionality through an API or other interface that your client applications can use. **Key Technologies and Approaches** * **Microsoft Graph API:** This is the **recommended** approach for most modern SharePoint Online development. It provides a unified endpoint for accessing data and services across Microsoft 365, including SharePoint. * **PnP Framework (Patterns and Practices):** This is a community-driven open-source library that simplifies SharePoint development. It provides helper methods and extensions for working with both the SharePoint Client Object Model (CSOM) and the Microsoft Graph API. * **SharePoint Client Object Model (CSOM):** This is an older but still viable option. It allows you to interact with SharePoint Online using .NET code. However, Microsoft Graph is generally preferred for new development. **Example: Building a Web API using Microsoft Graph and .NET Core** This example demonstrates how to create a simple ASP.NET Core Web API that retrieves a list of SharePoint lists from a specific site. **1. Prerequisites:** * **.NET SDK:** Install the latest .NET SDK (e.g., .NET 7 or .NET 8). * **Azure Active Directory (Azure AD) App Registration:** You'll need to register an application in Azure AD to authenticate with SharePoint Online. **2. Azure AD App Registration:** * Go to the Azure portal ([portal.azure.com](portal.azure.com)). * Navigate to "Azure Active Directory" > "App registrations". * Click "New registration". * **Name:** Give your app a descriptive name (e.g., "SharePointOnlineAPI"). * **Supported account types:** Choose "Accounts in this organizational directory only" (or "Accounts in any organizational directory" if you need multi-tenant support). * **Redirect URI (optional):** For a Web API, you typically don't need a redirect URI. If you're building a client application that calls the API, you'll need to configure this later. * Click "Register". **Important App Registration Settings:** * **Application (client) ID:** Note this down. You'll need it in your code. * **Directory (tenant) ID:** Note this down. You'll need it in your code. * **Client Secret:** * Go to "Certificates & secrets" > "Client secrets". * Click "New client secret". * Add a description and choose an expiration date. * Click "Add". * **Copy the *value* of the client secret immediately.** You won't be able to see it again. Treat this like a password. * **API Permissions:** * Go to "API permissions" > "Add a permission". * Select "Microsoft Graph". * Choose "Application permissions" (because this is a server-side application). * Search for and select the following permissions (at a minimum): * `Sites.Read.All` (to read site information) * `Sites.ReadWrite.All` (if you need to write to sites) * `Files.Read.All` (to read files) * `Files.ReadWrite.All` (if you need to write files) * Click "Add permissions". * **Grant admin consent:** After adding the permissions, you'll need to grant admin consent for your organization. Click the "Grant admin consent for [Your Organization]" button. This requires administrator privileges. **3. Create the ASP.NET Core Web API Project:** ```bash dotnet new webapi -n SharePointOnlineAPI cd SharePointOnlineAPI ``` **4. Install Required NuGet Packages:** ```bash dotnet add package Microsoft.Identity.Web dotnet add package Microsoft.Graph dotnet add package Microsoft.Graph.Beta # Optional, for beta features ``` **5. Configure `appsettings.json`:** Add the following configuration to your `appsettings.json` file, replacing the placeholders with your actual values: ```json { "AzureAd": { "Instance": "https://login.microsoftonline.com/", "TenantId": "YOUR_TENANT_ID", "ClientId": "YOUR_CLIENT_ID", "ClientSecret": "YOUR_CLIENT_SECRET" }, "SharePoint": { "SiteUrl": "YOUR_SHAREPOINT_SITE_URL" // e.g., "https://yourtenant.sharepoint.com/sites/YourSite" }, "Logging": { "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" } }, "AllowedHosts": "*" } ``` **6. Create a `SharePointService` (or similar) to handle SharePoint interactions:** Create a new class (e.g., `SharePointService.cs`) to encapsulate the logic for interacting with SharePoint. ```csharp using Microsoft.Graph; using Microsoft.Identity.Web; using Microsoft.Extensions.Configuration; public class SharePointService { private readonly GraphServiceClient _graphClient; private readonly string _siteUrl; public SharePointService(GraphServiceClient graphClient, IConfiguration configuration) { _graphClient = graphClient; _siteUrl = configuration["SharePoint:SiteUrl"]; } public async Task<List<string>> GetListTitlesAsync() { try { // Extract the site ID from the Site URL var uri = new Uri(_siteUrl); string host = uri.Host; string relativePath = uri.AbsolutePath.TrimStart('/'); var site = await _graphClient.Sites.GetByPath(relativePath, host) .Request() .GetAsync(); var lists = await _graphClient.Sites[site.Id].Lists .Request() .GetAsync(); return lists.Select(l => l.DisplayName).ToList(); } catch (Exception ex) { // Log the exception properly Console.WriteLine($"Error getting lists: {ex}"); return new List<string>(); // Or throw the exception, depending on your needs } } } ``` **7. Configure Dependency Injection in `Program.cs`:** ```csharp using Microsoft.AspNetCore.Authentication.JwtBearer; using Microsoft.Identity.Web; using Microsoft.Graph; var builder = WebApplication.CreateBuilder(args); // Add authentication builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) .AddMicrosoftIdentityWebApi(builder.Configuration.GetSection("AzureAd")); // Add services to the container. builder.Services.AddControllers(); // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle builder.Services.AddEndpointsApiExplorer(); builder.Services.AddSwaggerGen(); // Configure Microsoft Graph builder.Services.AddScoped<GraphServiceClient>(sp => { var config = sp.GetRequiredService<IConfiguration>(); var tokenAcquisition = sp.GetRequiredService<ITokenAcquisition>(); return new GraphServiceClient(new DelegateAuthenticationProvider(async (requestMessage) => { var scopes = new[] { "Sites.Read.All" }; // Adjust scopes as needed string accessToken = await tokenAcquisition.GetAccessTokenForAppAsync(scopes); requestMessage.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken); })); }); // Register the SharePointService builder.Services.AddScoped<SharePointService>(); var app = builder.Build(); // Configure the HTTP request pipeline. if (app.Environment.IsDevelopment()) { app.UseSwagger(); app.UseSwaggerUI(); } app.UseHttpsRedirection(); app.UseAuthentication(); app.UseAuthorization(); app.MapControllers(); app.Run(); ``` **8. Create a Controller (e.g., `SharePointController.cs`):** ```csharp using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; [Authorize] // Requires authentication [ApiController] [Route("[controller]")] public class SharePointController : ControllerBase { private readonly SharePointService _sharePointService; public SharePointController(SharePointService sharePointService) { _sharePointService = sharePointService; } [HttpGet("lists")] public async Task<IActionResult> GetLists() { var listTitles = await _sharePointService.GetListTitlesAsync(); return Ok(listTitles); } } ``` **9. Run the API:** ```bash dotnet run ``` **Explanation:** * **Azure AD Authentication:** The code uses `Microsoft.Identity.Web` to handle authentication with Azure AD. It retrieves an access token for the application using the client ID and client secret. * **Microsoft Graph Client:** The `GraphServiceClient` is used to make requests to the Microsoft Graph API. The `DelegateAuthenticationProvider` adds the access token to the `Authorization` header of each request. * **`SharePointService`:** This class encapsulates the logic for interacting with SharePoint. It retrieves the list titles from the specified site. * **Controller:** The `SharePointController` exposes an endpoint (`/sharepoint/lists`) that returns the list titles. The `[Authorize]` attribute ensures that only authenticated users can access the endpoint. * **Permissions:** The Azure AD app registration needs the `Sites.Read.All` permission (or more specific permissions if you only need to access certain sites). **Important Considerations:** * **Error Handling:** The example includes basic error handling, but you should implement more robust error handling in a production environment. Log exceptions properly and provide informative error messages to the client. * **Security:** Protect your client secret. Don't store it directly in your code. Use environment variables or Azure Key Vault to store it securely. * **Permissions:** Request only the permissions that your application needs. Avoid requesting broad permissions if you only need to access specific resources. * **Throttling:** SharePoint Online has throttling limits. Implement retry logic to handle throttling errors. Consider using the Microsoft Graph throttling guidance. * **PnP Framework:** For more complex scenarios, consider using the PnP Framework. It provides helper methods and extensions that can simplify your code. Install the `PnP.Framework` NuGet package. * **Asynchronous Operations:** Use `async` and `await` to avoid blocking the main thread. * **Configuration:** Use the `IConfiguration` interface to access configuration settings from `appsettings.json` or other configuration sources. * **Logging:** Implement proper logging to track errors and monitor the performance of your application. * **Deployment:** Deploy your Web API to a suitable hosting environment, such as Azure App Service. **Example using PnP Framework (Illustrative):** While the above example uses the Microsoft Graph directly, here's a snippet showing how PnP Framework can simplify things (this would require installing the `PnP.Framework` NuGet package and adjusting the `Program.cs` to inject the `IPnPContextFactory`): ```csharp using PnP.Framework; using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Authorization; [Authorize] [ApiController] [Route("[controller]")] public class SharePointController : ControllerBase { private readonly IPnPContextFactory _pnpContextFactory; private readonly IConfiguration _configuration; public SharePointController(IPnPContextFactory pnpContextFactory, IConfiguration configuration) { _pnpContextFactory = pnpContextFactory; _configuration = configuration; } [HttpGet("lists-pnp")] public async Task<IActionResult> GetListsPnP() { string siteUrl = _configuration["SharePoint:SiteUrl"]; using (var pnpContext = await _pnpContextFactory.CreateAsync(new Uri(siteUrl))) { await pnpContext.Web.LoadAsync(p => p.Lists.QueryProperties(p => p.Title)); return Ok(pnpContext.Web.Lists.Select(l => l.Title).ToList()); } } } ``` **Key Differences with PnP:** * **Simplified Authentication:** PnP Framework often simplifies the authentication process, especially when using app-only authentication. The `IPnPContextFactory` handles the authentication behind the scenes. You'll still need to configure the Azure AD app registration and grant the necessary permissions. * **Fluent API:** PnP Framework provides a fluent API for interacting with SharePoint. This can make your code more readable and easier to maintain. * **CSOM Abstraction:** PnP Framework can abstract away some of the complexities of the SharePoint Client Object Model (CSOM). **Choosing the Right Approach:** * **New Development:** For new projects, **Microsoft Graph API is generally the preferred approach.** It's the modern, recommended way to interact with Microsoft 365 services. * **Existing CSOM Code:** If you have existing code that uses the SharePoint Client Object Model (CSOM), you can continue to use it. However, consider migrating to Microsoft Graph over time. * **Complexity:** PnP Framework can simplify development, especially for complex scenarios. It's a good choice if you want to reduce the amount of boilerplate code you need to write. **In summary, you're building a server-side application (likely a Web API) that authenticates with SharePoint Online using an Azure AD app registration and then uses either the Microsoft Graph API or the PnP Framework to interact with SharePoint data. The example above provides a starting point for building such an application.** Remember to adapt the code to your specific requirements and to implement proper error handling, security, and throttling management.

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.