Discover Awesome MCP Servers

Memory Bank MCP

O Servidor de Banco de Memória fornece um conjunto de ferramentas e recursos para que assistentes de IA interajam com Bancos de Memória. Bancos de Memória são repositórios estruturados de informações que ajudam a manter o contexto e rastrear o progresso em várias sessões.

GitHub Kanban MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite o gerenciamento eficiente de issues do GitHub em um formato de quadro Kanban, permitindo que LLMs automatizem o gerenciamento de tarefas por meio da integração com o GitHub.

MySQL-MCP

Um servidor de Protocolo de Contexto de Modelo que permite a execução de consultas SQL, gerenciamento de banco de dados e recursos de inteligência de negócios através de conexões MySQL.

applescript-mcp

Permite que aplicações LLM interajam com o macOS através do AppleScript.

MCP Tasks Organizer

Um servidor MCP que converte planos do agente Cursor em listas de tarefas markdown estruturadas e as organiza no seu repositório, ajudando você a rastrear planos e recomendações gerados por IA como especificações acionáveis.

Model Context Protocol Server for Solana Client

Um servidor que permite a interação com a blockchain Solana, fornecendo acesso a mais de 40 métodos RPC da Solana, incluindo a obtenção de saldos, detalhes de transações, informações de blocos e o envio de transações.

Stealth Browser MCP Server

Fornece capacidades de navegador furtivo usando Playwright com técnicas anti-detecção, permitindo que clientes MCP naveguem em websites e tirem screenshots enquanto evadem sistemas comuns de detecção de bots.

MCP Personal Assistant Agent

Um servidor de Protocolo de Contexto de Modelo versátil que permite que assistentes de IA gerenciem calendários, rastreiem tarefas, lidem com e-mails, pesquisem na web e controlem dispositivos domésticos inteligentes.

MCP Server Semgrep

Um servidor compatível com o Protocolo de Contexto de Modelo que integra a ferramenta de análise estática Semgrep com assistentes de IA como o Anthropic Claude, permitindo análise de código avançada, detecção de vulnerabilidades de segurança e melhorias na qualidade do código por meio de uma interface conversacional.

MCP Postgres Server

Um servidor que implementa o Protocolo de Contexto de Modelo (MCP) para o Cursor, permitindo o uso de um banco de dados PostgreSQL como armazenamento para contextos de modelo, possibilitando a exploração e consulta segura do banco de dados.

MCP File Preview Server

Fornece capacidades de visualização e análise de arquivos HTML. Este servidor permite capturar screenshots de página inteira de arquivos HTML locais e analisar sua estrutura.

Explorium AgentSource MCP Server

O Explorium AgentSource MCP Server capacita cada agente a se tornar um agente especializado em Go-To-Market, impulsionado por IA! Com mais de 20 endpoints especializados, projetados para prospecção, vendas e geração de leads, os agentes podem gerar e enriquecer contas e prospects sem esforço, acessar insights de negócios profundos, e...

MCP PDF Forms

Um servidor que fornece ferramentas de manipulação de formulários PDF através da API do MCP, permitindo que os usuários encontrem PDFs em diretórios, extraiam informações de campos de formulário e visualizem campos de formulário em documentos.

Branch Thinking MCP Server

Um servidor MCP para navegar por processos de pensamento usando ramificações, com suporte para referências cruzadas de pensamentos e rastreamento de prioridades para aprimorar a geração de insights e a exploração estruturada de ideias.

Bazel MCP Server

Um servidor MCP local que expõe a funcionalidade do sistema de build Bazel para agentes de IA, permitindo que eles construam, testem, consultem e gerenciem projetos Bazel por meio de linguagem natural, mesmo em ambientes onde o Bazel não pode ser acessado diretamente.

Room MCP

Uma ferramenta de linha de comando que permite o uso do MCP com o protocolo Room, permitindo que agentes criem e interajam em salas virtuais ponto a ponto para colaboração orientada a objetivos.

MCP-AnkiConnect

Um servidor MCP que integra o Claude com flashcards Anki, permitindo que os usuários revisem os cartões pendentes e criem novos flashcards diretamente através da conversa.

Google Tasks MCP Server

Integra-se com o Google Tasks para permitir listar, ler, pesquisar, criar, atualizar e excluir tarefas.

MCP Terminal Server

Um servidor de execução de terminal seguro que permite a execução controlada de comandos com recursos de segurança e limites de recursos através do Protocolo de Contexto de Modelo (MCP).

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.

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

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.

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://.

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.

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 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.