Discover Awesome MCP Servers

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.

MySQL MCP Server

An MCP server that allows working with MySQL databases by providing tools for executing read-only SQL queries, getting table schemas, and listing database tables.

mcp-server-chart

mcp-server-chart

@lucairn/mcp-server

Privacy-preserving AI gateway. Sanitises PII before prompts reach Anthropic / OpenAI / your LLM, then emits a signed cryptographic certificate per call (Ed25519 + RFC 3161 + Sigstore Rekor). EU GDPR + AI Act ready. Free tier 500/mo with BYOK.

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!

Poetry MCP Server

Manages poetry catalogs with state-based tracking, thematic connections via nexuses, quality scoring across 8 dimensions, and submission tracking to literary venues, treating poems as artifacts with metadata stored in markdown frontmatter.

mcp-nativewind

Chuyển đổi các thành phần Tailwind sang NativeWind 4.

skills-mcp-server

Exposes Cursor-style skill packs (SKILL.md trees) via MCP resources, tools, and prompts, enabling any MCP client to list, get, search skills, and retrieve skill context.

Azure Pricing MCP Server

Enables querying Azure retail pricing information, comparing costs across regions and SKUs, estimating usage-based expenses, and discovering Azure services with savings plan information through the Azure Retail Prices API.

PDF Generator API MCP Server

This MCP server enables interactions with the PDF Generator API for creating, converting, and managing PDF documents using natural language commands.

Survey Cross-Analysis MCP Server

An AI-driven tool for processing survey data that supports cross-tabulation, NPS and satisfaction scoring, and automated Excel report generation. It enables users to analyze datasets via natural language for tasks like merging response options and identifying demographic differences.

MCP Server

Provides SMTP integration for sending HTML emails and specialized prompts for intent detection and client information extraction. It enables LLMs to automate personalized email workflows and structure user communication data.

crypto-stocks-mcp

An MCP server that tracks real-time data for major crypto-related stocks to help AI agents analyze blockchain investment opportunities.

Browser MCP Bridge

Bridges browser content, developer tools data, and web page interactions with Claude through MCP. Enables page inspection, DOM analysis, JavaScript execution, console monitoring, network activity tracking, and screenshot capture across multiple browser tabs.

Tailscale MCP Server

Enables interaction with the Tailscale API to manage devices, ACLs, keys, and DNS configurations directly from MCP clients like Claude Desktop or Raycast.

Nerdearla Agenda MCP Server

Provides real-time access to the Nerdearla conference agenda, enabling users to query upcoming talks, past sessions, topic recommendations, and event schedules through natural language interactions.

kovex-dental-marketing

AI-powered dental social media marketing tools. Generate Instagram captions, find hashtags, get benchmarks, and discover content ideas for dental practices.

Medusa Mcp

Máy chủ MCP cho Medusa JS SDK

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.

Vanta MCP Server

Enables management of Vanta compliance platform resources including controls, vulnerabilities, vendors, and policies through natural language. Supports multi-tenant OAuth2 authentication for secure access to security and compliance data.

Node MCP Server

A minimal Express-based MCP server that exposes a weather tool through HTTP endpoints, demonstrating how to implement the Model Context Protocol with streamable HTTP transport.

MCP Brain Service

Enables character management and semantic search for the Auto-Movie application through WebSocket communication. Supports creating characters with personality/appearance descriptions and finding similar characters using natural language queries with embedding-based similarity matching.

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.

Unified Auth0 MCP Server

An MCP server that enables Claude Code to access Auth0-protected APIs by handling OAuth authentication flows and securely proxying API requests with user credentials.

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

Remote MCP server for providing better education at home