Discover Awesome MCP Servers

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.

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.

SFCC Development MCP Server

Provides comprehensive access to Salesforce B2C Commerce Cloud development tools including SFCC API documentation, best practices guides, log analysis, and system object definitions. Enables AI assistants to help with SFCC development tasks through both documentation-only mode and full credential-based mode.

markdownlint-mcp

Provides AI assistants with the ability to lint, validate, and auto-fix Markdown files to ensure compliance with established Markdown standards and best practices.

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.

mcp-umami

Connect your Umami Analytics to any MCP client to derive insights from natural language.

Custom MCP Servers

Uma coleção de servidores MCP personalizados que eu construí 🧠⚡️.

Weather MCP Tool

An India-focused MCP server that provides real-time weather conditions, forecasts, air quality data, and location search capabilities using the OpenWeatherMap API.

Document Conversion Assistant

Enables conversion between multiple document formats including Markdown, HTML, TXT, PDF, and DOCX with automatic format detection. Supports high-fidelity document transformation while preserving content integrity.

BoldSign MCP Server

Enables interaction with the BoldSign e-signature platform through its API. Supports managing documents, templates, contacts, users, and teams for electronic signature workflows.

聚义厅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.

Local Scanner MCP Server

Um servidor MCP para escanear código local e URLs localhost.

MCP Server Template (

Este modelo ajuda você a iniciar rapidamente um novo projeto de servidor Model Context Protocol (MCP) com base nas práticas recomendadas.

Browser MCP Server

Enables AI assistants to automate web browsers through Playwright, providing capabilities for navigation, content extraction, form filling, screenshot capture, and JavaScript execution. Supports multiple browser engines with comprehensive error handling and security features.

Zendesk MCP Server

A server implementation that provides Claude AI with the ability to interact with Zendesk ticketing systems through various functions including retrieving, searching, creating, and updating tickets.

Avalara AvaTax MCP Server by CData

This read-only MCP Server allows you to connect to Avalara AvaTax data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

Activity Reporting MCP Server

Enables Google Developer Experts to report various activities (content creation, speaking engagements, workshops, mentoring) through AI conversational interfaces by connecting Advocu API with Model Context Protocol.

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.

WebforAI Text Extractor MCP Server

A Cloudflare Workers-based server that extracts clean, formatted text from web pages using WebforAI and makes it accessible to AI models through the Model Context Protocol.

mcp-youtube

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

On Running MCP

Um servidor MCP para interagir com a API da On Running.

OMNI-Sales

Servidor MCP de Vendas

aptos-wallet-mcp

MCP server for aptos wallet

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.

Marketo MCP Server

A Model Context Protocol server for interacting with the Marketo API that provides tools for managing Marketo forms, including listing, cloning, and approving forms.

SEC Filing MCP Server

Enables querying and analysis of SEC filing documents through natural language. Uses Pinecone vector search with document summarization to help users retrieve and understand financial filings for various companies.

Simple MCP Server

A Python Flask-based Model Context Protocol server that provides basic tools including hello_world, calculate, and get_time functions through stable HTTP endpoints.