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 Proxy (MCP)** server to access SharePoint Online. However, it's important to clarify that "MCP server" isn't a standard term or product directly provided by Microsoft for accessing SharePoint Online. It sounds like you're looking for a way to securely and potentially programmatically access SharePoint Online data from an application or service, possibly with some form of proxy or intermediary. Here's a breakdown of how you can achieve this, along with explanations and code examples (where applicable), focusing on the most common and recommended approaches: **Understanding the Goal** Before diving into the technical details, let's clarify what you're trying to accomplish: * **Secure Access:** You want to access SharePoint Online data securely, likely without exposing your credentials directly in your application. * **Programmatic Access:** You need to access SharePoint Online data programmatically, meaning through code (e.g., C#, Python, JavaScript). * **Potential Proxy/Intermediary:** You might want to use a proxy server or intermediary service for added security, control, or to handle authentication. * **Specific Use Case:** What are you trying to *do* with the SharePoint data? Read files? Update lists? Search? The specific actions will influence the best approach. **Recommended Approaches** Here are the most common and recommended ways to access SharePoint Online programmatically: 1. **Microsoft Graph API:** This is the *preferred* and most modern way to access SharePoint Online data. It provides a unified endpoint for accessing various Microsoft 365 services, including SharePoint. 2. **SharePoint REST API:** This is a more direct way to interact with SharePoint Online using RESTful web services. It's still supported, but Microsoft Graph is generally recommended for new development. 3. **SharePoint Client-Side Object Model (CSOM):** This is a .NET library that allows you to interact with SharePoint Online programmatically. It's often used in .NET applications. 4. **Azure Active Directory (Azure AD) App Registration:** This is a *critical* step for all of these approaches. You need to register an application in Azure AD to obtain the necessary credentials (client ID and client secret) to authenticate with SharePoint Online. **Detailed Steps and Examples** Let's walk through the steps using the Microsoft Graph API, as it's the recommended approach: **1. Register an Application in Azure AD** * **Go to the Azure Portal:** Sign in to the Azure portal (portal.azure.com) with an account that has permissions to manage Azure Active Directory. * **Navigate to Azure Active Directory:** Search for "Azure Active Directory" in the search bar and select it. * **App Registrations:** In the Azure Active Directory blade, click on "App registrations." * **New Registration:** Click on "New registration." * **Name:** Give your application a descriptive name (e.g., "SharePointDataAccessor"). * **Supported Account Types:** Choose the appropriate account type. "Accounts in this organizational directory only" is usually sufficient for internal applications. "Accounts in any organizational directory" is for multi-tenant applications. * **Redirect URI (Optional):** If your application is a web application or uses an authentication flow that requires a redirect URI, enter it here. For console applications or background services, you might not need a redirect URI. * **Register:** Click "Register." **Important Information:** * **Application (Client) ID:** After the registration is complete, you'll see the application's overview page. Note down the **Application (client) ID**. You'll need this later. * **Directory (Tenant) ID:** Also note down the **Directory (tenant) ID**. * **Client Secret (Password):** Go to "Certificates & secrets" in the left-hand menu. Click on "New client secret." Give the secret a description and an expiration time. **Copy the value of the secret immediately!** You won't be able to see it again. This is your client secret. Treat it like a password. **2. Grant API Permissions** * **API Permissions:** In your app registration, go to "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:** Choose the appropriate type of permission: * **Delegated Permissions:** The application acts on behalf of a signed-in user. The user must consent to the permissions. Use this if you want the application to access SharePoint data as a specific user. * **Application Permissions:** The application acts on its own, without a signed-in user. Use this for background services or applications that need to access SharePoint data without user interaction. **Requires administrator consent.** * **Select Permissions:** Search for the SharePoint permissions you need. Here are some common ones: * `Sites.Read.All`: Read access to all SharePoint sites. * `Sites.ReadWrite.All`: Read and write access to all SharePoint sites. * `Files.Read.All`: Read access to all files the user can access. * `Files.ReadWrite.All`: Read and write access to all files the user can access. * `Sites.Selected`: Allows access to specific sites. This is the most secure option if you only need access to a few sites. You'll need to configure the specific sites in the SharePoint admin center. * **Add Permissions:** Click "Add permissions." * **Grant Admin Consent:** If you selected application permissions, you'll need to grant admin consent. Click on "Grant admin consent for [Your Organization]." You'll need to be a global administrator or have the appropriate permissions to do this. **3. Code Example (C# with Microsoft Graph)** This example shows how to authenticate with Azure AD and retrieve a list of SharePoint sites using the Microsoft Graph API in C#. You'll need to install the `Microsoft.Graph` and `Microsoft.Identity.Client` NuGet packages. ```csharp using Microsoft.Graph; using Microsoft.Identity.Client; using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; namespace SharePointGraphExample { class Program { private static string _clientId = "YOUR_APPLICATION_CLIENT_ID"; // Replace with your Application (client) ID private static string _tenantId = "YOUR_TENANT_ID"; // Replace with your Directory (tenant) ID private static string _clientSecret = "YOUR_CLIENT_SECRET"; // Replace with your client secret private static GraphServiceClient _graphClient; static async Task Main(string[] args) { _graphClient = GetGraphServiceClient(); try { var sites = await GetSharePointSites(); Console.WriteLine("SharePoint Sites:"); foreach (var site in sites) { Console.WriteLine($"- {site.DisplayName} ({site.WebUrl})"); } } catch (Exception ex) { Console.WriteLine($"Error: {ex}"); } Console.ReadKey(); } private static GraphServiceClient GetGraphServiceClient() { IConfidentialClientApplication confidentialClientApplication = ConfidentialClientApplicationBuilder .Create(_clientId) .WithTenantId(_tenantId) .WithClientSecret(_clientSecret) .Build(); List<string> scopes = new List<string> { "https://graph.microsoft.com/.default" }; // Use .default for application permissions return new GraphServiceClient(new DelegateAuthenticationProvider(async (requestMessage) => { // Acquire token silently var authResult = await confidentialClientApplication.AcquireTokenForClient(scopes).ExecuteAsync(); // Add the access token to the request. requestMessage.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authResult.AccessToken); })); } private static async Task<List<Site>> GetSharePointSites() { var sites = new List<Site>(); try { var result = await _graphClient.Sites.Root.Sites.Request().GetAsync(); sites.AddRange(result.CurrentPage); // Handle pagination (if there are more than one page of results) while (result.NextPageRequest != null) { result = await result.NextPageRequest.GetAsync(); sites.AddRange(result.CurrentPage); } } catch (Exception ex) { Console.WriteLine($"Error getting sites: {ex}"); } return sites; } } } ``` **Explanation:** * **NuGet Packages:** Install `Microsoft.Graph` and `Microsoft.Identity.Client`. * **Configuration:** Replace `YOUR_APPLICATION_CLIENT_ID`, `YOUR_TENANT_ID`, and `YOUR_CLIENT_SECRET` with the values you obtained from the Azure AD app registration. * **`GetGraphServiceClient()`:** This method creates a `GraphServiceClient` instance, which is the main entry point for interacting with the Microsoft Graph API. It uses the `ConfidentialClientApplicationBuilder` to authenticate with Azure AD using the client ID, tenant ID, and client secret. The `.default` scope is used for application permissions, which means the application is requesting access to all the permissions it has been granted. * **`GetSharePointSites()`:** This method retrieves a list of SharePoint sites using the `_graphClient.Sites.Root.Sites.Request().GetAsync()` method. It also handles pagination to retrieve all sites, even if there are more than one page of results. * **Error Handling:** The code includes basic error handling to catch exceptions and display error messages. **4. Using a Proxy (If Needed)** If you need to use a proxy server for network access or security reasons, you can configure the `HttpClient` used by the `GraphServiceClient`. Here's how you can modify the `GetGraphServiceClient()` method to use a proxy: ```csharp private static GraphServiceClient GetGraphServiceClient() { IConfidentialClientApplication confidentialClientApplication = ConfidentialClientApplicationBuilder .Create(_clientId) .WithTenantId(_tenantId) .WithClientSecret(_clientSecret) .Build(); List<string> scopes = new List<string> { "https://graph.microsoft.com/.default" }; // Configure the proxy var proxy = new System.Net.WebProxy { Address = new Uri("http://your.proxy.server:8888"), // Replace with your proxy server address and port // Optionally, add credentials if your proxy requires authentication // Credentials = new System.Net.NetworkCredential("username", "password") }; var httpClientHandler = new System.Net.Http.HttpClientHandler { Proxy = proxy, UseProxy = true }; var httpClient = new System.Net.Http.HttpClient(httpClientHandler); return new GraphServiceClient(httpClient, new DelegateAuthenticationProvider(async (requestMessage) => { // Acquire token silently var authResult = await confidentialClientApplication.AcquireTokenForClient(scopes).ExecuteAsync(); // Add the access token to the request. requestMessage.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authResult.AccessToken); })); } ``` **Important Considerations for Proxies:** * **Proxy Address and Port:** Replace `"http://your.proxy.server:8888"` with the actual address and port of your proxy server. * **Proxy Authentication:** If your proxy server requires authentication, uncomment the `Credentials` line and provide the appropriate username and password. * **Security:** Be careful when storing proxy credentials in your code. Consider using environment variables or a secure configuration store. **5. Alternative Approaches (SharePoint REST API, CSOM)** * **SharePoint REST API:** You can use the SharePoint REST API directly by making HTTP requests to SharePoint Online endpoints. You'll need to obtain an access token using Azure AD and include it in the `Authorization` header of your requests. Refer to the Microsoft documentation for the specific endpoints and request formats. * **SharePoint CSOM:** The SharePoint CSOM is a .NET library that provides a more object-oriented way to interact with SharePoint Online. You'll need to install the `Microsoft.SharePointOnline.CSOM` NuGet package. The authentication process is similar to the Microsoft Graph API, using Azure AD to obtain an access token. **Important Security Considerations:** * **Least Privilege:** Grant your application only the *minimum* permissions it needs to access SharePoint Online data. Avoid granting broad permissions like `Sites.ReadWrite.All` if you only need to access a few specific sites. `Sites.Selected` is the most secure option when possible. * **Secure Storage of Credentials:** Never hardcode your client secret directly in your code. Use environment variables, Azure Key Vault, or a secure configuration store to protect your credentials. * **Regularly Rotate Secrets:** Rotate your client secrets regularly to minimize the risk of compromise. * **Monitor API Usage:** Monitor your application's API usage to detect any suspicious activity. * **Implement Proper Error Handling:** Implement robust error handling to prevent sensitive information from being exposed in error messages. * **Use Managed Identities (If Applicable):** If your application is running in Azure (e.g., Azure Functions, Azure App Service), consider using Managed Identities for Azure Resources. This eliminates the need to manage credentials manually. **Summary** Creating a secure and reliable way to access SharePoint Online data programmatically involves several steps: 1. **Azure AD App Registration:** Register your application in Azure AD and obtain the client ID, tenant ID, and client secret. 2. **API Permissions:** Grant your application the necessary SharePoint API permissions. 3. **Authentication:** Use the Microsoft Graph API or SharePoint REST API to authenticate with Azure AD and obtain an access token. 4. **Data Access:** Use the access token to make requests to SharePoint Online endpoints to retrieve or modify data. 5. **Security:** Follow security best practices to protect your credentials and minimize the risk of unauthorized access. 6. **Proxy (Optional):** Configure a proxy server if needed for network access or security reasons. Remember to choose the approach that best suits your specific needs and security requirements. The Microsoft Graph API is generally the recommended approach for new development. Always prioritize security and follow best practices to protect your SharePoint Online data. Let me know if you have any more specific questions or if you'd like me to elaborate on any of these steps. For example, if you tell me what you want to *do* with the SharePoint data, I can give you a more tailored example.

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.