Hospede seu servidor MCP Node.js no Azure Functions em uma etapa simples

Construir agentes de IA com o Model Context Protocol (MCP) é poderoso, mas quando se trata de hospedar seu servidor MCP em produção, você precisa de uma solução que seja confiável, escalonável e econômica. E se você pudesse implantar seu servidor MCP Node.js normal em uma plataforma sem servidor que lide com o escalonamento automaticamente enquanto você paga apenas pelo que usa?

Vamos explorar como o Azure Functions agora dá suporte à hospedagem de servidores MCP criados com o Anthropic MCP SDK oficial, proporcionando escalabilidade sem servidor quase sem alterações em seu código.

Pegue sua bebida quente favorita e vamos mergulhar!

Principais conclusões de TL;DR

• O Azure Functions agora oferece suporte à hospedagem de servidores MCP Node.js usando o Anthropic SDK oficial
• É necessária apenas uma configuração simples: adicionar host.json arquivo
• Atualmente suporta protocolo HTTP Streaming com servidores sem estado
• Hospedagem sem servidor significa escalonamento automático e preços pagos conforme o uso
• Implante com um comando usando infraestrutura como código

O que você aprenderá aqui?

• Entenda como os servidores MCP funcionam no Azure Functions
• Configurar um servidor MCP Node.js para hospedagem do Azure Functions
• Teste seu servidor MCP localmente e com agentes reais de IA
• Implante seu servidor MCP com infraestrutura como código e AZD

Links de referência para tudo que usamos

Requisitos

O que é MCP e por que isso é importante?

O Model Context Protocol é um padrão aberto que permite que modelos de IA interajam de forma segura com ferramentas externas e fontes de dados. Em vez de integrações de ferramentas codificadas, você cria um servidor MCP que expõe recursos (como navegar em um menu, fazer pedidos ou consultar um banco de dados) como ferramentas que qualquer agente de IA compatível com MCP pode descobrir e usar. O MCP é independente de modelo, o que significa que pode funcionar com qualquer LLM que suporte o protocolo, incluindo modelos da Anthropic, OpenAI e outros. Também é importante notar que o MCP oferece suporte a mais do que apenas chamadas de ferramentas, embora esse seja o caso de uso mais comum.

O desafio? A execução de servidores MCP em produção requer infraestrutura. Você precisa lidar com escalonamento, monitoramento e custos. É aí que entra o Azure Functions.

🚨Alerta de curso grátis! Se você é novo no MCP, confira o MCP para iniciantes claro para se atualizar rapidamente.

Por que Azure Functions para servidores MCP?

O Azure Functions é uma plataforma de computação sem servidor perfeita para servidores MCP:

• Gerenciamento zero de infraestrutura: Não há servidores para manter
• Dimensionamento automático: Lida perfeitamente com picos de tráfego
• Econômico: Pague apenas pelo tempo real de execução (com generosa concessão gratuita)
• Monitoramento integrado: Integração do Application Insights pronta para uso
• Distribuição global: Implante em regiões em todo o mundo

O novo suporte do Azure Functions significa que você pode usar seu servidor MCP Node.js existente e implantá-lo em um ambiente sem servidor pronto para produção com alterações mínimas. Isso surge como uma opção adicional para hospedagem MCP nativa do Node.js, mas você ainda pode usar o Ligações MCP do Azure Functions que estavam disponíveis antes.

1 passo simples para habilitar a hospedagem do Functions

Vamos detalhar o que você precisa adicionar ao seu servidor MCP Node.js existente para executá-lo no Azure Functions. vou usar um exemplo do mundo real do nosso sistema de pedidos de hambúrguer.

Se você já tem um servidor MCP Node.js em funcionamento, basta seguir isto para torná-lo compatível com a hospedagem do Azure Functions.

Etapa 1: adicione o host.json configuração

Crie um host.json arquivo na raiz do seu projeto Node.js:

{
  "version": "2.0",
  "configurationProfile": "mcp-custom-handler",
  "customHandler": {
    "description": {
      "defaultExecutablePath": "node",
      "arguments": ("lib/server.js")
    },
    "http": {
      "DefaultAuthorizationLevel": "anonymous"
    },
    "port": "3000"
  }
}

Observação: Ajuste o arguments array para apontar para o arquivo do servidor compilado (por exemplo, lib/server.js ou dist/server.js), dependendo da configuração da sua compilação. Você também pode alterar a porta, se necessário, para corresponder à configuração do seu servidor. O hosts.json arquivo contém configuração de metadados para o tempo de execução do Functions. A parte mais importante aqui é a customHandler seção. Ele configura o runtime do Azure Functions para executar seu servidor Node.js MCP como um manipulador personalizadoque permite usar qualquer estrutura de servidor HTTP (como Express, Fastify, etc.) sem modificação (dica: ele pode fazer mais que servidores MCP! 😉).

Não há etapa 2 ou 3. É isso aí! 😎

Observação: Não abordamos aqui os aspectos de autenticação e autorização do Azure Functions, mas você pode facilmente adicione-os mais tarde, se necessário.

Exemplo do mundo real: Burger MCP Server

Vejamos como isso funciona na prática com um pedido de hambúrguer servidor MCP. Este servidor expõe 9 ferramentas para agentes de IA interagirem com uma API de hambúrguer:

• get_burgers – Navegue pelo cardápio
• get_burger_by_id – Obtenha detalhes do hambúrguer
• place_order – Faça um pedido
• get_orders – Ver histórico de pedidos
• E mais…

Aqui está a implementação completa do servidor usando Express e o SDK MCP:

import express, { Request, Response } from 'express';
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
import { getMcpServer } from './mcp.js';

const app = express();
app.use(express.json());

// Handle all MCP Streamable HTTP requests
app.all('/mcp', async (request: Request, response: Response) => {
  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: undefined,
  });

  // Connect the transport to the MCP server
  const server = getMcpServer();
  await server.connect(transport);

  // Handle the request with the transport
  await transport.handleRequest(request, response, request.body);

  // Clean up when the response is closed
  response.on('close', async () => {
    await transport.close();
    await server.close();
  });

  // Note: error handling not shown for brevity
});

// The port configuration
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Burger MCP server listening on port ${PORT}`);
});

As ferramentas MCP são definidas usando o SDK oficial:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';

export function getMcpServer() {
  const server = new McpServer({
    name: 'burger-mcp',
    version: '1.0.0',
  });

  server.registerTool(
    'get_burgers',
    { description: 'Get a list of all burgers in the menu' },
    async () => {
      const response = await fetch(`${burgerApiUrl}/burgers`);
      const burgers = await response.json();
      return {
        content: ({
          type: 'text',
          text: JSON.stringify(burgers, null, 2)
        })
      };
    }
  );

  // ... more tools
  return server;
}

Como você pode ver, a implementação real da ferramenta é encaminhar uma solicitação HTTP para a API do hambúrguer e retornar o resultado no formato de resposta MCP. Este é um padrão comum para ferramentas MCP em contextos empresariais, que atuam como wrappers em torno de uma ou mais APIs existentes.

Limitações atuais

Observe que esta hospedagem MCP do Azure Functions tem atualmente algumas limitações: ele suporta apenas servidores sem estado usando o protocolo HTTP Streaming. O protocolo SSE legado não é compatível porque requer conexões com estado, então você terá que migrar seu cliente para usar o streaming HTTP ou usar outra opção de hospedagem, como usar contêineres, por exemplo.

Para a maioria dos casos de uso, o HTTP Streaming é a abordagem recomendada, pois é mais escalonável e não requer conexões persistentes. Os servidores MCP stateful apresentam desafios de complexidade adicionais e têm escalabilidade limitada se você precisar lidar com muitas conexões simultâneas.

Testando o servidor MCP localmente

Primeiro, vamos executar o servidor MCP localmente e brincar um pouco com ele.

Se não quiser se preocupar em configurar um ambiente local, você pode usar o link a seguir ou abri-lo em uma nova guia para iniciar um Codespace GitHub:

Isso abrirá um ambiente VS Code em seu navegador com o repositório já clonado e todas as ferramentas instaladas e prontas para uso. Caso contrário, você pode simplesmente clonar o repositório.

Depois de ter o código pronto, abra um terminal e execute:

# Install dependencies
npm install

# Start the burger MCP server and API
npm start

Isso iniciará vários serviços localmente, incluindo a API Burger e o servidor MCP, que estarão disponíveis em http://localhost:3000/mcp. Isso pode demorar alguns segundos, espere até ver esta mensagem no terminal:

🚀 All services ready 🚀

Por enquanto, estamos interessados ​​apenas no servidor MCP, então vamos nos concentrar nisso.

Usando o Inspetor MCP

A maneira mais fácil de testar o servidor MCP é com a ferramenta MCP Inspector:

npx -y @modelcontextprotocol/inspector

Abra o URL mostrado no console do seu navegador e:

1. Defina o tipo de transporte como HTTP streamável
2. Insira o URL do seu servidor local: http://localhost:3000/mcp
3. Clique Conectar

Depois de estar conectado, vá para o Ferramentas guia para listar as ferramentas disponíveis. Você pode então tentar o get_burgers ferramenta para ver o menu de hambúrguer.

Usando GitHub Copilot (com MCP remoto)

Configure GitHub Copilot para usar seu servidor MCP implantado adicionando isto ao seu projeto .vscode/mcp.json:

{
  "servers": {
    "burger-mcp": {
      "type": "http",
      "url": "http://localhost:3000/mcp"
    }
  }
}

Clique no botão “Iniciar” que aparecerá no arquivo JSON para ativar a conexão do servidor MCP.

Agora você pode usar o Copilot no modo de agente e fazer perguntas como:

• “Que hambúrgueres picantes você tem?”
• “Faça um pedido de dois cheeseburgers”
• “Mostrar meus pedidos recentes”

O Copilot descobrirá e usará automaticamente as ferramentas MCP! 🎉

Dica: Se o Copilot não chamar as ferramentas do Burger MCP, tente verificar se está habilitado clicando no ícone da ferramenta na caixa de entrada do chat e garantindo que “burger-mcp” esteja selecionado. Você também pode forçar o uso da ferramenta adicionando #burger-mcp em seu prompt.

(Bônus) Implantando no Azure com infraestrutura como código

A implantação de um aplicativo no Azure geralmente não é a parte divertida, especialmente quando envolve vários recursos e configurações. Com o CLI do desenvolvedor do Azure (AZD)você pode definir toda a infraestrutura do aplicativo e o processo de implantação como código e implantar tudo com um único comando.

Se você usou a configuração automatizada com GitHub Copilot, você já deverá ter os arquivos necessários. Nosso exemplo de hambúrguer também vem com esses arquivos pré-configurados. O servidor MCP é definido como um serviço em azure.yamle os arquivos sob o infra pasta define o aplicativo Azure Functions e os recursos relacionados.

Aqui está a parte relevante azure.yaml que define o serviço de hambúrguer MCP:

name: mcp-agent-langchainjs

services:
  burger-mcp:
    project: ./packages/burger-mcp
    language: ts
    host: function

Embora os arquivos de infraestrutura possam parecer intimidantes no início, você não precisa entender todos os detalhes para começar. Existem vários modelos e exemplos disponíveis para ajudá-lo a começar rapidamente. O importante é que tudo seja definido como código, para que você possa controlar a versão e reutilizá-lo.

Agora vamos implantar:

# Login to Azure
azd auth login

# Provision resources and deploy
azd up

Escolha sua região preferida do Azure quando solicitado (se não tiver certeza, escolha Leste dos EUA2) e voilá! Em alguns minutos, você terá um servidor MCP totalmente implantado em execução no Azure Functions.

Assim que a implantação for concluída, a CLI mostrará a URL dos recursos implantados, incluindo o endpoint do servidor MCP.

Projetos de exemplo

O servidor Burger MCP é, na verdade, parte de um projeto de exemplo maior que demonstra a construção de um agente de IA com LangChain.js, que usa o servidor Burger MCP para fazer pedidos. Se você estiver interessado nas próximas etapas de construção de um agente de IA baseado no MCP, este é um ótimo recurso, pois inclui:

• API da web do agente de IA usando LangChain.js
• Interface de aplicativo da web criada com componentes da web do Lit
• Servidor MCP em Functions (aquele que acabamos de ver)
• API de pedidos de hambúrguer (usada pelo servidor MCP)
• Visualização de pedidos ao vivo
• Infraestrutura completa como código, para implantar tudo com um comando

Mas se você estiver interessado apenas na parte do servidor MCP, talvez queira dar uma olhada neste exemplo mais simples que pode usar como ponto de partida para seus próprios servidores MCP: nó de hospedagem mcp-sdk-functions é um modelo de servidor para um servidor Node.js MCP usando TypeScript e MCP SDK.

E quanto ao custo?

O preço do Azure Functions Flex Consumption é atraente para servidores MCP:

• Concessão gratuita: 1 milhão de solicitações e tempo de execução de 400.000 GB-s por mês
• Após concessão gratuita: Pague apenas pelo tempo real de execução
• Dimensionamento automático: De zero a centenas de instâncias

A concessão gratuita é generosa o suficiente para permitir a execução de um servidor MCP típico com uso moderado e toda a experimentação necessária. É fácil configurar os limites de escalabilidade para controlar os custos conforme necessário, com a opção de reduzir para zero quando ocioso. Essa flexibilidade é a razão pela qual o Functions é minha escolha pessoal para projetos TypeScript no Azure.

Concluir

Hospedar servidores MCP no Azure Functions oferece o melhor dos dois mundos: a simplicidade da infraestrutura sem servidor e o poder do Anthropic SDK oficial. Com apenas uma simples etapa de configuraçãovocê pode pegar seu servidor MCP Node.js existente e implantá-lo em uma plataforma de escalonamento automático pronta para produção.

A combinação do protocolo padronizado do MCP e da plataforma sem servidor do Azure significa que você pode se concentrar na criação de experiências de IA incríveis em vez de gerenciar a infraestrutura. Bum. 😎

Marque os repositórios com estrela ⭐️ se você achou isso útil! Tente implantar seu próprio servidor MCP e compartilhe sua experiência nos comentários. Se você tiver algum problema ou tiver dúvidas, pode pedir ajuda no Comunidade Azure AI no Discord.