Blog

Como Criar, Publicar e Hospedar Servidores de Minecraft (MCP) na Netlify

Ashley Goolam

Ashley Goolam

15 julho 2025

Como Criar, Publicar e Hospedar Servidores de Minecraft (MCP) na Netlify

Você está pronto para turbinar seus fluxos de trabalho de IA com o Servidor MCP no Netlify? Imagine dar aos seus agentes de IA — como Claude, Cursor ou VS Code Copilot — uma linha direta para as ferramentas e dados da sua plataforma, tudo hospedado na elegante infraestrutura serverless do Netlify. Neste guia divertido e conversacional, vamos explorar o que é o Servidor MCP no Netlify, por que ele é incrível e como construí-lo, implantá-lo e hospedá-lo passo a passo. Além disso, vamos testá-lo com um exemplo legal para garantir que está funcionando. Vamos mergulhar e deixar sua IA mais inteligente!

💡
Quer uma ótima ferramenta de Teste de API que gera uma linda Documentação de API?

Quer uma plataforma integrada e completa para sua Equipe de Desenvolvedores trabalhar em conjunto com máxima produtividade?

Apidog entrega todas as suas demandas e substitui o Postman por um preço muito mais acessível!
botão

O Que É um Servidor MCP e Por Que o Netlify?

O Model Context Protocol (MCP) é como um adaptador universal para agentes de IA. É um padrão aberto e leve que permite que clientes de IA (por exemplo, Claude Desktop ou Cursor) se comuniquem com servidores que expõem ferramentas, dados e prompts. Isso significa que sua IA pode interagir com os recursos do seu aplicativo em tempo real, tornando-a ciente do contexto e muito mais útil.

Hospedar seu Servidor MCP no Netlify é uma escolha óbvia. A plataforma serverless do Netlify é escalável, de baixa manutenção e perfeita para implantar servidores MCP. Ela lida com o trabalho pesado — picos de tráfego, atualizações e segurança — para que você possa se concentrar na construção de integrações de IA incríveis. Seja adicionando IA a um blog, site de e-commerce ou aplicativo personalizado, o Servidor MCP no Netlify torna tudo perfeito.

site oficial do netlify

Por Que Você Vai Adorar Hospedar Servidores MCP no Netlify

Aqui está o porquê o Servidor MCP no Netlify é um divisor de águas:

Pronto para dar vida à sua IA? Vamos configurar seu Servidor MCP no Netlify!

implantar no netlify

Construindo, Implantando e Hospedando Servidores MCP no Netlify

Pré-requisitos

Antes de começarmos, certifique-se de ter:

Passo 1: Configure Seu Projeto Netlify

Configurar Estrutura do Projeto:

Exemplo de estrutura:

/mcp-netlify
  /netlify
    /functions
      mcp.js

Criar um Site Netlify:

Passo 2: Implementar a Função do Servidor MCP

Crie o arquivo mcp.js em /netlify/functions para definir seu Servidor MCP no Netlify. Isso usa o SDK do MCP para expor ferramentas, recursos e prompts a clientes de IA.

Aqui está um exemplo para mcp.js:

import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import { toFetchResponse, toReqRes } from "fetch-to-node";
import { z } from "zod";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import {
  CallToolResult,
  ReadResourceResult,
  JSONRPCError
} from "@modelcontextprotocol/sdk/types.js";

// Netlify serverless function handler which handles all inbound requests
export default async (req: Request) => {

  try {

    // for stateless MCP, we'll only use the POST requests that are sent
    // with event information for the init phase and resource/tool requests
    if (req.method === "POST") {

      // Convert the Request object into a Node.js Request object
      const { req: nodeReq, res: nodeRes } = toReqRes(req);
      const server = getServer();

      const transport = new StreamableHTTPServerTransport({
        sessionIdGenerator: undefined,
      });

      await server.connect(transport);

      const body = await req.json();
      await transport.handleRequest(nodeReq, nodeRes, body);

      nodeRes.on("close", () => {
        console.log("Request closed");
        transport.close();
        server.close();
      });

      return toFetchResponse(nodeRes);

    }

    return new Response("Method not allowed", { status: 405 });

  } catch (error) {

    console.error("MCP error:", error);
    return new Response(
      JSON.stringify({
        jsonrpc: "2.0",
        error: {
          code: -32603,
          message: "Internal server error",
        },
        id: '',
      } satisfies JSONRPCError),
      {
        status: 500,
        headers: { "Content-Type": "application/json" }
      }
    );
  }
};

function getServer(): McpServer {

  // initialize our MCP Server instance that we will
  // attach all of our functionality and data.
  const server = new McpServer(
    {
      name: "acme-devtool-server",
      version: "1.0.0",
    },
    { capabilities: { logging: {} } }
  );


  server.tool(
    "run-analysis-report",
    "Checks the data available in Acme Devtool and returns all of the important data regarding the latest numbers.",
    {
      days: z.number().describe("Number of days to analyze").default(7),
    },
    async (
      { days },
    ): Promise<CallToolResult> => {

      const random = Math.random() * 100;

      return {
        content: [
          {
            type: "text",
            text: JSON.stringify({
              lastNDays: days,
              data: Array.from({ length: days }, (_, i) => `Day ${i + 1} had ${random * days} growth.`),
            }),
          },
        ],
      };
    }
  );

  // providing a resource for agents that might need to take a given report
  // and parse the information in it
  server.resource(
    "interpreting-reports",
    "acme://interpreting-reports",
    { mimeType: "text/plain" },
    async (): Promise<ReadResourceResult> => {
      return {
        contents: [
          {
            uri: "acme://interpreting-reports",
            text: `Reports from Acme will include an array of text that informs the growth of over that number of days. It's unstructured text but is consistent so parsing the information can be based on looking at a single line to understand where the data is.`,
          },
        ],
      };
    }
  );

  return server;
};

// Ensure this function responds to the <domain>/mcp path
// This can be any path you want but you'll need to ensure the
// mcp server config you use/share matches this path.
export const config = {
  path: "/mcp"
};

Isso cria um endpoint MCP serverless em /.netlify/functions/mcp. Personalize tools, resources e prompts com base nas necessidades do seu aplicativo (por exemplo, chamadas de API, consultas de banco de dados).

Passo 3: Instalar Dependências

Na pasta do seu projeto, inicialize um projeto Node.js e instale o SDK do MCP:

npm init -y
npm install @modelcontextprotocol/sdk

Passo 4: Desenvolvimento e Teste Local

  1. Instalar Netlify CLI:
npm install -g netlify-cli

2. Executar Localmente:

netlify dev

Isso inicia um servidor local em http://localhost:8888. Seu Servidor MCP no Netlify estará disponível em:

http://localhost:8888/.netlify/functions/mcp

3. Testar com o Inspetor MCP:

Use o Inspetor MCP para verificar seu servidor:

npx @modelcontextprotocol/inspector npx mcp-remote@next http://localhost:8888/mcp

Abra http://localhost:6274 no seu navegador para explorar as ferramentas e recursos do seu servidor interativamente.

testar com o inspetor mcp

Passo 5: Implantar Seu Servidor MCP no Netlify

Você tem duas opções de implantação:

Opção 1: Implantação Baseada em Git

  1. Envie seu projeto para um repositório GitHub, GitLab ou Bitbucket.
  2. No Netlify, vincule o repositório ao seu site em Configuração do site > Build & deploy.
  3. O Netlify implanta automaticamente a cada push para sua branch principal.
instalar netlify no repositório github

Opção 2: Implantação Via CLI

Implante diretamente com o Netlify CLI:

netlify deploy

Para produção:

netlify deploy --prod

Após a implantação, seu Servidor MCP no Netlify estará ativo em:

https://your-site-name.netlify.app/.netlify/functions/mcp

Anote a URL para o próximo passo.

Passo 6: Conectar Clientes MCP ao Seu Servidor MCP do Netlify

Configure seu cliente de IA (Claude Desktop, Cursor, Windsurf ou VS Code Copilot) para se conectar ao seu Servidor MCP no Netlify implantado. Use uma destas configurações:

Para Teste Local

{
  "mcpServers": {
    "my-netlify-mcp": {
      "command": "npx",
      "args": [
        "mcp-remote@next",
        "http://localhost:8888/mcp"
      ]
    }
  }
}

Para Servidor Implantado

{
  "mcpServers": {
    "my-netlify-mcp": {
      "command": "npx",
      "args": [
        "mcp-remote@next",
        "https://your-site-name.netlify.app/mcp"
      ]
    }
  }
}

Substitua your-site-name.netlify.app pela URL real do seu site Netlify.

Configuração do Cliente

Claude Desktop:

  1. Vá para Configurações > Desenvolvedor > Editar Config.
  2. Abra claude_desktop_config.json, cole a configuração e salve.
  3. Reinicie o Claude Desktop.
claude editar configuração mcp

Cursor:

  1. Vá para Configurações > Ferramentas e Integrações > Adicionar um Servidor MCP Personalizado.
  2. Cole a configuração e salve.
  3. Mude para o Modo Agente no painel de chat.
editar configuração mcp do cursor

VS Code Copilot:

  1. Abra Configurações (Ctrl+, ou Cmd+,).
  2. Procure por “MCP” e habilite-o em Recursos > Chat.
  3. Clique em Editar em settings.json, cole a configuração e salve.
editar configuração mcp do vs code

Passo 7: Testar Seu Servidor MCP

Vamos testar seu Servidor MCP no Netlify com um prompt de exemplo em seu cliente MCP:

Usando o Servidor MCP no Netlify, você pode gerar um relatório para os últimos 3 dias?

Se você usou o exemplo mcp.js acima, a IA deve responder com algo como:

testando o servidor mcp remoto

Isso confirma que seu servidor está funcionando. Personalize seu mcp.js para adicionar ferramentas reais (por exemplo, integrações de API, consultas de banco de dados) para tarefas mais complexas.

Passo 8: Inspecionar e Depurar

npx @modelcontextprotocol/inspector npx mcp-remote@next https://your-site-name.netlify.app/mcp

Melhores Práticas para Servidores MCP no Netlify

Dicas de Solução de Problemas

Por Que Hospedar Servidores MCP no Netlify?

O Servidor MCP no Netlify é uma combinação perfeita para fluxos de trabalho impulsionados por IA. A plataforma serverless do Netlify escala sem esforço, então seu servidor MCP pode lidar com milhares de solicitações de IA sem travar. Além disso, sua implantação baseada em Git e CLI tornam as atualizações muito fáceis. Esteja você construindo um chatbot, uma ferramenta de gerenciamento de conteúdo ou uma integração de e-commerce, hospedar seu Servidor MCP no Netlify garante que seus agentes de IA tenham acesso dinâmico e em tempo real aos recursos da sua plataforma.

Por exemplo, você poderia criar uma ferramenta MCP para buscar dados de usuários da API do seu aplicativo ou acionar fluxos de trabalho automatizados com base em prompts de IA. A configuração serverless significa que você não precisa gerenciar servidores — apenas codificar, implantar e deixar o Netlify fazer o resto.

Conclusão

E pronto! Você acabou de aprender como construir, implantar e hospedar um Servidor MCP no Netlify, transformando seus agentes de IA em potências de produtividade. Desde a configuração de uma simples função serverless até a conexão com Claude, Cursor ou VS Code, este guia facilita a integração da IA com sua plataforma. Nosso prompt de teste — “process the query: Hello, Netlify!” — mostra como é simples começar.

Pronto para ir além? Adicione ferramentas personalizadas ao seu mcp.js, como chamadas de API ou consultas de banco de dados, e veja sua IA fazer coisas incríveis.

💡
Quer uma ótima ferramenta de Teste de API que gera uma linda Documentação de API?

Quer uma plataforma integrada e completa para sua Equipe de Desenvolvedores trabalhar em conjunto com máxima produtividade?

Apidog entrega todas as suas demandas e substitui o Postman por um preço muito mais acessível!
botão

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar