Discover Awesome MCP Servers

equity-intel-mcp

Provides institutional-grade equity analysis for any LLM via MCP, aggregating insider trading, superinvestor holdings, analyst consensus, options data, and valuation into a confidence-weighted verdict.

RimSage

Search and browse RimWorld source code, definitions, and C# symbols via MCP tools.

Doxygen MCP Server

A comprehensive server that enables AI assistants to generate, configure, and manage Doxygen documentation for various programming languages through a clean interface.

SudoMock

Product mockup rendering API for e-commerce and print-on-demand. Upload Photoshop PSD templates, render photorealistic mockups by placing your designs onto smart object layers. 9 tools including AI-powered render (no PSD needed), template management, and account info. Supports remote HTTP (OAuth) and local stdio (npx) transports.

Unsplash API MCP Server

An API that exposes Unsplash image search, listing, and random photo capabilities as MCP tools, enabling AI models like Claude to directly interact with Unsplash's services.

TouchDesigner MCP

Enables control of a running TouchDesigner instance via MCP protocol, providing tools to manage operators, parameters, and project state through a local HTTP bridge.

mixxx-mcp

An MCP server that lets AI agents control Mixxx DJ software over a virtual MIDI port, enabling playback, mixing, EQ, effects, and track loading.

trac-mcp-server

Enables AI agents to manage Trac projects with full CRUD operations on tickets, wiki pages, and milestones via the Model Context Protocol.

Epoch

Time estimation MCP server for AI agents. It provides PERT, COCOMO II, Monte Carlo simulation, sprint forecasting, token-to-time and cost mapping, and schedule-risk tools.

godot-mcp-pilot

An MCP server that gives AI assistants direct control over Godot 4 game development projects. It enables launching the editor, running projects, creating and editing scenes, writing GDScript, and inspecting assets through natural language commands.

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.

memtrace

Memtrace is a persistent memory layer for coding agents, built as a bi‑temporal structural knowledge graph over your codebase (AST‑driven symbols and relationships, plus temporal evolution and cross‑service API topology)

cryptoiz-mcp

AI-powered Solana DEX smart money signals. Detects whale/dolphin accumulation, divergence patterns, and market phase across 170+ tokens. Pay-per-call via x402 USDC micropayments.

MCP TypeScript Template

A starter template for building remote Model Context Protocol servers using TypeScript, providing modern tooling and best practices while leveraging the MCP TypeScript SDK.

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.

@vorionsys/mcp-server

MCP server for AI-agent governance using trust scoring, behavioral signals, and pre-flight action checks.

WooCommerce MCP Server

Enables AI agents to manage WooCommerce stores, including products, orders, customers, categories, coupons, attributes, variations, order notes, refunds, reports, payment gateways, meta data, reviews, settings, data, posts, and system status through natural language.

Pi-hole MCP Server

Enables control of Pi-hole v6 ad blocking, allowing users to toggle DNS blocking status and retrieve real-time statistics like query counts and blocked domains. It provides a structured interface for monitoring and managing network-level ad filtering through the Pi-hole REST API.

mcp-local-gateway

Minimal MCP server exposing a single tool, run_date, to execute the local date command via a Streamable HTTP endpoint.

Angular Toolkit MCP

A Model Context Protocol server that provides Angular project analysis and refactoring capabilities, enabling LLMs to analyze component usage patterns, dependency structures, and perform safe refactoring with breaking change detection.

ine-chile-mcp

MCP server exposing Chilean INE (Instituto Nacional de Estadísticas) public APIs as LLM tools. 11 tools for economic indicators, labor market data (ENE/ESI), automatic CAENES/CIUO-08 classification, and open datasets. No API key required.

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.

Pubtator MCP Server

Provides an async Python server for interacting with the PubTator3 API, exposing multiple biomedical text-mining tools compatible with the MCP agent protocol.

Guarded MCP Agent

Enables note management (create, read, update, delete) with a policy engine for blocking tools, human approval, and prompt injection detection.

Halo LMS MCP Server

MCP server that provides access to Grand Canyon University's Halo LMS, enabling AI agents to manage classes, assignments, grades, discussions, announcements, inbox messages, notifications, and user profiles.

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.

fittok

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

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.