Discover Awesome MCP Servers

Mathematica Documentation MCP server

Um servidor que fornece acesso à documentação do Mathematica através do FastMCP, permitindo que os usuários recuperem a documentação de funções e listem os símbolos de pacotes do Wolfram Mathematica.

Anki MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que LLMs interajam com o software de flashcards Anki através do AnkiConnect, possibilitando a criação e gerenciamento de flashcards, baralhos e tipos de nota.

Canvas MCP Server

Um servidor local que permite a interação com a API do Sistema de Gestão de Aprendizagem Canvas através do Claude Desktop, permitindo aos usuários gerenciar cursos, acessar tarefas, visualizar anúncios e recuperar materiais do curso.

Zonos TTS MCP Server

Facilita a geração de fala direta usando o Claude para múltiplos idiomas e emoções, integrando-se com uma configuração Zonos TTS via Protocolo de Contexto do Modelo.

ClickUp Operator

Model Context Protocol (MCP) server implementation for ClickUp integration

LanceDB MCP Server

Permite operações eficientes em bancos de dados vetoriais para armazenamento de embeddings e busca de similaridade através de uma interface de Protocolo de Contexto de Modelo.

MCP Notes Server

Um servidor MCP para gerenciar e persistir notas, oferecendo operações CRUD, sumarização de notas e acesso baseado em recursos através de um esquema URI note://.

Google Drive MCP Server

Permite a integração com o Google Drive para listar, ler e pesquisar arquivos, com suporte a vários tipos de arquivo e exportação automática para arquivos do Google Workspace.

MCP 3D Printer Server

Permite a interação com sistemas de gerenciamento de impressoras 3D através de um servidor MCP, suportando manipulação de arquivos STL, fatiamento e controle de impressoras como OctoPrint, Klipper, Duet e muito mais.

MCP MySQL Server

Facilita a interação com um banco de dados MySQL local através de uma API RESTful, oferecendo suporte a consultas de banco de dados e atualizações em tempo real com integração para serviços Cursor MCP.

MCP Server Template

## Modelo para Criação de Servidores Model Context Protocol (MCP) em TypeScript Este modelo oferece uma base para a criação de servidores Model Context Protocol (MCP) em TypeScript, incorporando injeção de dependência baseada em contêineres, uma arquitetura baseada em serviços e integração com a LLM CLI para feedback de design arquitetural através de linguagem natural. **Estrutura do Projeto:** ``` mcp-server/ ├── src/ │ ├── core/ # Componentes essenciais do framework │ │ ├── container.ts # Contêiner de injeção de dependência (InversifyJS) │ │ ├── service.ts # Classe base para serviços │ │ ├── mcp.ts # Lógica principal do MCP (conexão, autenticação, etc.) │ │ └── ... │ ├── services/ # Implementações de serviços específicos do domínio │ │ ├── data-access.service.ts # Serviço para acesso a dados │ │ ├── llm-integration.service.ts # Serviço para integração com LLM CLI │ │ └── ... │ ├── controllers/ # Lógica de roteamento e manipulação de requisições │ │ ├── mcp.controller.ts # Controlador para endpoints MCP │ │ └── ... │ ├── models/ # Definições de dados (interfaces, classes) │ │ ├── request.model.ts │ │ ├── response.model.ts │ │ └── ... │ ├── config/ # Configurações da aplicação │ │ ├── default.ts │ │ └── ... │ ├── app.ts # Ponto de entrada da aplicação │ └── server.ts # Inicialização do servidor (Express.js) ├── package.json ├── tsconfig.json ├── README.md └── .env # Variáveis de ambiente ``` **Componentes Chave:** * **`src/core/container.ts`:** Utiliza uma biblioteca de injeção de dependência (ex: InversifyJS) para gerenciar as dependências entre os serviços. Define um contêiner que registra e resolve as dependências. ```typescript // Exemplo com InversifyJS import { Container } from "inversify"; import { DataAccessService } from "../services/data-access.service"; import { LLMIntegrationService } from "../services/llm-integration.service"; import { TYPES } from "./types"; const container = new Container(); container.bind<DataAccessService>(TYPES.DataAccessService).to(DataAccessService); container.bind<LLMIntegrationService>(TYPES.LLMIntegrationService).to(LLMIntegrationService); export { container }; ``` * **`src/core/service.ts`:** Define uma classe base abstrata para todos os serviços. Fornece uma estrutura consistente e pode incluir lógica comum, como logging ou tratamento de erros. ```typescript export abstract class Service { protected logger: any; // Exemplo: Winston, pino constructor() { // Inicializar o logger this.logger = console; // Substituir por um logger real } protected log(message: string, level: 'info' | 'warn' | 'error' = 'info'): void { this.logger[level](message); } } ``` * **`src/services/`:** Contém as implementações dos serviços específicos do domínio. Cada serviço é responsável por uma funcionalidade específica, como acesso a dados, integração com LLMs, etc. * **`data-access.service.ts`:** Responsável por interagir com o banco de dados ou outras fontes de dados. ```typescript import { injectable } from "inversify"; import { Service } from "../core/service"; @injectable() export class DataAccessService extends Service { async getData(): Promise<any[]> { // Lógica para buscar dados this.log("Fetching data from database"); return []; // Substituir por dados reais } } ``` * **`llm-integration.service.ts`:** Responsável por interagir com a LLM CLI para obter feedback de design arquitetural. ```typescript import { injectable } from "inversify"; import { Service } from "../core/service"; import { exec } from 'child_process'; import { promisify } from 'util'; const execAsync = promisify(exec); @injectable() export class LLMIntegrationService extends Service { async getArchitecturalFeedback(designDescription: string): Promise<string> { try { // Executar o comando da LLM CLI const { stdout, stderr } = await execAsync(`llm-cli analyze "${designDescription}"`); if (stderr) { this.log(`LLM CLI error: ${stderr}`, 'error'); return `Erro ao obter feedback da LLM CLI: ${stderr}`; } this.log(`LLM CLI output: ${stdout}`); return stdout; } catch (error: any) { this.log(`Error executing LLM CLI: ${error.message}`, 'error'); return `Erro ao executar a LLM CLI: ${error.message}`; } } } ``` * **`src/controllers/`:** Responsável por receber as requisições, roteá-las para os serviços apropriados e retornar as respostas. * **`mcp.controller.ts`:** Controlador para os endpoints específicos do MCP. ```typescript import { Request, Response } from "express"; import { inject, injectable } from "inversify"; import { DataAccessService } from "../services/data-access.service"; import { LLMIntegrationService } from "../services/llm-integration.service"; import { TYPES } from "../core/types"; @injectable() export class MCPController { constructor( @inject(TYPES.DataAccessService) private dataAccessService: DataAccessService, @inject(TYPES.LLMIntegrationService) private llmIntegrationService: LLMIntegrationService ) {} async handleDataRequest(req: Request, res: Response): Promise<void> { try { const data = await this.dataAccessService.getData(); res.json(data); } catch (error: any) { console.error(error); res.status(500).json({ error: error.message }); } } async getArchitecturalFeedback(req: Request, res: Response): Promise<void> { try { const designDescription = req.body.description; const feedback = await this.llmIntegrationService.getArchitecturalFeedback(designDescription); res.json({ feedback }); } catch (error: any) { console.error(error); res.status(500).json({ error: error.message }); } } } ``` * **`src/app.ts`:** Configura o servidor Express.js, define as rotas e inicializa o contêiner de injeção de dependência. ```typescript import express, { Application, Request, Response } from 'express'; import { container } from './core/container'; import { MCPController } from './controllers/mcp.controller'; import { TYPES } from './core/types'; class App { public app: Application; private mcpController: MCPController; constructor() { this.app = express(); this.config(); this.mcpController = container.get<MCPController>(TYPES.MCPController); this.routes(); } private config(): void { this.app.use(express.json()); this.app.use(express.urlencoded({ extended: false })); } private routes(): void { this.app.get('/', (req: Request, res: Response) => { res.send('MCP Server is running!'); }); this.app.get('/data', (req: Request, res: Response) => this.mcpController.handleDataRequest(req, res)); this.app.post('/feedback', (req: Request, res: Response) => this.mcpController.getArchitecturalFeedback(req, res)); } } export default new App().app; ``` * **`src/server.ts`:** Inicia o servidor Express.js. ```typescript import app from './app'; const PORT = process.env.PORT || 3000; app.listen(PORT, () => { console.log(`Server is running on port ${PORT}`); }); ``` * **`src/core/types.ts`:** Define as chaves de identificação para os serviços no contêiner de injeção de dependência. ```typescript export const TYPES = { DataAccessService: Symbol.for("DataAccessService"), LLMIntegrationService: Symbol.for("LLMIntegrationService"), MCPController: Symbol.for("MCPController"), }; ``` **Funcionalidades:** * **Injeção de Dependência:** Utiliza um contêiner de injeção de dependência (ex: InversifyJS) para gerenciar as dependências entre os serviços, promovendo a testabilidade e a modularidade. * **Arquitetura Baseada em Serviços:** Organiza a lógica da aplicação em serviços independentes e reutilizáveis. * **Integração com LLM CLI:** Permite obter feedback de design arquitetural através da LLM CLI, utilizando linguagem natural. * **TypeScript:** Utiliza TypeScript para garantir a tipagem estática e melhorar a qualidade do código. * **Express.js:** Utiliza Express.js como framework web para facilitar a criação de APIs. **Como Usar:** 1. **Instale as dependências:** ```bash npm install express inversify reflect-metadata child_process util npm install --save-dev @types/express @types/node typescript ts-node nodemon ``` 2. **Configure as variáveis de ambiente:** Crie um arquivo `.env` e defina as variáveis de ambiente necessárias (ex: porta do servidor, credenciais do banco de dados, etc.). 3. **Implemente os serviços específicos do domínio:** Crie as implementações dos serviços no diretório `src/services/`. 4. **Defina as rotas no controlador:** Configure as rotas no controlador `src/controllers/mcp.controller.ts` para expor os endpoints do MCP. 5. **Execute o servidor:** ```bash npm run dev # Usando nodemon para hot-reloading ``` **Considerações:** * **LLM CLI:** Certifique-se de ter a LLM CLI instalada e configurada corretamente. * **Segurança:** Implemente medidas de segurança adequadas, como autenticação e autorização. * **Testes:** Escreva testes unitários e de integração para garantir a qualidade do código. * **Logging:** Utilize um sistema de logging robusto para monitorar a aplicação. * **Escalabilidade:** Considere a escalabilidade da aplicação ao projetar a arquitetura. Este modelo fornece um ponto de partida sólido para a criação de servidores MCP em TypeScript. Adapte-o às suas necessidades específicas e adicione as funcionalidades adicionais que forem necessárias. Lembre-se de que este é apenas um exemplo e pode precisar de ajustes para se adequar ao seu caso de uso específico.

MCP File Server

Permite que modelos de IA executem operações no sistema de arquivos (leitura, criação e listagem de arquivos) em um sistema de arquivos local por meio de uma interface padronizada do Protocolo de Contexto do Modelo.

Code Sandbox MCP

Um servidor MCP para criar um ambiente de sandbox de código seguro para executar código dentro de contêineres Docker.

Anki MCP Server

Um servidor baseado em TypeScript que se integra ao Anki através do plugin AnkiConnect, permitindo que você gerencie baralhos de flashcards, modelos de notas e crie notas do Anki usando linguagem natural.

MCP Notmuch Sendmail

Um servidor assistente de e-mail que conecta o Claude Desktop a bancos de dados de e-mail notmuch, permitindo que os usuários pesquisem e-mails, visualizem threads, componham novas mensagens e respondam a conversas com formatação markdown.

Github-Oauth MCP Server

Facilita a autenticação com o GitHub usando o protocolo OAuth, permitindo acesso e interação seguros com repositórios e serviços do GitHub.

claude-code-mcp

Este projeto tem como objetivo construir um servidor Claude Code MCP e implementar suas ferramentas associadas (explain\_code, review\_code, fix\_code, edit\_code, test\_code, simulate\_command, sua\_própria\_consulta). O servidor é implementado usando Node.js e o SDK MCP. Ele recebe solicitações de ferramentas de clientes via Stdio, dinamicamente.

Notion MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que Claude e outros LLMs interajam com espaços de trabalho do Notion, fornecendo capacidades como pesquisar, recuperar, criar e atualizar páginas, bem como gerenciar bancos de dados.

Super Windows CLI MCP Server

Um servidor MCP de CLI do Windows aprimorado, que oferece capacidades de acesso irrestrito ao sistema, projetado para ambientes confiáveis com requisitos de acesso total ao sistema.

mcp-local-dev

Crie ambientes de desenvolvimento locais isolados diretamente do Github e execute testes, veja a cobertura e muito mais! Suporta Python, Node, Bun e muitos executores de teste.

Azure OpenAI

Aqui está uma implementação mínima de uma aplicação servidor/cliente utilizando o Protocolo de Contexto de Modelo (MCP) e o Azure OpenAI: **Observação:** Este é um exemplo simplificado e requer a instalação das bibliotecas necessárias (como `openai`, `fastapi`, `uvicorn`, etc.) e a configuração correta das suas credenciais do Azure OpenAI. **1. Servidor (usando FastAPI):** ```python from fastapi import FastAPI, Request, HTTPException from pydantic import BaseModel import openai import os app = FastAPI() # Configurar as credenciais do Azure OpenAI openai.api_type = "azure" openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") # Obtenha do seu ambiente openai.api_version = "2023-05-15" # Use a versão da API apropriada openai.api_key = os.getenv("AZURE_OPENAI_KEY") # Obtenha do seu ambiente deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME") # Obtenha do seu ambiente class Message(BaseModel): content: str role: str # "user" ou "system" class ChatRequest(BaseModel): messages: list[Message] @app.post("/chat") async def chat_endpoint(request: ChatRequest): try: response = openai.ChatCompletion.create( engine=deployment_name, messages=[message.dict() for message in request.messages], temperature=0.7, max_tokens=800, n=1, stop=None, ) return {"response": response.choices[0].message.content} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) ``` **Explicação do Servidor:** * **Importações:** Importa as bibliotecas necessárias do FastAPI, Pydantic e OpenAI. * **Configuração do Azure OpenAI:** Configura as credenciais do Azure OpenAI usando variáveis de ambiente. **IMPORTANTE:** Nunca coloque suas chaves diretamente no código. Use variáveis de ambiente ou um sistema de gerenciamento de segredos. * **Modelos de Dados (Pydantic):** Define modelos de dados para a requisição (`ChatRequest`) e as mensagens (`Message`) usando Pydantic para validação e tipagem. * **Endpoint `/chat`:** * Recebe uma requisição POST com uma lista de mensagens (`ChatRequest`). * Converte as mensagens Pydantic para dicionários para serem usadas pela API OpenAI. * Chama a API `openai.ChatCompletion.create` com as mensagens, configurando parâmetros como `temperature`, `max_tokens`, etc. * Retorna a resposta do modelo OpenAI. * Trata erros e retorna um código de status 500 em caso de falha. * **Execução:** Inicia o servidor FastAPI usando `uvicorn`. **2. Cliente (exemplo simples):** ```python import requests import json # URL do servidor SERVER_URL = "http://localhost:8000/chat" # Mensagens de exemplo messages = [ {"role": "system", "content": "Você é um assistente útil."}, {"role": "user", "content": "Qual é a capital da França?"} ] # Criar o payload da requisição payload = {"messages": messages} # Enviar a requisição POST try: response = requests.post(SERVER_URL, data=json.dumps(payload)) response.raise_for_status() # Levanta uma exceção para códigos de erro HTTP data = response.json() print("Resposta do servidor:", data["response"]) except requests.exceptions.RequestException as e: print("Erro na requisição:", e) except json.JSONDecodeError as e: print("Erro ao decodificar a resposta JSON:", e) ``` **Explicação do Cliente:** * **Importações:** Importa as bibliotecas `requests` e `json`. * **URL do Servidor:** Define o URL do servidor FastAPI. * **Mensagens de Exemplo:** Cria uma lista de mensagens de exemplo para enviar ao servidor. * **Payload da Requisição:** Cria um dicionário contendo a lista de mensagens. * **Enviar Requisição POST:** * Envia uma requisição POST para o endpoint `/chat` do servidor. * Converte o payload para JSON usando `json.dumps`. * Trata erros de requisição e erros de decodificação JSON. * Imprime a resposta do servidor. **Como Executar:** 1. **Instale as dependências:** ```bash pip install fastapi uvicorn openai python-dotenv requests ``` 2. **Configure as variáveis de ambiente:** * Crie um arquivo `.env` na mesma pasta dos seus scripts. * Adicione as seguintes linhas, substituindo pelos seus valores reais: ``` AZURE_OPENAI_ENDPOINT="YOUR_AZURE_OPENAI_ENDPOINT" AZURE_OPENAI_KEY="YOUR_AZURE_OPENAI_KEY" AZURE_OPENAI_DEPLOYMENT_NAME="YOUR_AZURE_OPENAI_DEPLOYMENT_NAME" ``` * No seu código Python, você pode usar `os.getenv()` para acessar essas variáveis. Se você não quiser usar um arquivo `.env`, você pode definir as variáveis de ambiente diretamente no seu sistema operacional. 3. **Execute o servidor:** ```bash python seu_servidor.py # Substitua seu_servidor.py pelo nome do seu arquivo ``` 4. **Execute o cliente:** ```bash python seu_cliente.py # Substitua seu_cliente.py pelo nome do seu arquivo ``` **Considerações sobre o MCP (Model Context Protocol):** Este exemplo, embora funcional, não implementa o MCP de forma completa. O MCP é um protocolo mais complexo que envolve: * **Gerenciamento de Contexto:** O servidor deve ser capaz de manter o contexto da conversa entre múltiplas requisições. Isso geralmente envolve o uso de um banco de dados ou cache para armazenar o histórico da conversa. * **Tokenização e Limites de Contexto:** O servidor deve ser capaz de tokenizar as mensagens e garantir que o tamanho total do contexto (em tokens) não exceda o limite do modelo OpenAI. Se o limite for excedido, o servidor deve remover as mensagens mais antigas do contexto. * **ID de Sessão:** O cliente deve enviar um ID de sessão para o servidor para que o servidor possa identificar a conversa correta. Para implementar o MCP de forma completa, você precisaria adicionar lógica para: * Gerenciar o contexto da conversa (armazenando o histórico das mensagens). * Tokenizar as mensagens (usando uma biblioteca como `tiktoken`). * Remover mensagens antigas do contexto quando o limite de tokens for atingido. * Implementar um sistema de ID de sessão. **Exemplo de como adicionar um ID de sessão (simplificado):** **Servidor (modificado):** ```python from fastapi import FastAPI, Request, HTTPException from pydantic import BaseModel import openai import os import uuid app = FastAPI() # Configurar as credenciais do Azure OpenAI openai.api_type = "azure" openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") openai.api_version = "2023-05-15" openai.api_key = os.getenv("AZURE_OPENAI_KEY") deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME") class Message(BaseModel): content: str role: str class ChatRequest(BaseModel): messages: list[Message] session_id: str # Adicionado o ID da sessão # Dicionário para armazenar o contexto da conversa (substitua por um banco de dados em produção) conversation_context = {} @app.post("/chat") async def chat_endpoint(request: ChatRequest): session_id = request.session_id messages = request.messages # Obter o contexto da conversa existente ou criar um novo if session_id in conversation_context: context = conversation_context[session_id] else: context = [] # Adicionar as novas mensagens ao contexto context.extend([message.dict() for message in messages]) try: response = openai.ChatCompletion.create( engine=deployment_name, messages=context, # Usar o contexto completo temperature=0.7, max_tokens=800, n=1, stop=None, ) response_content = response.choices[0].message.content # Adicionar a resposta do modelo ao contexto context.append({"role": "assistant", "content": response_content}) # Atualizar o contexto da conversa conversation_context[session_id] = context return {"response": response_content, "session_id": session_id} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.get("/new_session") async def new_session_endpoint(): session_id = str(uuid.uuid4()) return {"session_id": session_id} if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) ``` **Cliente (modificado):** ```python import requests import json SERVER_URL = "http://localhost:8000/chat" NEW_SESSION_URL = "http://localhost:8000/new_session" # Obter um novo ID de sessão try: session_response = requests.get(NEW_SESSION_URL) session_response.raise_for_status() session_data = session_response.json() session_id = session_data["session_id"] print("Novo ID de sessão:", session_id) except requests.exceptions.RequestException as e: print("Erro ao obter o ID de sessão:", e) exit() # Mensagens de exemplo messages = [ {"role": "user", "content": "Qual é a capital da França?"} ] # Criar o payload da requisição payload = {"messages": messages, "session_id": session_id} # Adicionar o ID da sessão # Enviar a requisição POST try: response = requests.post(SERVER_URL, data=json.dumps(payload)) response.raise_for_status() data = response.json() print("Resposta do servidor:", data["response"]) print("ID de sessão retornado:", data["session_id"]) except requests.exceptions.RequestException as e: print("Erro na requisição:", e) except json.JSONDecodeError as e: print("Erro ao decodificar a resposta JSON:", e) # Enviar outra mensagem na mesma sessão messages2 = [ {"role": "user", "content": "E qual é a população?"} ] payload2 = {"messages": messages2, "session_id": session_id} try: response2 = requests.post(SERVER_URL, data=json.dumps(payload2)) response2.raise_for_status() data2 = response2.json() print("Resposta do servidor (segunda mensagem):", data2["response"]) print("ID de sessão retornado (segunda mensagem):", data2["session_id"]) except requests.exceptions.RequestException as e: print("Erro na requisição (segunda mensagem):", e) except json.JSONDecodeError as e: print("Erro ao decodificar a resposta JSON (segunda mensagem):", e) ``` **Mudanças:** * **Servidor:** * Adicionado um campo `session_id` ao `ChatRequest`. * Adicionado um dicionário `conversation_context` para armazenar o histórico da conversa (substitua por um banco de dados em produção). * O endpoint `/chat` agora recebe o `session_id` e usa o contexto da conversa existente (se houver). * A resposta do modelo é adicionada ao contexto da conversa. * Adicionado um endpoint `/new_session` para gerar um novo ID de sessão. * **Cliente:** * Obtém um novo ID de sessão do endpoint `/new_session`. * Envia o `session_id` em cada requisição. * Envia uma segunda mensagem usando o mesmo `session_id` para continuar a conversa. **Observações:** * Este exemplo ainda é simplificado e não implementa tokenização ou limites de contexto. * Em um ambiente de produção, você deve usar um banco de dados para armazenar o contexto da conversa em vez de um dicionário na memória. * Você deve implementar tratamento de erros mais robusto. * Considere usar um sistema de autenticação e autorização para proteger seu servidor. Este exemplo fornece um ponto de partida para construir uma aplicação servidor/cliente mais completa que utiliza o MCP e o Azure OpenAI. Lembre-se de adaptar o código às suas necessidades específicas e de seguir as melhores práticas de segurança.

MCP-LOGO-GEN

Servidor de Ferramentas MCP para Geração de Logotipos. Este servidor oferece recursos de geração de logotipos usando FAL AI, com ferramentas para geração de imagens, remoção de fundo e redimensionamento de imagens.

Cline Personas MCP Server

Um servidor MCP para gerenciar e ativar templates e componentes de persona, escrevendo em arquivos .clinerules, com suporte para rastreamento de versão e armazenamento baseado em arquivos.

Face Generator MCP Server

Gera imagens realistas de rostos humanos que não representam pessoas reais, oferecendo vários formatos de saída, dimensões configuráveis e capacidades de geração em lote.

mcp-maigret

Servidor MCP para o Maigret, uma ferramenta OSINT poderosa que coleta informações de contas de usuários de várias fontes públicas. Este servidor fornece ferramentas para pesquisar nomes de usuário em redes sociais e analisar URLs.

Cursor A11y MCP

Fornece capacidades de teste de acessibilidade através de CLI, ajudando a identificar problemas de acessibilidade em aplicações web usando axe-core e Puppeteer.

MCP-AppleMusic

Facilita o controle do Apple Music no macOS via AppleScript através de comandos MCP, permitindo que os usuários gerenciem a reprodução, pesquisem faixas e criem playlists.

MCP Server Make

Um servidor de Protocolo de Contexto de Modelo que permite que LLMs executem com segurança alvos "make" de um Makefile, permitindo que assistentes de IA executem testes, formatem código e automatizem várias tarefas de desenvolvimento através da interação em linguagem natural.

mcp-image-downloader

Permite que assistentes de IA baixem imagens de URLs e realizem tarefas básicas de otimização de imagem.