Discover Awesome MCP Servers

MCP Git Tools

Git tool integration library for the Model Context Protocol (MCP).

SuperGateway 介绍

Run MCP stdio servers over SSE and SSE over stdio. AI gateway.

Have I Been Pwned MCP Server

Um servidor de Protocolo de Contexto de Modelo (MCP) que oferece integração com a API Have I Been Pwned para verificar se suas contas ou senhas foram comprometidas em violações de dados.

IMCP

A macOS app that provides an MCP server to your Messages, Contacts, and more

Gmail AutoAuth MCP Server

Mirror of

mcp

interacting with claude desktop via mcp server , just exploring

MCP Development Server

Mirror of

Sonic Pi MCP

Um servidor de Protocolo de Contexto de Modelo que permite que assistentes de IA como Claude e Cursor criem música e controlem o Sonic Pi programaticamente através de mensagens OSC.

Sentry

Um servidor MCP que se conecta ao Sentry.io ou a instâncias Sentry auto-hospedadas para recuperar e analisar relatórios de erros, rastreamentos de pilha e informações de depuração.

easy-mcp

Absurdly easy Model Context Protocol Servers in Typescript

MCP Server for Asana

Mirror of

China Weather MCP Server

Servidor MCP para consultar o clima em cidades chinesas.

SQL Server MCP Server for Windsurf IDE

SQL Server MCP Server for Windsurf IDE - A standalone MCP server providing SQL Server integration capabilities

rag-browser

A Browser Automation Tool for Humans and AI - Built with Playwright, optimized for Bun runtime, supporting CLI and MCP Server modes for webpage analysis and automation

Crypto Fear & Greed Index MCP Server

Um servidor MCP que fornece dados do Índice de Medo e Ganância de Criptomoedas em tempo real e históricos.

P-GitHubTestRepo

criado a partir da demonstração do servidor MCP

TMDB MCP Server

Permite que assistentes de IA pesquisem e recuperem informações de filmes da API do The Movie Database (TMDB) através da interface do Protocolo de Contexto do Modelo.

GitHub MCP Server

everyday series assignment

MCP Kipris

Servidor MCP para KIPRIS Plus, para pesquisa de patentes em...

MCP Google Map Server

Um servidor de Protocolo de Contexto de Modelo que fornece integração com a API do Google Maps, permitindo que os usuários pesquisem locais, obtenham detalhes de lugares, geocodifiquem endereços, calculem distâncias, obtenham direções e recuperem dados de elevação por meio de recursos de processamento de LLM.

Todo Assistant with AI and Google Calendar Integration

AI-powered todo assistant with Google Calendar integration using OpenAI's API and Model Context Protocol (MCP) support for natural language task management.

Pocketbase Mcp

MCP-compliant PocketBase server implementation

Most Popular Model Context Protocol (MCP) Servers

Uma lista selecionada dos servidores de Protocolo de Contexto de Modelo (MCP) mais populares, com base em dados de uso da Smithery.ai.

MongoDB MCP Server

Espelho de

🌐 Starknet MCP Server

Starknet MCP server.

Typescript Mcp Server Usage

Please specify which "typescript sdk" you are referring to. "MCP server" is also ambiguous. It could refer to: * **Minecraft Protocol (MCP) server:** A server that implements the Minecraft network protocol. * **Media Control Protocol (MCP) server:** A server that uses a protocol for controlling media devices. * **Something else entirely.** Once you clarify which SDK and what kind of MCP server you're interested in, I can provide more relevant and helpful code examples. However, I can give you a *general* example of how you might structure a basic server using TypeScript and Node.js, which you can then adapt to your specific needs. This example uses the `ws` library for WebSocket communication, which is often used for game servers. ```typescript import * as WebSocket from 'ws'; // Define the port the server will listen on const PORT = 8080; // Create a WebSocket server instance const wss = new WebSocket.Server({ port: PORT }); console.log(`Server listening on port ${PORT}`); // Define a type for client data (you can customize this) interface ClientData { id: string; // Example: Unique client ID // Add other client-specific data here } // Store connected clients const clients: Map<WebSocket, ClientData> = new Map(); // Function to generate a unique ID for clients function generateClientId(): string { return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15); } // Event handler for when a client connects wss.on('connection', (ws: WebSocket) => { console.log('Client connected'); // Generate a unique ID for the client const clientId = generateClientId(); // Store client data const clientData: ClientData = { id: clientId }; clients.set(ws, clientData); // Send the client their ID ws.send(JSON.stringify({ type: 'clientId', id: clientId })); // Event handler for messages received from the client ws.on('message', (message: string) => { console.log(`Received message: ${message} from client ${clientId}`); // Process the message (e.g., parse JSON, handle commands) try { const data = JSON.parse(message); // Example: Handle a "ping" message if (data.type === 'ping') { ws.send(JSON.stringify({ type: 'pong', timestamp: Date.now() })); } else { console.log(`Unknown message type: ${data.type}`); } } catch (error) { console.error('Error parsing message:', error); ws.send(JSON.stringify({ type: 'error', message: 'Invalid message format' })); } // Example: Broadcast the message to all other clients clients.forEach((clientData, otherWs) => { if (otherWs !== ws) { otherWs.send(JSON.stringify({ type: 'broadcast', senderId: clientId, message: message })); } }); }); // Event handler for when the client disconnects ws.on('close', () => { console.log(`Client ${clientId} disconnected`); clients.delete(ws); }); // Event handler for errors ws.on('error', (error) => { console.error(`Error with client ${clientId}:`, error); clients.delete(ws); }); }); console.log('WebSocket server started'); ``` **Explanation:** 1. **Import `ws`:** Imports the `ws` library for WebSocket functionality. You'll need to install it: `npm install ws --save` or `yarn add ws`. 2. **`PORT`:** Defines the port the server will listen on. 3. **`WebSocket.Server`:** Creates a new WebSocket server instance. 4. **`wss.on('connection', ...)`:** This is the main event handler. It's called whenever a new client connects to the server. 5. **`clients: Map<WebSocket, ClientData>`:** A `Map` to store information about each connected client. The key is the `WebSocket` object, and the value is a `ClientData` object (which you can customize). 6. **`generateClientId()`:** A simple function to generate a unique ID for each client. 7. **`ws.on('message', ...)`:** This event handler is called when the server receives a message from a client. 8. **`JSON.parse(message)`:** Parses the message as JSON. This assumes that clients are sending JSON-formatted messages. 9. **Message Handling:** The example shows how to handle a simple "ping" message and how to broadcast messages to other clients. You'll need to adapt this to your specific protocol. 10. **`ws.on('close', ...)`:** This event handler is called when a client disconnects. 11. **`ws.on('error', ...)`:** This event handler is called if there's an error with the client's connection. 12. **Error Handling:** Includes basic error handling for message parsing and client connections. **How to Run:** 1. **Save:** Save the code as a `.ts` file (e.g., `server.ts`). 2. **Install Dependencies:** `npm install ws --save` or `yarn add ws` 3. **Compile:** `tsc server.ts` (You'll need TypeScript installed: `npm install -g typescript`) 4. **Run:** `node server.js` **Important Considerations and Next Steps:** * **Error Handling:** The error handling in this example is very basic. You'll need to add more robust error handling for production use. * **Security:** For a production server, you'll need to consider security issues such as authentication, authorization, and input validation. * **Scalability:** This example is a simple single-process server. For high-traffic applications, you'll need to consider scaling strategies such as using multiple processes or a load balancer. * **Protocol Definition:** Define a clear protocol for communication between the client and server. This will make it easier to develop and maintain your application. Consider using a schema definition language like Protocol Buffers or Avro for more complex protocols. * **Game Logic (if applicable):** If you're building a game server, you'll need to implement the game logic, such as handling player movement, collisions, and game rules. * **State Management:** Decide how you'll manage the state of the game or application. This could involve storing data in memory, in a database, or in a distributed cache. * **Logging:** Implement logging to track server activity and debug issues. **To get more specific help, please provide the following information:** * **Which "MCP server" are you trying to create?** (Minecraft, Media Control, or something else?) * **Which TypeScript SDK are you using?** (If it's a custom SDK, please provide details about it.) * **What are the specific requirements of your server?** (e.g., what kind of data will it handle, how many clients will it support, what security requirements are there?) Once I have this information, I can provide a more tailored and helpful code example. **Tradução para Português:** Por favor, especifique a qual "typescript sdk" você está se referindo. "Servidor MCP" também é ambíguo. Pode se referir a: * **Servidor Minecraft Protocol (MCP):** Um servidor que implementa o protocolo de rede do Minecraft. * **Servidor Media Control Protocol (MCP):** Um servidor que usa um protocolo para controlar dispositivos de mídia. * **Algo completamente diferente.** Assim que você esclarecer qual SDK e que tipo de servidor MCP você está interessado, posso fornecer exemplos de código mais relevantes e úteis. No entanto, posso fornecer um exemplo *geral* de como você pode estruturar um servidor básico usando TypeScript e Node.js, que você pode adaptar às suas necessidades específicas. Este exemplo usa a biblioteca `ws` para comunicação WebSocket, que é frequentemente usada para servidores de jogos. ```typescript import * as WebSocket from 'ws'; // Define a porta que o servidor irá escutar const PORT = 8080; // Cria uma instância do servidor WebSocket const wss = new WebSocket.Server({ port: PORT }); console.log(`Servidor escutando na porta ${PORT}`); // Define um tipo para os dados do cliente (você pode personalizar isso) interface ClientData { id: string; // Exemplo: ID único do cliente // Adicione outros dados específicos do cliente aqui } // Armazena os clientes conectados const clients: Map<WebSocket, ClientData> = new Map(); // Função para gerar um ID único para os clientes function generateClientId(): string { return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15); } // Manipulador de eventos para quando um cliente se conecta wss.on('connection', (ws: WebSocket) => { console.log('Cliente conectado'); // Gera um ID único para o cliente const clientId = generateClientId(); // Armazena os dados do cliente const clientData: ClientData = { id: clientId }; clients.set(ws, clientData); // Envia o ID do cliente para ele ws.send(JSON.stringify({ type: 'clientId', id: clientId })); // Manipulador de eventos para mensagens recebidas do cliente ws.on('message', (message: string) => { console.log(`Mensagem recebida: ${message} do cliente ${clientId}`); // Processa a mensagem (por exemplo, analisa JSON, lida com comandos) try { const data = JSON.parse(message); // Exemplo: Lida com uma mensagem "ping" if (data.type === 'ping') { ws.send(JSON.stringify({ type: 'pong', timestamp: Date.now() })); } else { console.log(`Tipo de mensagem desconhecido: ${data.type}`); } } catch (error) { console.error('Erro ao analisar a mensagem:', error); ws.send(JSON.stringify({ type: 'error', message: 'Formato de mensagem inválido' })); } // Exemplo: Transmite a mensagem para todos os outros clientes clients.forEach((clientData, otherWs) => { if (otherWs !== ws) { otherWs.send(JSON.stringify({ type: 'broadcast', senderId: clientId, message: message })); } }); }); // Manipulador de eventos para quando o cliente se desconecta ws.on('close', () => { console.log(`Cliente ${clientId} desconectado`); clients.delete(ws); }); // Manipulador de eventos para erros ws.on('error', (error) => { console.error(`Erro com o cliente ${clientId}:`, error); clients.delete(ws); }); }); console.log('Servidor WebSocket iniciado'); ``` **Explicação:** 1. **Importa `ws`:** Importa a biblioteca `ws` para funcionalidade WebSocket. Você precisará instalá-la: `npm install ws --save` ou `yarn add ws`. 2. **`PORT`:** Define a porta que o servidor irá escutar. 3. **`WebSocket.Server`:** Cria uma nova instância do servidor WebSocket. 4. **`wss.on('connection', ...)`:** Este é o principal manipulador de eventos. É chamado sempre que um novo cliente se conecta ao servidor. 5. **`clients: Map<WebSocket, ClientData>`:** Um `Map` para armazenar informações sobre cada cliente conectado. A chave é o objeto `WebSocket` e o valor é um objeto `ClientData` (que você pode personalizar). 6. **`generateClientId()`:** Uma função simples para gerar um ID único para cada cliente. 7. **`ws.on('message', ...)`:** Este manipulador de eventos é chamado quando o servidor recebe uma mensagem de um cliente. 8. **`JSON.parse(message)`:** Analisa a mensagem como JSON. Isso assume que os clientes estão enviando mensagens formatadas em JSON. 9. **Tratamento de Mensagens:** O exemplo mostra como lidar com uma mensagem "ping" simples e como transmitir mensagens para outros clientes. Você precisará adaptar isso ao seu protocolo específico. 10. **`ws.on('close', ...)`:** Este manipulador de eventos é chamado quando um cliente se desconecta. 11. **`ws.on('error', ...)`:** Este manipulador de eventos é chamado se houver um erro com a conexão do cliente. 12. **Tratamento de Erros:** Inclui tratamento de erros básico para análise de mensagens e conexões de clientes. **Como Executar:** 1. **Salvar:** Salve o código como um arquivo `.ts` (por exemplo, `server.ts`). 2. **Instalar Dependências:** `npm install ws --save` ou `yarn add ws` 3. **Compilar:** `tsc server.ts` (Você precisará do TypeScript instalado: `npm install -g typescript`) 4. **Executar:** `node server.js` **Considerações Importantes e Próximos Passos:** * **Tratamento de Erros:** O tratamento de erros neste exemplo é muito básico. Você precisará adicionar um tratamento de erros mais robusto para uso em produção. * **Segurança:** Para um servidor de produção, você precisará considerar questões de segurança, como autenticação, autorização e validação de entrada. * **Escalabilidade:** Este exemplo é um servidor simples de processo único. Para aplicações de alto tráfego, você precisará considerar estratégias de escalonamento, como usar múltiplos processos ou um balanceador de carga. * **Definição de Protocolo:** Defina um protocolo claro para comunicação entre o cliente e o servidor. Isso tornará mais fácil desenvolver e manter sua aplicação. Considere usar uma linguagem de definição de esquema como Protocol Buffers ou Avro para protocolos mais complexos. * **Lógica do Jogo (se aplicável):** Se você estiver construindo um servidor de jogos, precisará implementar a lógica do jogo, como lidar com o movimento do jogador, colisões e regras do jogo. * **Gerenciamento de Estado:** Decida como você irá gerenciar o estado do jogo ou aplicação. Isso pode envolver armazenar dados na memória, em um banco de dados ou em um cache distribuído. * **Registro (Logging):** Implemente o registro para rastrear a atividade do servidor e depurar problemas. **Para obter ajuda mais específica, forneça as seguintes informações:** * **Qual "servidor MCP" você está tentando criar?** (Minecraft, Media Control ou algo mais?) * **Qual TypeScript SDK você está usando?** (Se for um SDK personalizado, forneça detalhes sobre ele.) * **Quais são os requisitos específicos do seu servidor?** (por exemplo, que tipo de dados ele irá lidar, quantos clientes ele irá suportar, quais são os requisitos de segurança?) Assim que eu tiver essas informações, posso fornecer um exemplo de código mais personalizado e útil.