Discover Awesome MCP Servers

Slack MCP Server

An MCP server that enables searching for messages and listing channels within a Slack workspace. It provides tools to retrieve channel history and filter messages based on text matching and date ranges.

artifactory-mcp

Enables AI assistants to query Maven artifacts in JFrog Artifactory by reusing credentials from ~/.m2/settings.xml and providing tools like getting latest stable versions, listing artifacts, and checking dependency updates.

Zefix MCP

Enables AI assistants to search the Swiss Central Business Name Index (Zefix) for companies by name or UID, with optional filters, and retrieve full company details including address, legal form, history, and representatives.

Weather MCP Server

Provides real-time weather information for Brazilian cities, built with domain-driven design and SOLID principles.

Screen View MCP

Enables AI assistants to capture and analyze screenshots using Claude Vision API, providing AI-powered insights about desktop interface content, UI elements, and visual layouts.

Pentest MCP Server

Enables AI agents to perform autonomous penetration testing on any Linux distribution via SSH with persistent tmux sessions, supporting interactive tools like Metasploit, reverse shells, and complex multi-step security workflows.

fcgen-mcp

Enables LLMs to safely generate parametric CAD parts (STEP/STL) using verified templates and FreeCAD, with validation and assembly support.

mcp-playwright-scraper

An MCP server that scrapes content from web pages, including JavaScript-heavy sites, and converts it into high-quality Markdown. It leverages Playwright for headless browser automation and Pypandoc for clean content conversion.

mcp-api-tester Tools & Interfaces

Here are a few possible translations, depending on the specific nuance you want to convey: * **Opção 1 (Mais direta):** Servidor MCP para LLM para testar API * **Opção 2 (Um pouco mais descritiva):** Servidor MCP para LLM para teste de API * **Opção 3 (Com foco no propósito):** Servidor MCP para LLM usado para testar APIs **Explanation of Choices:** * **MCP:** It's likely best to leave "MCP" as is, assuming it's an acronym or specific term. If you know what it stands for, you could replace it with the full term in Portuguese if appropriate. * **LLM:** Similarly, "LLM" (Large Language Model) is often used as is, even in Portuguese contexts. You *could* translate it to "Modelo de Linguagem Grande" but it's less common. * **API:** "API" is also commonly used in Portuguese without translation. * **"para" vs. "usado para":** "Para" is a direct translation of "for." "Usado para" (used for) adds a bit more emphasis on the purpose of the server. * **"teste de API" vs. "testar API":** Both are correct. "Teste de API" is a noun phrase ("API test"), while "testar API" is a verb phrase ("to test API"). Therefore, the best option depends on the context. If you want a simple and direct translation, **Option 1** is fine. If you want to emphasize the purpose, **Option 3** might be better.

md-redline

Inline review comments for markdown specs and design docs. Agents request human review mid-task via MCP and pause until you send feedback.

mcp-youtube

High-efficiency YouTube MCP server: Get token-optimized, structured data for your LLMs using the YouTube Data API v3.

OMNI-Sales

Servidor MCP de Vendas

@looppause/mcp

Pauses AI agent execution and routes approval requests to humans via Slack or email, with cryptographically signed proof of the human's decision.

open-museum-mcp

Federated, license-verified search across open-access museum collections — currently The Met, Cleveland, AIC, Wikimedia Commons, and Europeana, with more being added. Strict-default-deny rights gate accepts only CC0 / Public Domain Mark, returning reuse-safe artwork with citations in three styles.

battery-mcp

Enables LLMs to verify the novelty and validity of invented battery materials, with support for searching and validating against a materials database.

OpenOcean MCP

Enables interaction with decentralized exchanges (DEXs) through OpenOcean, allowing users to get swap quotes, execute token swaps, check gas prices, and query transaction information across multiple blockchain networks.

sql-sop-mcp

MCP server that integrates sql-sop SQL linter into LLM clients, enabling linting SQL queries and listing lint rules via chat tools.

Remote MCP Server on Cloudflare

A server that enables Model Context Protocol (MCP) functionality on Cloudflare Workers with OAuth login, allowing applications like Claude Desktop to access custom tools through a standardized interface.

ActTrace

MCP server for EU AI Act compliance, providing risk classification of AI features and Article 50 transparency notices.

wiz-light-mcp

MCP server for controlling WiZ smart lights locally via UDP: discover bulbs, power control, color, temperature, and scenes.

Design-Pattern-MCP

Provides design pattern templates and anti-pattern guidance to AI coding agents for correct pattern implementation.

systemd-mcp

Provides AI assistants with safe, read-only access to Linux systemd services, including status monitoring, log querying, and dependency analysis, with optional granular permissions for service management actions.

obsidian-kb

Git-backed MCP server for creating and maintaining an Obsidian-style markdown knowledge base with full CRUD, search, and git sync.

TestCafe MCP Server

Bridges AI assistants with TestCafe testing capabilities, enabling AI-driven browser automation and test creation.

Geond Agent Protocol

Local-first shared memory and coordination layer for AI coding agents, with repository evidence, reservations, handoffs, code graph context, and dashboard review backed by PostgreSQL/pgvector.

MCP Medical Appointments Demo

Enables users to manage medical appointments by searching for doctors, checking availability, and booking sessions through a natural language interface. It serves as a reference implementation for advanced MCP features like symptom-based specialist recommendations and multi-step scheduling workflows.

MCP Database Server

Enables AI assistants to interact with PostgreSQL databases through query execution and schema inspection, supporting multiple schemas for customer data, document management, loan systems, and asset leasing.

mcp-postman-runner

Run the requests in a Postman collection folder and get structured, assertion-level results back straight from your AI assistant.

LayerZero OFT MCP Server

A TypeScript/Node.js server that enables creating, deploying, and bridging Omnichain Fungible Tokens (OFTs) across multiple blockchains using LayerZero protocols.

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.