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

✨ Bản Demo Máy Chủ 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 (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!

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

Chuyển đổi các thành phần Tailwind sang 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

Một router AI kết nối các ứng dụng với nhiều nhà cung cấp LLM (OpenAI, Anthropic, Google, DeepSeek, Ollama, v.v.) với các khả năng điều phối mô hình thông minh, cho phép chuyển đổi động giữa các mô hình cho các tác vụ suy luận khác nhau.

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

Cho phép tương tác với các cửa hàng Shopify thông qua GraphQL API, cung cấp các công cụ để quản lý sản phẩm, khách hàng, đơn hàng và nhiều hơn nữa.

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

Máy chủ MCP Tushare Rust

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

Các Công cụ MCP của chúng tôi được thiết kế để tăng cường các dịch vụ phỏng vấn tự động do AI điều khiển bằng cách đảm bảo một quy trình đánh giá ứng viên liền mạch và phù hợp với ngữ cảnh. Các công cụ này tận dụng các mô hình AI tiên tiến để phân tích phản hồi, đánh giá năng lực và cung cấp phản hồi theo thời gian thực, ma

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.