Discover Awesome MCP Servers

Lindorm MCP Server

An example server that enables interaction with Alibaba Cloud's Lindorm multi-model NoSQL database, allowing applications to perform vector searches, full-text searches, and SQL operations through a unified interface.

聚义厅MCP

An AI personality collaboration tool based on Model Context Protocol (MCP) that enables users to summon and collaborate with multiple AI personas for intelligent analysis and problem-solving.

Society Abstract MCP

Provides comprehensive wallet, token, and smart contract utilities for the Abstract Testnet and Mainnet, including balance checks, transfers, and ERC-20 deployments. It enables users to manage Abstract Global Wallets and generate EOA accounts through natural language commands.

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.

Autopilot Browser MCP Server

Enables AI agents to search for and execute automated browser workflows through Autopilot Browser's API, allowing web scraping, data extraction, and other browser automation tasks via natural language commands.

Seo Api2 MCP Server

Provides a comprehensive suite of SEO and web utility tools for domain analysis, keyword tracking, SERP data, and technical site audits. It enables users to perform various tasks such as checking domain age, WHOIS information, and website technology stacks.

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.

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.

RT-Prompt-MCP

A Model Context Protocol server that provides specialized prompt suggestions for backend development, frontend development, and general tasks to help LLMs generate better content.

MCPServer

A setup guide for running a Model Completion Protocol (MCP) server in Windows Subsystem for Linux, enabling Claude AI integration with local Python code.

MCP LLMS-TXT Documentation Server

An MCP server that enables users to fetch and audit documentation from user-defined llms.txt index files. It provides tools to list documentation sources and retrieve content from specific URLs with built-in domain access controls for secure context retrieval.

MongTap

Enables LLMs to create, query, and manage MongoDB-compatible databases using natural language without actual data storage. Uses statistical modeling to generate realistic data on-the-fly from sample documents or descriptions.

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.

Rovodev MCP Tool

Integrates the Atlassian Rovo Dev CLI with the Model Context Protocol, allowing AI assistants to perform deep code analysis using Rovo Dev's large context capabilities. It enables features like repository-wide queries, file-specific analysis, and specialized coding modes through a standard MCP interface.

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

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.

Remote MCP Server on Cloudflare

A deployable Model Context Protocol server that runs on Cloudflare Workers without requiring authentication, allowing users to create custom AI tools and connect them to clients like Claude Desktop and Cloudflare AI Playground.

MCP TypeScript SDK

A toolkit for building Model Context Protocol servers and clients that provide standardized context for LLMs, allowing applications to expose resources, tools, and prompts through stdio or Streamable HTTP transports.

Task MCP Server

A simple task management server that enables users to add, list, complete, and delete tasks through natural language interactions in Claude Desktop.

Umbraco CMS MCP Server

Provides AI agents with access to Umbraco CMS Management API for managing documents, media, content types, templates, users, and other back office operations with user permission-based access control.

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.

Thordata MCP Server

Enables AI models to scrape and extract structured data from any website globally using a 195+ country proxy network with JavaScript rendering, anti-bot bypass, and output in Markdown, HTML, or Links format.

Gotas Commerce MCP Server

A bridge between AI assistants and cryptocurrency payment services that enables creating and verifying USDT transactions through the Gotas Commerce API.

Celery MCP

Enables interaction with Celery distributed task queues through MCP tools. Supports task management, monitoring worker statistics, and controlling asynchronous job execution through natural language.

discord-mcp-server

Discord MCP Server est un pont entre votre intelligence artificielle et Discord. Il transforme votre bot Discord en un assistant intelligent capable de comprendre et d'exécuter vos commandes.

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.