Discover Awesome MCP Servers

🌐 Starknet MCP Server

Starknet MCP server.

MCP Stock Market

Uma ferramenta de Protocolo de Contexto de Modelo que recupera dados diários do mercado de ações para qualquer símbolo de ação usando a API Alpha Vantage.

MCP Servers - OpenAI and Flux Integration

Mirror of

mcp-server-weaviate

Um servidor que permite que a IA Claude interaja com bancos de dados vetoriais Weaviate, suportando operações de busca e armazenamento através do protocolo MCP da Anthropic.

Coco AI

Coco AI App - Pesquise, Conecte-se, Colabore, Seu Assistente e Busca pessoal com IA, tudo em um só lugar.

mcp-server-imessage

Servidor MCP para interagir com o iMessage no macOS

Unity AI MCP Server

An MCP server that provides AI-powered tools and assistance for Unity game development, integrating with Cursor IDE

Advanced PocketBase MCP Server

Mirror of

YouTube Transcript Server

Espelho de

WorldTime MCP Server

Um servidor MCP de fuso horário baseado na API OSS TimezoneDB.

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.

anitabi-mcp-server

anitabi 巡礼地图的 MCP Server

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.

mcp-remote-server

Mirror of

National Parks MCP Server

Fornece informações em tempo real sobre os Parques Nacionais dos EUA através da API do NPS, permitindo que os usuários pesquisem parques, verifiquem detalhes, alertas, centros de visitantes, acampamentos e próximos eventos.

MongoDB MCP Server

Espelho de

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.

MCP server for CData Connect Cloud サンプル

MCP server for CData Connect Cloud

Query MCP (Supabase MCP Server)

Espelho de

MCP Windows Desktop Automation

Um servidor de Protocolo de Contexto de Modelo que envolve a funcionalidade do AutoIt, permitindo que LLMs automatizem tarefas na área de trabalho do Windows, incluindo operações de mouse/teclado, gerenciamento de janelas e interações de controle de interface do usuário.

D&D Knowledge Navigator

Implementação de servidor MCP da API de D&D 5e usando recursos, ferramentas e prompts.

Pokemon MCP Demo

A quick pokemon demo to showcase MCP server, client, and host

MCP Cortex

MCP server implementation for advanced document and knowledge graph processing

DemiCode

Ringkasan tentang awesome-mcp-servers - koleksi server Model Context Protocol (MCP)