Discover Awesome MCP Servers

skilltap

Exposes MCP tools to list, search, and load Markdown skills from a local folder, enabling coding agents to discover and reuse procedural knowledge.

ZenTao MCP Server

Enables interaction with ZenTao project management system through RESTful APIs. Supports listing products, managing bugs, viewing statistics, and filtering personal bug assignments through natural language.

Arcate MCP Connect

Gives AI agents direct access to your Arcate product discovery workspace to read signals, browse roadmaps, and ingest new customer feedback. It enables users to search existing data and link signals to initiatives through natural language commands.

lab-units-mcp

Converts clinical blood-test results between conventional and SI units and resolves lab-marker names to canonical analytes.

aspicio-dxf-viewer

Opens, inspects, and renders DXF/CAD drawings for AI agents: describe_dxf returns structured facts (layers with actual drawn colors, units, bounds, text content) and render_dxf returns PNG images. On MCP Apps hosts like ChatGPT and Claude, view_dxf opens an interactive in-chat viewer with pan, zoom, and layer toggles.

Halo ITSM MCP Server

Enables AI-driven IT service management by exposing the full Halo ITSM REST API through 172 tools across 43 resource domains to any MCP-compatible client.

sophotron

MCP server for searching and retrieving philosophy papers, combining Semantic Scholar, OpenAlex, Unpaywall, CrossRef, and PhilArchive with PDF resolution, taxonomy browsing, and a personal library.

MetaVision AI Studio

Generate 3D models from text or image. Browse 10K+ free 3D models. AI creative platform with API

Microsoft Fabric RTI MCP Server

Enables AI agents to interact with Microsoft Fabric Real-Time Intelligence services, allowing for seamless data querying, analysis, and streaming capabilities.

web-scrapper-stdio

A headless web scraping server that extracts main content from web pages into Markdown, text, or HTML for AI and automation integration. It features per-domain rate limiting and robust error handling using Playwright and BeautifulSoup.

Tribunal TJSC: Processo

Enables consultation of TJSC court processes from official source through a read-only MCP tool.

Untappd MCP Server using Azure Functions

Okay, here's an example of a minimal, complete, and practical (MCP) Azure Function written in F# that demonstrates a simple HTTP trigger. I'll break down the code and explain the key parts. ```fsharp namespace MyFunctionApp open System.Net open Microsoft.AspNetCore.Mvc open Microsoft.Azure.WebJobs open Microsoft.Azure.WebJobs.Extensions.Http open Microsoft.AspNetCore.Http open Microsoft.Extensions.Logging module HelloFunction = [<FunctionName("Hello")>] let Run ( [<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)>] req: HttpRequest, log: ILogger ) = task { log.LogInformation "C# HTTP trigger function processed a request." let name = match req.Query.["name"] with | ValueSome n -> n | ValueNone -> match new System.IO.StreamReader(req.Body).ReadToEndAsync().Result with | null -> "Azure Functions" | body -> try let parsedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<{| name: string |}>(body) match parsedBody.name with | null -> "Azure Functions" | name -> name with | _ -> "Azure Functions" let responseMessage = sprintf "Hello, %s. This HTTP triggered function executed successfully." name return OkObjectResult responseMessage :> IActionResult } ``` **Explanation:** 1. **Namespaces:** - `namespace MyFunctionApp`: This defines the namespace for your function app. Choose a meaningful name. 2. **`open` Statements:** - These import necessary namespaces. Crucially: - `Microsoft.Azure.WebJobs`: Provides the core attributes for defining Azure Functions. - `Microsoft.Azure.WebJobs.Extensions.Http`: Provides the HTTP trigger attributes. - `Microsoft.AspNetCore.Mvc`: Provides `IActionResult` for returning HTTP responses. - `Microsoft.AspNetCore.Http`: Provides `HttpRequest` for accessing the HTTP request. - `Microsoft.Extensions.Logging`: Provides `ILogger` for logging. - `System.Net`: Provides `HttpStatusCode` for setting HTTP status codes. 3. **`module HelloFunction`:** - F# code is typically organized into modules. This module contains our function. 4. **`[<FunctionName("Hello")>]`:** - This attribute is *essential*. It tells Azure Functions the name of your function. This is the name you'll use in the Azure portal and in your function URL. Change `"Hello"` to whatever you want to call your function. 5. **`let Run (...) = task { ... }`:** - This defines the `Run` function, which is the entry point for your Azure Function. The `task { ... }` block indicates that this function is asynchronous (it returns a `Task`). This is important for performance in Azure Functions. 6. **Function Parameters:** - `[<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)>] req: HttpRequest`: - This is the HTTP trigger. It tells Azure Functions that this function should be triggered by HTTP requests. - `AuthorizationLevel.Anonymous`: Means anyone can call the function without authentication. Other options are `Function` (requires a function-specific key) and `Admin` (requires the master key). - `"get", "post"`: Specifies that the function will respond to both GET and POST requests. - `Route = null`: Specifies that there is no custom route. The function URL will be based on the function name. If you set `Route = "myroute/{id}"`, the URL would be something like `/api/myroute/123`. - `req: HttpRequest`: This is the HTTP request object. You can use it to access headers, query parameters, the request body, etc. - `log: ILogger`: This is the logger object. Use it to write log messages to Azure's logging system. 7. **Request Processing:** - `log.LogInformation "C# HTTP trigger function processed a request."`: Logs a message to the Azure Functions logs. Use `LogInformation`, `LogError`, `LogWarning`, etc., as appropriate. - The code then attempts to get the `name` parameter from the query string (`req.Query.["name"]`). If it's not in the query string, it tries to read the request body as JSON and extract the `name` property. If neither is found, it defaults to "Azure Functions". This is a common pattern for handling input. 8. **Response:** - `let responseMessage = sprintf "Hello, %s. This HTTP triggered function executed successfully." name`: Creates the response message. - `return OkObjectResult responseMessage :> IActionResult`: Creates an `OkObjectResult` (an HTTP 200 OK response) with the response message as the body. The `:> IActionResult` is an upcast, telling the compiler that we're returning an `IActionResult`. This is the standard way to return HTTP responses from Azure Functions. **How to Use This Code:** 1. **Create an Azure Functions Project:** - In Visual Studio, create a new project. Choose "Azure Functions" as the project type. Select "F#" as the language. Choose the "HTTP trigger" template. 2. **Replace the Template Code:** - Replace the code in the generated `Function1.fs` (or whatever the default file is named) with the code above. 3. **Install Newtonsoft.Json:** - You'll need to install the `Newtonsoft.Json` NuGet package to handle JSON deserialization. In Visual Studio, go to Tools -> NuGet Package Manager -> Manage NuGet Packages for Solution. Search for "Newtonsoft.Json" and install it. Make sure you have the `open Newtonsoft.Json` statement at the top of your file. 4. **Publish to Azure:** - Right-click on your project in Visual Studio and choose "Publish". Follow the prompts to publish your function app to Azure. You'll need an Azure subscription. **Testing:** After publishing, you can test your function: * **GET Request (Query Parameter):** Open a browser and go to the function URL (you'll find it in the Azure portal). Append `?name=YourName` to the URL. For example: `https://your-function-app-name.azurewebsites.net/api/Hello?name=John`. * **POST Request (JSON Body):** Use a tool like Postman or `curl` to send a POST request to the function URL. Set the `Content-Type` header to `application/json` and include a JSON body like this: ```json { "name": "Jane" } ``` **Key Improvements and Considerations:** * **Error Handling:** The example includes a basic `try...with` block for JSON parsing, but you should add more robust error handling. Consider logging errors and returning appropriate HTTP error codes (e.g., 400 Bad Request). * **Input Validation:** Validate the input you receive from the request. Don't assume it's always in the correct format or within acceptable ranges. * **Asynchronous Operations:** Use `async` and `await` (or `task { ... }` in F#) for any I/O-bound operations (e.g., database calls, HTTP requests to other services). This prevents your function from blocking and improves performance. * **Dependency Injection:** For more complex functions, use dependency injection to manage dependencies (e.g., database connections, configuration settings). Azure Functions supports dependency injection. * **Configuration:** Store configuration settings (e.g., database connection strings, API keys) in Azure App Configuration or Azure Key Vault, and access them through the `IConfiguration` interface. Avoid hardcoding sensitive information in your code. * **Logging:** Use the `ILogger` interface extensively to log important events, errors, and performance metrics. This will help you monitor and troubleshoot your function. * **Idempotency:** If your function performs operations that should only be executed once (e.g., processing payments), ensure that it's idempotent. This means that if the function is called multiple times with the same input, it should only perform the operation once. * **Testing:** Write unit tests to verify the logic of your function. Use mocking frameworks to isolate your function from external dependencies. **Portuguese Translation of the Explanation:** Aqui está um exemplo de uma Azure Function mínima, completa e prática (MCP) escrita em F# que demonstra um gatilho HTTP simples. Vou detalhar o código e explicar as partes principais. ```fsharp namespace MyFunctionApp open System.Net open Microsoft.AspNetCore.Mvc open Microsoft.Azure.WebJobs open Microsoft.Azure.WebJobs.Extensions.Http open Microsoft.AspNetCore.Http open Microsoft.Extensions.Logging module HelloFunction = [<FunctionName("Hello")>] let Run ( [<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)>] req: HttpRequest, log: ILogger ) = task { log.LogInformation "Função de gatilho HTTP em C# processou uma requisição." let name = match req.Query.["name"] with | ValueSome n -> n | ValueNone -> match new System.IO.StreamReader(req.Body).ReadToEndAsync().Result with | null -> "Azure Functions" | body -> try let parsedBody = Newtonsoft.Json.JsonConvert.DeserializeObject<{| name: string |}>(body) match parsedBody.name with | null -> "Azure Functions" | name -> name with | _ -> "Azure Functions" let responseMessage = sprintf "Olá, %s. Esta função disparada por HTTP foi executada com sucesso." name return OkObjectResult responseMessage :> IActionResult } ``` **Explicação:** 1. **Namespaces:** - `namespace MyFunctionApp`: Define o namespace para sua aplicação de função. Escolha um nome significativo. 2. **`open` Statements:** - Importam os namespaces necessários. Crucialmente: - `Microsoft.Azure.WebJobs`: Fornece os atributos principais para definir Azure Functions. - `Microsoft.Azure.WebJobs.Extensions.Http`: Fornece os atributos de gatilho HTTP. - `Microsoft.AspNetCore.Mvc`: Fornece `IActionResult` para retornar respostas HTTP. - `Microsoft.AspNetCore.Http`: Fornece `HttpRequest` para acessar a requisição HTTP. - `Microsoft.Extensions.Logging`: Fornece `ILogger` para registro de logs. - `System.Net`: Fornece `HttpStatusCode` para definir códigos de status HTTP. 3. **`module HelloFunction`:** - O código F# é tipicamente organizado em módulos. Este módulo contém nossa função. 4. **`[<FunctionName("Hello")>]`:** - Este atributo é *essencial*. Ele diz ao Azure Functions o nome da sua função. Este é o nome que você usará no portal do Azure e no URL da sua função. Altere `"Hello"` para o que você quiser chamar sua função. 5. **`let Run (...) = task { ... }`:** - Define a função `Run`, que é o ponto de entrada para sua Azure Function. O bloco `task { ... }` indica que esta função é assíncrona (retorna uma `Task`). Isso é importante para o desempenho no Azure Functions. 6. **Parâmetros da Função:** - `[<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)>] req: HttpRequest`: - Este é o gatilho HTTP. Ele diz ao Azure Functions que esta função deve ser disparada por requisições HTTP. - `AuthorizationLevel.Anonymous`: Significa que qualquer um pode chamar a função sem autenticação. Outras opções são `Function` (requer uma chave específica da função) e `Admin` (requer a chave mestre). - `"get", "post"`: Especifica que a função responderá a requisições GET e POST. - `Route = null`: Especifica que não há rota customizada. O URL da função será baseado no nome da função. Se você definir `Route = "myroute/{id}"`, o URL seria algo como `/api/myroute/123`. - `req: HttpRequest`: Este é o objeto de requisição HTTP. Você pode usá-lo para acessar cabeçalhos, parâmetros de consulta, o corpo da requisição, etc. - `log: ILogger`: Este é o objeto de logger. Use-o para escrever mensagens de log no sistema de log do Azure. 7. **Processamento da Requisição:** - `log.LogInformation "Função de gatilho HTTP em C# processou uma requisição."`: Registra uma mensagem nos logs do Azure Functions. Use `LogInformation`, `LogError`, `LogWarning`, etc., conforme apropriado. - O código então tenta obter o parâmetro `name` da string de consulta (`req.Query.["name"]`). Se não estiver na string de consulta, ele tenta ler o corpo da requisição como JSON e extrair a propriedade `name`. Se nenhum for encontrado, ele usa "Azure Functions" como padrão. Este é um padrão comum para lidar com a entrada. 8. **Resposta:** - `let responseMessage = sprintf "Olá, %s. Esta função disparada por HTTP foi executada com sucesso." name`: Cria a mensagem de resposta. - `return OkObjectResult responseMessage :> IActionResult`: Cria um `OkObjectResult` (uma resposta HTTP 200 OK) com a mensagem de resposta como o corpo. O `:> IActionResult` é um upcast, dizendo ao compilador que estamos retornando um `IActionResult`. Esta é a maneira padrão de retornar respostas HTTP do Azure Functions. **Como Usar Este Código:** 1. **Crie um Projeto Azure Functions:** - No Visual Studio, crie um novo projeto. Escolha "Azure Functions" como o tipo de projeto. Selecione "F#" como a linguagem. Escolha o template "HTTP trigger". 2. **Substitua o Código do Template:** - Substitua o código em `Function1.fs` gerado (ou qualquer que seja o nome do arquivo padrão) com o código acima. 3. **Instale Newtonsoft.Json:** - Você precisará instalar o pacote NuGet `Newtonsoft.Json` para lidar com a desserialização JSON. No Visual Studio, vá para Tools -> NuGet Package Manager -> Manage NuGet Packages for Solution. Procure por "Newtonsoft.Json" e instale-o. Certifique-se de ter a declaração `open Newtonsoft.Json` no topo do seu arquivo. 4. **Publique no Azure:** - Clique com o botão direito no seu projeto no Visual Studio e escolha "Publish". Siga as instruções para publicar sua aplicação de função no Azure. Você precisará de uma assinatura do Azure. **Testando:** Após a publicação, você pode testar sua função: * **Requisição GET (Parâmetro de Consulta):** Abra um navegador e vá para o URL da função (você o encontrará no portal do Azure). Adicione `?name=SeuNome` ao URL. Por exemplo: `https://your-function-app-name.azurewebsites.net/api/Hello?name=João`. * **Requisição POST (Corpo JSON):** Use uma ferramenta como Postman ou `curl` para enviar uma requisição POST para o URL da função. Defina o cabeçalho `Content-Type` para `application/json` e inclua um corpo JSON como este: ```json { "name": "Maria" } ``` **Melhorias e Considerações Chave:** * **Tratamento de Erros:** O exemplo inclui um bloco `try...with` básico para análise JSON, mas você deve adicionar um tratamento de erros mais robusto. Considere registrar erros e retornar códigos de erro HTTP apropriados (por exemplo, 400 Bad Request). * **Validação de Entrada:** Valide a entrada que você recebe da requisição. Não assuma que está sempre no formato correto ou dentro de intervalos aceitáveis. * **Operações Assíncronas:** Use `async` e `await` (ou `task { ... }` em F#) para quaisquer operações vinculadas a E/S (por exemplo, chamadas de banco de dados, requisições HTTP para outros serviços). Isso impede que sua função bloqueie e melhora o desempenho. * **Injeção de Dependência:** Para funções mais complexas, use a injeção de dependência para gerenciar dependências (por exemplo, conexões de banco de dados, configurações de configuração). O Azure Functions suporta injeção de dependência. * **Configuração:** Armazene as configurações de configuração (por exemplo, strings de conexão de banco de dados, chaves de API) no Azure App Configuration ou no Azure Key Vault e acesse-as através da interface `IConfiguration`. Evite codificar informações confidenciais em seu código. * **Registro de Logs:** Use a interface `ILogger` extensivamente para registrar eventos importantes, erros e métricas de desempenho. Isso ajudará você a monitorar e solucionar problemas da sua função. * **Idempotência:** Se sua função executa operações que devem ser executadas apenas uma vez (por exemplo, processamento de pagamentos), certifique-se de que ela seja idempotente. Isso significa que, se a função for chamada várias vezes com a mesma entrada, ela deverá executar a operação apenas uma vez. * **Testes:** Escreva testes unitários para verificar a lógica da sua função. Use frameworks de mocking para isolar sua função de dependências externas. This should give you a solid starting point for building Azure Functions in F#. Let me know if you have any other questions.

MyDriverParis MCP Server

Enables booking premium private chauffeur transfers in Paris and across Europe directly from AI agents. Provides tools to list vehicles, get quotes, book rides, and retrieve service information.

fittok

An MCP server that filters and compresses context by 80-90% before sending to an LLM, using code knowledge graphs and compression.

Azure Assistant MCP

Enables natural language exploration of Azure environments by generating and executing KQL queries against Azure Resource Graph. Supports multi-tenant configurations, subscription scoping, and provides direct access to Azure resource information through conversational interactions.

effective-potato

Provides a sandboxed Ubuntu 24.04 container for secure command execution, with tools for git operations, background tasks, and GUI automation (screenshots and screen recording).

Book4Time MCP Server

Enables interaction with the Book4Time API through an Azure Function-hosted server. It allows users to query product information and manage bookings using MCP-compatible clients like Claude Desktop.

taxonomy-mcp

Exposes Marble's open skill taxonomy (ages 4-15) as queryable MCP tools, enabling AI agents to search topics, find prerequisites, and plan learning paths.

DocuWare Read-only MCP

Read-only MCP server for DocuWare that lets you list file cabinets, search documents, view metadata, and download documents.

GiljoAI MCP

A passive context server that stores product knowledge, generates structured prompts, and coordinates multi-agent workflows via the Model Context Protocol, enabling AI coding tools to share a full picture of the product.

krexel-mcp

Enables AI assistants to deploy, manage, and rollback websites via the Krexel API, supporting site uploads, deploys, logs, rollbacks, environment variables, and status checks.

kalvium-livebooks

A read-only MCP server that lets you browse Kalvium Livebooks using your existing browser session, listing livebooks and lessons and retrieving lesson content as Markdown.

substack-publisher-mcp

A tool that connects to Substack's official Publisher API to access posts, newsletters, analytics, and subscribers, compatible with MCP clients like Claude and Cursor.

Wedding Invitation Builder MCP

Enables creating and customizing mobile wedding invitations through natural language, with support for multiple designs, RSVP, maps, gallery, and share tokens.

Google Web Search MCP Server

Enables Google web search via MCP, compatible with gemini-cli's google_web_search tool.

SkillsGuard

Static security scanner for AI agent skill packages that detects malicious SKILL.md files and bundled scripts before they run.

ui-lift

Imports public websites and extracts UI components and design tokens, making them available via MCP for AI coding agents to reuse in implementations.

dero-mcp-server

Read-only MCP server for querying DERO blockchain — blocks, smart contracts, transactions, network info. Privacy-first, runs locally.

MCP Server

A Django-based implementation of the Model Context Protocol (MCP) for managing political preferences and visions for the future.

memsearch-mcp

Provides hybrid vector+BM25+reranker search and index-refresh tools over agent memory stored in markdown files, enabling forge agents to query memory across session, working, and docs tiers without direct file access.