Discover Awesome MCP Servers

ProtonMail MCP Server

An MCP server that connects to ProtonMail via Bridge, enabling AI assistants like Claude to manage your email.

mcp-nrepl

Connects to nREPL servers to evaluate Clojure code interactively, enabling AI assistants like Claude to run Clojure code in real-time.

3dspace-mcp-server

Converts OpenAPI specifications into MCP tools to access 3DSpace Engineering Web Services APIs, enabling natural language interaction with 45+ services for engineering, manufacturing, and project management.

TradeX MCP Server

Enables AI agents to research, analyze, and trade Pokemon card perpetual futures on the TradeX platform. It supports market data retrieval, trading simulations, and secure transaction execution using local Solana keypairs.

mcp-toolselect

An MCP server that recommends specific tools for tasks by learning from usage patterns and historical success rates. It enables users to register tool capabilities and provides ranked recommendations that adapt based on feedback and execution data.

Chotu Robo Server

An MCP server that integrates Arduino-based robotics (ESP32 or Arduino Nano) with AI, allowing control of hardware components like LEDs, motors, servos, and sensors through AI assistants.

Slack MCP Server

A Model Context Protocol (MCP) server for Slack integration, allowing Claude to interact with your Slack workspace.

Legion Demo

Enables interaction with the Agent Legion platform through MCP. Provides tools such as tool_say_hi to demo the server's capabilities.

AV-MCP Automator

Middleware that uses Model Context Protocol and generative AI to automatically generate native Crestron Construct interfaces (.cuig/.cuib), enabling natural language creation of AV control UI components.

@thatworkagency/mcp-shopify

Model Context Protocol server providing read-only access to Shopify Admin API for products, orders, customers, and shop information with multi-store support via HTTP.

Slack MCP Server

Self-hosted MCP server for Slack using User OAuth Token, enabling message management, channel operations, and user interactions via natural language.

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 (or more likely, you're referring to a server-side application) that can access **SharePoint Online**. Since "MCP server" isn't a standard term in this context, I'll assume you want to build a backend application that interacts with SharePoint Online. Here's a breakdown of how to approach this, along with code snippets and explanations. I'll focus on using **.NET Core/ASP.NET Core** as the backend language, as it's a common and well-supported choice for this type of integration. I'll also cover the necessary authentication and authorization aspects. **1. Prerequisites:** * **Azure Subscription:** You'll need an Azure subscription to register your application in Azure Active Directory (Azure AD). If you don't have one, you can create a free trial. * **.NET Core SDK:** Install the .NET Core SDK on your development machine. You can download it from the official Microsoft website. * **SharePoint Online Subscription:** You need a SharePoint Online subscription (part of Microsoft 365). * **Visual Studio or VS Code:** Use your preferred IDE for .NET development. Visual Studio is a full-featured IDE, while VS Code is a lightweight and cross-platform option. **2. Azure AD App Registration:** This is the most crucial step. You need to register your application in Azure AD to get the necessary credentials for authentication. 1. **Go to the Azure Portal:** Sign in to the Azure portal (portal.azure.com) with an account that has permissions to manage Azure AD. 2. **Navigate to Azure Active Directory:** Search for "Azure Active Directory" in the search bar and select it. 3. **App Registrations:** In the Azure Active Directory blade, click on "App registrations" in the left-hand menu. 4. **New Registration:** Click on "+ New registration". 5. **Register an application:** * **Name:** Give your application a descriptive name (e.g., "SharePointOnlineBackend"). * **Supported account types:** Choose the appropriate option. For most scenarios, "Accounts in this organizational directory only" is sufficient. If you need to support users from other organizations, choose "Accounts in any organizational directory (Any Azure AD directory - Multitenant)". * **Redirect URI (optional):** This is important for interactive authentication (user login). If your application will have a web UI, enter the URL where Azure AD will redirect the user after authentication (e.g., `https://localhost:5001/signin-oidc` for a local ASP.NET Core application). If it's a purely backend application (e.g., a console application or an API), you might not need a redirect URI, or you can use `urn:ietf:wg:oauth:2.0:oob` for out-of-band authentication (less common for server-side apps). You can add/modify redirect URIs later. * Click **Register**. 6. **Application (client) ID:** After the registration is complete, you'll see the application overview. **Copy the "Application (client) ID"**. You'll need this later. 7. **Directory (tenant) ID:** Also on the overview page, **copy the "Directory (tenant) ID"**. You'll need this as well. 8. **Client Secret (if using client credentials flow):** If you're using the client credentials flow (for unattended access, where no user is present), you'll need to create a client secret. * In the left-hand menu, click on "Certificates & secrets". * Click on "+ New client secret". * Add a description and choose an expiration duration. * Click "Add". * **Copy the "Value" of the client secret immediately!** You won't be able to see it again. This is your client secret. Treat it like a password. 9. **API Permissions:** You need to grant your application permissions to access SharePoint Online. * In the left-hand menu, click on "API permissions". * Click on "+ Add a permission". * Select "Microsoft Graph". (SharePoint Online is accessed through the Microsoft Graph API.) * Choose "Delegated permissions" (if you want to act on behalf of a user) or "Application permissions" (if you want to act as the application itself). **Application permissions are generally preferred for server-side applications that need unattended access.** * Search for "Sites.Read.All", "Sites.Write.All", "Sites.Manage.All", or other relevant SharePoint permissions. Choose the permissions that your application needs. **Be as specific as possible and only request the permissions you need.** For example, if you only need to read site data, choose "Sites.Read.All". * Click "Add permissions". * **Grant admin consent:** After adding the permissions, you'll likely need to grant admin consent for your organization. Click the "Grant admin consent for [Your Organization]" button and confirm. This requires an account with Global Administrator or SharePoint Administrator privileges. If you don't have these privileges, you'll need to ask your administrator to grant consent. **3. Create an ASP.NET Core Web API Project:** 1. **Create a new project:** Open Visual Studio or VS Code and create a new ASP.NET Core Web API project. 2. **Install NuGet Packages:** Add the following NuGet packages to your project: ```bash dotnet add package Microsoft.Identity.Web dotnet add package Microsoft.Identity.Web.MicrosoftGraph dotnet add package Microsoft.Graph dotnet add package Microsoft.Graph.Core ``` * `Microsoft.Identity.Web`: Provides authentication and authorization support for Azure AD. * `Microsoft.Identity.Web.MicrosoftGraph`: Simplifies using Microsoft Graph with `Microsoft.Identity.Web`. * `Microsoft.Graph`: The official Microsoft Graph SDK for .NET. * `Microsoft.Graph.Core`: Core components for the Microsoft Graph SDK. **4. Configure Authentication and Authorization:** 1. **`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 Application (client) ID]", "ClientSecret": "[Your Client Secret (if using client credentials flow)]", "Scopes": "https://graph.microsoft.com/.default" // Important for app permissions }, "Logging": { "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" } }, "AllowedHosts": "*" } ``` * `Instance`: Usually `https://login.microsoftonline.com/` for global Azure. * `TenantId`: Your Azure AD tenant ID. * `ClientId`: Your application (client) ID. * `ClientSecret`: Your client secret (only needed for client credentials flow). If you're using delegated permissions, you might not need this. * `Scopes`: This is crucial. For application permissions, use `https://graph.microsoft.com/.default`. This tells Azure AD that you want to use all the application permissions you configured in the Azure portal. For delegated permissions, you would list the specific scopes you need (e.g., `Sites.Read.All`, `Sites.Write.All`). 2. **`Program.cs`:** Configure authentication and authorization in your `Program.cs` file: ```csharp using Microsoft.AspNetCore.Authentication; using Microsoft.AspNetCore.Authentication.JwtBearer; using Microsoft.Identity.Web; using Microsoft.Graph; var builder = WebApplication.CreateBuilder(args); // Add services to the container. builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) .AddMicrosoftIdentityWebApi(builder.Configuration.GetSection("AzureAd")); builder.Services.AddControllers(); // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle builder.Services.AddEndpointsApiExplorer(); builder.Services.AddSwaggerGen(); // Add Microsoft Graph service (important!) builder.Services.AddMicrosoftGraph(builder.Configuration.GetSection("AzureAd")); 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(); ``` * `AddAuthentication` and `AddMicrosoftIdentityWebApi`: Configures Azure AD authentication. * `AddMicrosoftGraph`: Registers the Microsoft Graph client for dependency injection. This makes it easy to use the `GraphServiceClient` in your controllers. **5. Create a Controller to Access SharePoint Online:** 1. **Create a new controller:** Create a new API controller (e.g., `SharePointController.cs`). 2. **Inject the `GraphServiceClient`:** Use dependency injection to get an instance of the `GraphServiceClient`. 3. **Access SharePoint Online:** Use the `GraphServiceClient` to interact with SharePoint Online. Here's an example of how to get a list of sites: ```csharp using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; using Microsoft.Graph; using Microsoft.Identity.Web; namespace YourProjectName.Controllers { [Authorize] // Requires authentication [ApiController] [Route("[controller]")] public class SharePointController : ControllerBase { private readonly GraphServiceClient _graphServiceClient; private readonly ILogger<SharePointController> _logger; public SharePointController(GraphServiceClient graphServiceClient, ILogger<SharePointController> logger) { _graphServiceClient = graphServiceClient; _logger = logger; } [HttpGet("sites")] public async Task<IActionResult> GetSites() { try { var sites = await _graphServiceClient.Sites.Request().GetAsync(); return Ok(sites); } catch (ServiceException ex) { _logger.LogError(ex, "Error getting sites"); return StatusCode((int)ex.StatusCode, ex.Message); } } [HttpGet("site/{siteId}/lists")] public async Task<IActionResult> GetLists(string siteId) { try { var lists = await _graphServiceClient.Sites[siteId].Lists.Request().GetAsync(); return Ok(lists); } catch (ServiceException ex) { _logger.LogError(ex, "Error getting lists for site {SiteId}", siteId); return StatusCode((int)ex.StatusCode, ex.Message); } } } } ``` * `[Authorize]`: This attribute ensures that only authenticated users can access the controller's actions. * `_graphServiceClient`: The injected `GraphServiceClient` instance. * `GetSites()`: Retrieves a list of SharePoint sites. * `GetLists(string siteId)`: Retrieves a list of lists (e.g., document libraries, lists) for a specific site. * Error handling: The `try...catch` block handles potential `ServiceException` errors from the Microsoft Graph API. It logs the error and returns an appropriate HTTP status code. **6. Testing:** 1. **Run the application:** Run your ASP.NET Core Web API application. 2. **Use Swagger or Postman:** Use Swagger (if enabled) or Postman to send requests to your API endpoints. 3. **Authentication:** You'll need to obtain an access token from Azure AD to authenticate your requests. The easiest way to do this during development is to use the `dotnet user-jwts` tool (if you're using delegated permissions) or to manually request a token using Postman or a similar tool. For production, you'll typically use a library like `Microsoft.Identity.Web` to handle token acquisition. **Important Considerations:** * **Error Handling:** Implement robust error handling to gracefully handle exceptions and provide informative error messages to the client. * **Logging:** Use logging to track application behavior and diagnose issues. * **Security:** Protect your client secret (if you're using the client credentials flow). Don't store it directly in your code or configuration files. Use Azure Key Vault or a similar secret management solution. * **Rate Limiting:** Be aware of Microsoft Graph's rate limits. Implement retry logic and consider using caching to reduce the number of requests you make. * **Permissions:** Request only the permissions that your application needs. Avoid requesting overly broad permissions. * **Asynchronous Operations:** Use asynchronous operations (`async` and `await`) to avoid blocking the main thread and improve performance. * **Client Credentials Flow vs. Delegated Permissions:** Choose the appropriate authentication flow based on your application's requirements. Client credentials flow is suitable for unattended access, while delegated permissions are used when you need to act on behalf of a user. * **Incremental Consent:** If you need more permissions later, you can request them incrementally. This is a good practice to avoid overwhelming users with a large list of permissions upfront. **Example of getting an access token using Postman (for testing with delegated permissions):** 1. **Configure Postman:** * Open Postman. * Create a new request. * Set the request type to `POST`. * Enter the following URL: `https://login.microsoftonline.com/[Your Tenant ID]/oauth2/v2.0/token` * Go to the "Body" tab and select "x-www-form-urlencoded". * Add the following key-value pairs: * `grant_type`: `password` * `client_id`: `[Your Application (client) ID]` * `client_secret`: `[Your Client Secret]` * `username`: `[Your User Principal Name (UPN) - e.g., user@yourdomain.com]` * `password`: `[Your User's Password]` * `scope`: `Sites.Read.All Sites.Write.All` (or the scopes you need) 2. **Send the request:** Click "Send". 3. **Get the access token:** The response will contain an `access_token`. Copy this token. 4. **Use the access token in your API requests:** * In Postman, create a new request to your API endpoint (e.g., `https://localhost:5001/sharepoint/sites`). * Go to the "Headers" tab. * Add a header with the following key-value pair: * `Authorization`: `Bearer [Your Access Token]` 5. **Send the API request:** Click "Send". You should now be able to access your API endpoint. **Vietnamese Translation of Key Concepts:** * **Azure Active Directory (Azure AD):** Thư mục hoạt động Azure (Azure AD) * **Application (client) ID:** ID ứng dụng (khách hàng) * **Directory (tenant) ID:** ID thư mục (người thuê) * **Client Secret:** Mật khẩu khách hàng * **API Permissions:** Quyền API * **Microsoft Graph:** Microsoft Graph * **Access Token:** Mã truy cập * **Authentication:** Xác thực * **Authorization:** Ủy quyền * **SharePoint Online:** SharePoint Online * **Delegated Permissions:** Quyền được ủy quyền * **Application Permissions:** Quyền ứng dụng * **Client Credentials Flow:** Luồng thông tin xác thực khách hàng This comprehensive guide should help you create a .NET Core Web API that can access SharePoint Online. Remember to adapt the code and configuration to your specific requirements. Good luck!

Superset MCP Server - TypeScript

Enables AI assistants to interact with Apache Superset instances programmatically, providing 45+ tools for dashboard management, chart creation, database operations, SQL execution, and complete Superset API coverage. Supports multiple transport modes including stdio, SSE, and HTTP streaming for flexible deployment options.

lineageverse-mcp

MCP server for single-cell lineage tracing analysis, enabling conversational reconstruction, visualization, and heritability analysis of lineage trees using Cassiopeia, pycea, and treedata.

AutoEQ MCP Server

Provides access to a database of over 8,800 headphones and IEMs for equalization settings, sound signature analysis, and Harman preference scores. It enables AI assistants to search, compare, and recommend headphones based on frequency response measurements and parametric EQ profiles.

memora

Persistent memory with knowledge graph visualization, semantic/hybrid search, importance scoring, and cloud sync (S3/R2) for cross-session context management.

CSMAR MCP Server

Enables direct access to CSMAR financial databases through Claude Code. Supports 240+ databases including financial statements, stock trading data, and company information with intelligent login management and 11 MCP tools.

Outline MCP Server

An MCP server that enables reading, writing, and searching documents in Outline via its API. It supports document management, full-text search, and collection organization using Markdown formatting.

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.

imap-mail-mcp

An MCP server that lets Claude read, search, and send email over standard IMAP/SMTP.

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.

DadMCP

Remote MCP server for providing better education at home

DebugPilot

Enables AI agents to inspect debug state, control execution, and set breakpoints in VS Code by exposing the Debug Adapter Protocol as an MCP server.