Discover Awesome MCP Servers

mcp-server-chart

mcp-server-chart

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 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.

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.

Crypto Price & Market Analysis MCP Server

Provides comprehensive cryptocurrency analysis using the CoinCap API, offering real-time price data, market analysis across exchanges, and historical price trends for any cryptocurrency.

float-mcp

A community MCP server for float.com.

Pokémcp

Un servidor de Protocolo de Contexto de Modelo que proporciona información de Pokémon conectándose a la PokeAPI, permitiendo a los usuarios consultar datos detallados de Pokémon, descubrir Pokémon aleatorios y encontrar Pokémon por región o tipo.

kubevirt-mcp-server

Un servidor de Protocolo de Contexto de Modelo simple para KubeVirt

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 **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.

Splunk MCP Server

Enables AI assistants to interact with Splunk Enterprise and Splunk Cloud instances through standardized MCP interface. Supports executing SPL queries, managing indexes and saved searches, listing applications, and retrieving server information with flexible authentication options.

MCP Python SDK Documentation

Here are a few ways to translate that, depending on the nuance you want to convey: **More literal:** * **Español:** Lee la documentación para el hackathon de MCP, la IA descentralizada del MIT. **Slightly more natural, emphasizing the "Read the docs" part:** * **Español:** Consulta la documentación del hackathon de MCP, la IA descentralizada del MIT. **Emphasizing the purpose of the documentation:** * **Español:** Lee la documentación para informarte sobre el hackathon de MCP, la IA descentralizada del MIT. **Which one is best depends on the context. If you're telling someone to go look up the information, the second option is probably best.**

MongoDB MCP Server for LLMs

A Model Context Protocol (MCP) server that enables LLMs to interact directly with MongoDB databases, allowing them to query collections, inspect schemas, and manage data seamlessly through natural language.

MCP Interface for Teenage Engineering EP-133 K.O. II

Here are a few ways you could translate "MCP Server for Teenage Engineering EP-133 KO-II" into Spanish, depending on the context: * **Servidor MCP para Teenage Engineering EP-133 KO-II:** This is a direct translation and is likely the best option if you're talking about a specific server application or software. "MCP" is often used as is in Spanish in technical contexts. * **Servidor de MCP para Teenage Engineering EP-133 KO-II:** This is also a direct translation, but it includes the "de" which can be more grammatically correct in some contexts. * **Servidor MCP para el EP-133 KO-II de Teenage Engineering:** This version reorders the phrase slightly to emphasize the EP-133 KO-II and uses "el" before the model number. The best option depends on the specific context of your conversation. If you are referring to a specific software or application, the first option is likely the best. If you are simply referring to a server that is compatible with the device, the second or third option may be more appropriate.

DadMCP

Servidor MCP remoto para brindar una mejor educación en casa.

Guardrail MCP Server

A minimal Model Context Protocol server that provides a safety guardrail tool to check if provided context is free from code injection or harmful content.

Screenshot Server

Enables capturing screenshots of web pages and local HTML files through a simple MCP tool interface using Puppeteer with configurable options for dimensions and output paths.

MCP Obsidian

Una implementación de servidor que permite a los asistentes de IA leer, crear y manipular notas en bóvedas de Obsidian a través del Protocolo de Contexto del Modelo.

monday MCP Server

monday MCP Server

MCP RAG Server

Un servidor de Protocolo de Conversación con Máquinas que permite a los agentes de IA realizar Generación Aumentada por Recuperación (Retrieval-Augmented Generation) consultando una base de datos vectorial FAISS que contiene documentos del lenguaje Sui Move.

DolphinScheduler MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los agentes de IA interactuar con Apache DolphinScheduler a través de un protocolo estandarizado, habilitando la gestión de flujos de trabajo impulsada por la IA.

nativeMCP

Aquí hay un sistema MCP escrito en C++ que incluye la arquitectura central de MCP: host, cliente y servidor.

Google Search MCP

Una herramienta basada en Playwright que realiza búsquedas en Google y extrae resultados, evitando los mecanismos anti-bot, proporcionando capacidades de búsqueda en tiempo real para asistentes de IA.

Agentic-AI-Projects

Acerca de: Este repositorio presenta una colección de proyectos de IA agentiva en diversos dominios, mostrando aplicaciones prácticas de agentes de IA con diferentes marcos de trabajo, técnicas y herramientas.

MCP SSE Server

Una implementación del protocolo de contexto del modelo (MCP) del lado del servidor que utiliza eventos enviados por el servidor (SSE) para la comunicación en tiempo real, proporcionando herramientas para cálculos y plantillas de recursos dinámicas.

MCP Play Sound Server

Provides audio playback functionality for AI agents, allowing them to play notification sounds when coding tasks are completed.

RemoteZip MCP Server

Enables accessing and extracting files from remote zip archives over HTTP, HTTPS, and FTP without downloading the entire archive. Supports listing files, extracting individual files, and getting file information using partial reading techniques.

MCP Servers

Una herramienta que permite el control automatizado del navegador utilizando Pyppeteer dentro del marco de trabajo MCP, permitiendo la navegación, la captura de pantalla y la interacción con elementos de sitios web.

Undoom Uninstaller MCP

Enables Windows program management through MCP, including listing installed programs, uninstalling software, force removal, and cleaning residual files. Supports generating detailed Markdown reports of system programs with smart categorization and statistics.