MCP 3D Printer Server

Agradecimentos à FULU e a Louis Rossmann

Obrigado à Fundação FULU e a Louis Rossmann por defenderem a propriedade do consumidor, os desenvolvedores de código aberto, os direitos de reparo e os usuários que não deveriam ter hardware funcional piorado por software restritivo. Este servidor MCP trata o fork FULU OrcaSlicer-bambulab como um alvo de slicer de projeto Bambu de primeira classe.

MCP 3D Printer Server

Descrição

Este é um servidor que permite que usuários MCP se conectem aos endpoints de API destas impressoras 3D:

• OctoPrint
• Klipper (Moonraker)
• Duet
• Repetier
• Bambu Labs
• Prusa Connect
• Creality/Ender

Este servidor é um servidor Model Context Protocol (MCP) para conectar o Claude a sistemas de gerenciamento de impressoras 3D. Ele permite que o MCP interaja com impressoras 3D por meio das APIs de vários sistemas de gerenciamento de impressoras, como OctoPrint, Klipper (via Moonraker), Duet, Repetier e impressoras Bambu Labs.

Nota sobre Uso de Recursos: Este servidor MCP inclui recursos avançados de manipulação de modelos 3D que podem consumir muita memória ao trabalhar com arquivos STL grandes. Consulte a seção "Limitações e Considerações" para obter informações importantes sobre uso de memória e desempenho.

Recursos

• Obter o status da impressora (temperaturas, progresso da impressão, etc.)
• Listar arquivos na impressora
• Enviar arquivos G-code para a impressora
• Iniciar, cancelar e monitorar trabalhos de impressão
• Definir temperaturas da impressora
• Manipulação avançada de arquivos STL:
  • Estender a base para melhor aderência
  • Escalar modelos uniformemente ou ao longo de eixos específicos
  • Rotacionar modelos em torno de qualquer eixo
  • Transladar (mover) modelos
  • Modificar seções específicas de arquivos STL (superior, inferior, centro ou personalizado)
• Análise abrangente de STL com informações detalhadas do modelo
• Gerar visualizações SVG de múltiplos ângulos de arquivos STL
• Relatórios de progresso em tempo real para operações longas
• Tratamento de erros com diagnósticos detalhados
• Fatiar arquivos STL para gerar G-code
• Confirmar configurações de temperatura em arquivos G-code
• Fluxo de trabalho completo de ponta a ponta, da modificação de STL à impressão
• Imprimir arquivos .3mf diretamente em impressoras Bambu Lab (via comando MQTT)
• Fatiar projetos Bambu com FULU OrcaSlicer-bambulab (SLICER_TYPE=orcaslicer-bambulab) e fatiar automaticamente arquivos 3MF não fatiados antes da impressão Bambu quando um slicer de projeto está configurado
• Inspecionar e sondar o runtime FULU BambuNetwork (check_fulu_orca_setup) e chamar métodos RPC de ponte FULU seguros por padrão para diagnósticos e desenvolvimento (fulu_bambu_network_rpc)
• Ler arquivos de predefinição do Bambu Studio (impressora, filamento, processo) como recursos

Instalação

Pré-requisitos

• Node.js 18 ou superior
• npm ou yarn

Instalar a partir do npm

npm install -g mcp-3d-printer-server

Instalar a partir do código-fonte

git clone https://github.com/dmontgomery40/mcp-3d-printer-server.git
cd mcp-3d-printer-server
npm install
npm link  # Makes the command available globally

Executando com Docker

Você também pode executar o servidor usando Docker e Docker Compose para um ambiente conteinerizado.

1. Certifique-se de ter Docker e Docker Compose instalados.
2. Copie .env.example para .env e configure suas definições.
3. Compile e execute o contêiner:

   docker-compose up --build -d
   

Usando Slicers com Docker

Observe que a configuração padrão do Docker não pode usar diretamente um slicer instalado na sua máquina host. Montar o executável do slicer diretamente do host no contêiner não é confiável devido às diferenças de sistema operacional e bibliotecas entre o host e o contêiner.

A abordagem recomendada é instalar o slicer de sua preferência dentro da imagem Docker. Isso torna o contêiner autossuficiente.

Para fazer isso, você precisará modificar o Dockerfile. Aqui está um exemplo conceitual de como você pode adicionar PrusaSlicer, OrcaSlicer ou a compilação FULU OrcaSlicer-bambulab (os comandos específicos podem variar dependendo do slicer, suas dependências e os pacotes Alpine atuais):

# ... other Dockerfile commands ...

# Example: Install PrusaSlicer, OrcaSlicer, or FULU OrcaSlicer-bambulab (adjust command as needed)
# Check Alpine package repositories first (e.g., apk add prusaslicer or apk add orcaslicer)
# If not available, download and install manually (e.g., AppImage):
# RUN apk add --no-cache fuse # FUSE might be needed for AppImages
# RUN wget https://example.com/path/to/OrcaSlicer_Linux_Vxxxx.AppImage -O /usr/local/bin/orcaslicer && \
#     chmod +x /usr/local/bin/orcaslicer

# Set the SLICER_PATH env var accordingly in docker-compose.yml or when running
# Example for installed executable:
ENV SLICER_PATH=/usr/local/bin/orcaslicer 

# ... rest of Dockerfile ...

Após modificar o Dockerfile, recompile sua imagem (docker-compose build). Você também precisará garantir que a variável de ambiente SLICER_PATH no seu arquivo .env ou docker-compose.yml aponte para o caminho correto dentro do contêiner (por exemplo, /usr/local/bin/orcaslicer). Para o fork FULU habilitado para Bambu, defina SLICER_TYPE=orcaslicer-bambulab.

Peço desculpas por não incluir um slicer específico pronto para uso, mas dada a grande variedade de slicers (PrusaSlicer, OrcaSlicer, Cura, etc.) e configurações disponíveis, pré-instalar um aumentaria desnecessariamente o tamanho da imagem para muitos usuários. Se um slicer específico se tornar um pedido muito comum, certamente poderei considerar adicionar suporte oficial a ele em uma versão futura.

Configuração

Crie um arquivo .env no diretório onde você executará o servidor ou defina variáveis de ambiente:

# Required for authentication with your printer management system
API_KEY=your_api_key_here

# Default printer connection settings
PRINTER_HOST=localhost
PRINTER_PORT=80 # Port for non-Bambu HTTP APIs
PRINTER_TYPE=octoprint  # Options: octoprint, klipper, duet, repetier, bambu, prusa, creality

# Optional: Directory for temporary files
TEMP_DIR=/path/to/temp/dir

# Bambu Labs specific configuration
BAMBU_SERIAL=your_printer_serial # REQUIRED for Bambu
BAMBU_TOKEN=your_access_token    # REQUIRED for Bambu
BAMBU_MODEL=p1s                  # REQUIRED for Bambu: p1s, p1p, x1c, x1e, a1, a1mini, h2d
BED_TYPE=textured_plate          # Bed plate: textured_plate, cool_plate, engineering_plate, hot_plate
NOZZLE_DIAMETER=0.4              # Nozzle diameter in mm (default: 0.4)

# Slicer configuration (for slice_stl tool)
# For Bambu projects, the default is orcaslicer-bambulab unless SLICER_TYPE is set.
SLICER_TYPE=orcaslicer-bambulab  # Options: prusaslicer, cura, slic3r, orcaslicer, orcaslicer-bambulab, bambustudio
SLICER_PATH=/path/to/slicer/executable
SLICER_PROFILE=/path/to/slicer/profile

# Optional aliases for FULU OrcaSlicer-bambulab when SLICER_PATH is not set
FULU_ORCA_PATH=/path/to/FULU/OrcaSlicer
ORCASLICER_BAMBULAB_PATH=/path/to/FULU/OrcaSlicer
FULU_ORCA_PLUGIN_DIR=/path/to/FULU/OrcaSlicer.app/Contents/MacOS
ORCASLICER_BAMBULAB_PLUGIN_DIR=/path/to/FULU/OrcaSlicer.app/Contents/MacOS

# Optional FULU BambuNetwork bridge runtime
# macOS default runtime dir:
# /Users/you/Library/Application Support/OrcaSlicer/macos-bridge/runtime
PJARCZAK_MAC_RUNTIME_DIR=
FULU_BAMBU_BRIDGE_COMMAND=

# Optional: Path to Bambu Studio user config dir (for loading presets)
# Example macOS: /Users/your_user/Library/Application Support/BambuStudio/user/YOUR_USER_ID
# Example Windows: C:\Users\your_user\AppData\Roaming\BambuStudio\user\YOUR_USER_ID
# Example Linux: /home/your_user/.config/BambuStudio/user/YOUR_USER_ID
BAMBU_STUDIO_CONFIG_PATH=

# MCP transport configuration
MCP_TRANSPORT=stdio             # Options: stdio, streamable-http
MCP_HTTP_HOST=127.0.0.1
MCP_HTTP_PORT=3000
MCP_HTTP_PATH=/mcp
MCP_HTTP_STATEFUL=true
MCP_HTTP_JSON_RESPONSE=true
MCP_HTTP_ALLOWED_ORIGINS=http://localhost

# Optional bridge command for blender_mcp_edit_model execute=true mode
BLENDER_MCP_BRIDGE_COMMAND=

# Accept per-call executable selectors instead of reading commands and paths
# from server environment configuration. Off by default: slicer_path,
# bridge_command, and active-probe path overrides can select which local
# executable launches. MCP_ALLOW_BRIDGE_COMMAND_ARG remains a legacy alias for
# bridge commands and bridge-derived probe paths only.
MCP_ALLOW_EXECUTABLE_ARG=false

Uso

Adicione este servidor à configuração do seu cliente MCP (Claude Desktop, Claude Code, Cursor, Codex ou qualquer cliente compatível com MCP). A maioria dos clientes baseados em JSON usa uma entrada mcpServers com o comando e as variáveis de ambiente:

{
  "mcpServers": {
    "3dprint": {
      "command": "npx",
      "args": ["-y", "mcp-3d-printer-server"],
      "env": {
        "PRINTER_HOST": "your_printer_ip",
        "PRINTER_TYPE": "bambu",
        "BAMBU_SERIAL": "your_printer_serial",
        "BAMBU_TOKEN": "your_access_token",
        "BAMBU_MODEL": "p1s",
        "SLICER_TYPE": "orcaslicer-bambulab",
        "SLICER_PATH": "/path/to/FULU/OrcaSlicer",
        "FULU_ORCA_PLUGIN_DIR": "/Applications/OrcaSlicer.app/Contents/MacOS"
      }
    }
  }
}

Para impressoras que não são Bambu, substitua as variáveis de ambiente específicas da Bambu por API_KEY e o PRINTER_TYPE apropriado (consulte Sistemas de Gerenciamento de Impressoras Suportados).

FULU OrcaSlicer-bambulab

Use FULU-Foundation/OrcaSlicer-bambulab como o slicer de projeto Bambu de primeira classe definindo:

PRINTER_TYPE=bambu
SLICER_TYPE=orcaslicer-bambulab
SLICER_PATH=/path/to/FULU/OrcaSlicer
FULU_ORCA_PLUGIN_DIR=/path/to/FULU/runtime/payload
BAMBU_MODEL=p1s

Os aliases aceitos incluem fulu_orca, fulu-orca, orca-studio e orca_bambulab. Para impressoras Bambu, esta é a família de slicer padrão quando SLICER_TYPE não está definido.

O que a integração faz:

• slice_stl usa a forma de CLI de projeto FULU/Orca (--slice 0 --export-3mf) para produzir um 3MF fatiado compatível com Bambu.
• print_3mf pode fatiar automaticamente um 3MF não fatiado por meio do FULU OrcaSlicer-bambulab e, em seguida, enviar e iniciar o projeto fatiado pelo caminho de impressão Bambu deste servidor.
• check_fulu_orca_setup verifica o executável FULU, o payload de runtime da plataforma, os comandos de configuração e o handshake opcional da ponte BambuNetwork.
• fulu_bambu_network_rpc pode chamar o protocolo de ponte FULU para diagnósticos e desenvolvimento. Métodos somente leitura são permitidos por padrão; métodos de mutação exigem allow_mutating_method=true; métodos de impressão FULU ainda exigem bambu_model.

O que permanece deliberadamente explícito:

• O caminho de impressão Bambu existente deste servidor MCP é MQTT local mais FTPS e ainda precisa de BAMBU_SERIAL, BAMBU_TOKEN e PRINTER_HOST.
• A ponte BambuNetwork da FULU é um runtime separado. O MCP pode inspecioná-la, sondá-la e emitir chamadas RPC de ponte protegidas, mas não alternará silenciosamente uma impressão do controle local por LAN para o controle em nuvem/BambuNetwork.
• BAMBU_MODEL permanece obrigatório para operações de impressão Bambu porque predefinições de máquina incorretas podem produzir G-code perigoso.

Status Atual do Teste de Bancada

Esta integração foi testada contra os artefatos de lançamento atuais do FULU para macOS e um teste de fumaça local com Benchy. O bug do lado do MCP encontrado durante esse teste foi real: os slicers de projetos da família Bambu devem usar o JSON de preset Orca/Bambu com --load-settings, não o sinalizador inválido --load-machine. Isso está corrigido aqui.

O fallback antigo do Bambu Studio ainda funciona. Defina:

SLICER_TYPE=bambustudio
SLICER_PATH=/Applications/BambuStudio.app/Contents/MacOS/BambuStudio

Com esse fallback, o mesmo Benchy 3MF foi fatiado com sucesso através da CLI do Bambu Studio em um 3MF de projeto compatível com Bambu. Este é o caminho conhecido como bom enquanto o empacotamento da plataforma FULU se estabiliza.

O macOS ainda não está comprovado como verde. Neste Mac, os pacotes de lançamento do FULU para macOS arm64 e x86_64 encontraram o mesmo problema de fatiamento via CLI durante o teste com Benchy: um caminho travou com SIGSEGV dentro do processamento da CLI do OrcaSlicer, e tentativas repetidas deixaram processos UE do macOS ininterruptíveis que ignoraram SIGKILL. O MCP agora evita fingir que isso está resolvido. check_fulu_orca_setup pode inspecionar o pacote e a carga útil da ponte, mas usuários de macOS devem tratar o fatiamento via CLI do FULU como território de feedback ativo até que o FULU envie uma combinação estável de CLI/tempo de execução para macOS.

Precisamos de testadores no Windows. O caminho de configuração do WSL 2, as verificações de carga útil e a forma do comando da ponte estão representados neste MCP, mas o caminho completo do Windows ainda precisa de relatórios reais de pessoas que possam validar install_runtime.ps1, verify_runtime.ps1, sondagem da ponte, fatiamento via CLI e um fluxo de impressão conhecido como seguro em suas próprias máquinas.

Continuaremos iterando com o feedback de usuários e contribuidores. Por favor, relate o SO, a arquitetura da CPU, o nome do artefato de lançamento do FULU, o resultado de check_fulu_orca_setup, o stderr do comando do slicer e se o fallback do Bambu Studio funciona no mesmo modelo.

Configuração do Tempo de Execução FULU por Plataforma

O README do FULU atualmente diz que o macOS está em andamento, mas a árvore de origem já inclui scripts de tempo de execução Lima para macOS e scripts de tempo de execução WSL para Windows. Este MCP conhece esses layouts de arquivo e retorna os comandos exatos através de check_fulu_orca_setup.

Windows:

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

Reinicie o Windows e execute os scripts do pacote FULU a partir do diretório que contém install_runtime.ps1:

powershell.exe -NoProfile -ExecutionPolicy Bypass -File .\install_runtime.ps1 -PackageDir . -PluginDir .
powershell.exe -NoProfile -ExecutionPolicy Bypass -File .\verify_runtime.ps1 -PackageDir . -PluginDir .

Linux:

Instale a compilação FULU OrcaSlicer-bambulab normalmente, defina SLICER_TYPE=orcaslicer-bambulab e aponte SLICER_PATH para o executável. Se você quiser diagnósticos no nível da ponte, defina FULU_BAMBU_BRIDGE_COMMAND para o pjarczak_bambu_linux_host empacotado.

macOS:

Defina o diretório de carga útil do aplicativo e execute os scripts que o FULU copia para o pacote do aplicativo:

export FULU_ORCA_PLUGIN_DIR="/Applications/OrcaSlicer.app/Contents/MacOS"
bash "$FULU_ORCA_PLUGIN_DIR/install_runtime_macos.sh" -PackageDir "$FULU_ORCA_PLUGIN_DIR" -PluginDir "$FULU_ORCA_PLUGIN_DIR"
bash "$FULU_ORCA_PLUGIN_DIR/verify_runtime_macos.sh" -PackageDir "$FULU_ORCA_PLUGIN_DIR" -PluginDir "$FULU_ORCA_PLUGIN_DIR"

O tempo de execução instalado por padrão é:

~/Library/Application Support/OrcaSlicer/macos-bridge/runtime

A forma do comando da ponte é:

"/Applications/OrcaSlicer.app/Contents/MacOS/pjarczak-bambu-linux-host-wrapper" "$HOME/Library/Application Support/OrcaSlicer/macos-bridge/runtime/pjarczak_bambu_linux_host"

Se o seu aplicativo for nomeado Orca Studio.app ou estiver em outro lugar, passe seu caminho real de Contents/MacOS como plugin_dir ou FULU_ORCA_PLUGIN_DIR.

Verifique a Configuração Através do MCP

Peça ao seu cliente MCP para chamar check_fulu_orca_setup, ou chame-o de um agente com argumentos como:

{
  "platform": "darwin",
  "slicer_path": "/Applications/OrcaSlicer.app/Contents/MacOS/OrcaSlicer",
  "plugin_dir": "/Applications/OrcaSlicer.app/Contents/MacOS",
  "run_bridge_probe": true,
  "bridge_command": "\"/Applications/OrcaSlicer.app/Contents/MacOS/pjarczak-bambu-linux-host-wrapper\" \"$HOME/Library/Application Support/OrcaSlicer/macos-bridge/runtime/pjarczak_bambu_linux_host\""
}

O resultado relata arquivos de carga útil ausentes, comandos de instalação/verificação, os valores de env do MCP a serem usados e informações de handshake/capacidade/tempo de execução da ponte quando a sondagem está habilitada.

Seletores de executável por chamada exigem MCP_ALLOW_EXECUTABLE_ARG=1. Por padrão, o comando da ponte e seus caminhos derivados são lidos da configuração de ambiente do servidor. Passar bridge_command, ou passar slicer_path, plugin_dir ou runtime_dir com run_bridge_probe=true, retorna um erro nomeando o sinalizador de adesão. A inspeção de configuração sem execução ainda pode usar os argumentos de caminho sem o sinalizador. Esses valores selecionam qual executável local este servidor inicia, então aceitá-los para uma sondagem permite que o que está direcionando o modelo — a descrição de um modelo baixado, um README em um arquivo, metadados 3MF — escolha esse programa. A mesma restrição se aplica a slicer_path nas ferramentas de fatiamento. Defina o sinalizador apenas para diagnósticos iterativos confiáveis; deixe-o desligado para uso normal.

RPC da Ponte FULU

fulu_bambu_network_rpc fala o protocolo de quadro da ponte FULU do lado do MCP. O protocolo são quadros binários little-endian com corpos JSON, usando métodos como bridge.handshake, bridge.capabilities, bridge.runtime_info e net.get_user_print_info.

Exemplo de diagnóstico seguro:

{
  "method": "bridge.runtime_info",
  "bridge_command": "\"/Applications/OrcaSlicer.app/Contents/MacOS/pjarczak-bambu-linux-host-wrapper\" \"$HOME/Library/Application Support/OrcaSlicer/macos-bridge/runtime/pjarczak_bambu_linux_host\""
}

Métodos de mutação são intencionalmente restritos:

{
  "method": "net.start_print",
  "allow_mutating_method": true,
  "bambu_model": "p1s",
  "payload": {
    "client_job_id": 1,
    "params": {
      "dev_id": "YOUR_PRINTER_ID"
    }
  }
}

Esse segundo exemplo é intencionalmente incompleto porque chamadas reais de impressão BambuNetwork precisam da carga útil completa dos parâmetros de impressão FULU/Bambu. A parte importante é que o MCP expõe a ponte sem fingir que uma impressão em nuvem pode ser inferida com segurança de um nome de arquivo local.

Onde essa configuração vive depende do seu cliente e SO:

O Codex usa TOML em vez do formato JSON acima. Você pode gerenciar servidores MCP com codex mcp, ou editar config.toml diretamente com uma entrada [mcp_servers.<name>].

Reinicie seu cliente após editar a configuração. Para o Codex, execute /mcp ou codex mcp list para confirmar que o servidor carregou.

Recomendado: use com codemode-mcp

Para qualquer servidor MCP com uma grande superfície de ferramentas, envolvê-lo atrás de codemode-mcp reduz drasticamente o uso de tokens. Em vez de expor cada definição de ferramenta ao modelo, o codemode permite que o agente escreva código contra uma interface de duas ferramentas (search() e execute()), carregando apenas as ferramentas que precisa sob demanda.

Anthropic e Cloudflare demonstraram independentemente que esse padrão reduz os custos de tokens do MCP em até 98%:

• Execução de código com MCP (Anthropic)
• Code Mode: dê aos agentes uma API inteira em 1.000 tokens (Cloudflare)

Isso se aplica a todos os servidores MCP, não apenas a este.

Sistemas de Gerenciamento de Impressoras Suportados

OctoPrint

OctoPrint é uma interface web popular para impressoras 3D. Ela fornece uma API REST para controlar a impressora.

• Porta padrão: 80 (http) ou 443 (https)
• Autenticação: chave de API necessária

Klipper (via Moonraker)

Klipper é um firmware para impressoras 3D que funciona com o servidor de API Moonraker.

• Porta padrão: 7125
• Autenticação: depende da sua configuração do Moonraker

Duet

Duet é uma placa de controle para impressoras 3D com sua própria interface web (DuetWebControl).

• Porta padrão: 80 (http) ou 443 (https)
• Autenticação: depende da sua configuração do Duet

Repetier

Repetier-Server é um software host para impressoras 3D.

• Porta padrão: 3344
• Autenticação: chave de API necessária

Bambu Labs

As impressoras Bambu Lab usam MQTT para status e controle e FTP para operações de arquivo.

• Autenticação: número de série e token de acesso necessários (defina BAMBU_SERIAL e BAMBU_TOKEN)
• Modelo da impressora: Obrigatório (defina BAMBU_MODEL). Valores válidos: p1s, p1p, x1c, x1e, a1, a1mini, h2d. Isso garante que o slicer gere o G-code correto para sua impressora específica.
• Requisitos: a impressora deve estar na mesma rede com o Modo Desenvolvedor e o Modo Somente LAN habilitados
• Compatível com: X1C, X1E, P1S, P1P, A1, A1 Mini, H2D

Encontrando o Número de Série e o Token de Acesso da Sua Impressora Bambu

Para conectar à sua impressora Bambu Lab, você precisa de duas coisas:

1. Número de Série da Impressora:

   • Procure na parte traseira ou inferior da sua impressora um adesivo com um número de série (normalmente começa com "01P" ou "01A" seguido de números/letras)
   • Alternativamente, abra o Bambu Studio, conecte-se à sua impressora, vá para Dispositivo > Gerenciamento de Dispositivos e veja as informações da sua impressora

2. Token de Acesso:

   • O token de acesso é um código de segurança necessário para conectar diretamente à sua impressora
   • Para impressoras da série P1: vá para a tela de toque, selecione Configurações > Rede > Modo LAN, e você verá o código de acesso
   • Para impressoras da série X1: vá para a tela de toque, selecione Configurações > Rede > Modo LAN, e habilite o Modo LAN para ver o código de acesso
   • Para A1 Mini: use o aplicativo Bambu Handy para conectar à sua impressora e depois vá para Configurações > Rede > Modo LAN

Nota: Se sua impressora não estiver na mesma rede local ou você não conseguir encontrar o token de acesso, pode ser necessário atualizar o firmware da sua impressora para a versão mais recente para habilitar o Modo LAN.

Notas de Comunicação Bambu (MQTT e FTP)

• MQTT: Este servidor usa o protocolo MQTT local (porta 8883, TLS) com base em descobertas da comunidade (por exemplo, OpenBambuAPI) para enviar comandos como iniciar impressões e cancelar trabalhos.
• FTP: A listagem e o upload de arquivos atualmente dependem do servidor FTP que roda na impressora (via auxiliar da biblioteca bambu-js). Nota: Esta conexão FTP pode ser não segura (FTP simples) com base nas limitações atuais da biblioteca. Use com consciência da segurança da sua rede.

Prusa Connect

Prusa Connect é a solução baseada em nuvem da Prusa para gerenciar suas impressoras.

• Porta padrão: 80 (http) ou 443 (https)
• Autenticação: chave de API necessária
• Compatível com: Prusa MK4, Prusa Mini, Prusa XL e outras impressoras Prusa com Prusa Connect

Para a nuvem Prusa Connect, use connect.prusa3d.com com PRINTER_PORT=443, ou inclua o esquema diretamente com PRINTER_HOST=https://connect.prusa3d.com. O servidor normaliza ambas as formas para HTTPS. Hosts locais PrusaLink continuam usando HTTP, a menos que você forneça um host https:// ou porta 443.

Configurando o Prusa Connect

1. Certifique-se de que sua impressora Prusa esteja atualizada com o firmware mais recente
2. Conecte sua impressora à sua rede Wi-Fi
3. Crie uma conta Prusa Connect e registre sua impressora
4. Gere uma chave de API na interface web do Prusa Connect em Configurações > Acesso à API

Creality Cloud

Creality Cloud é o sistema de gerenciamento da Creality para suas impressoras.

• Porta padrão: 80 (http) ou 443 (https)
• Autenticação: token Bearer necessário
• Compatível com: série Ender, série CR e outras impressoras Creality com capacidades de rede

Configurando o Creality Cloud

1. Instale o aplicativo Creality Cloud no seu dispositivo móvel
2. Crie uma conta e adicione sua impressora
3. Habilite o acesso à rede local para sua impressora
4. Gere um token no aplicativo Creality Cloud em Configurações > Opções de Desenvolvedor

Ferramentas Disponíveis

{
  "stl_path": "/path/to/file.stl"
}

{
  "stl_path": "/path/to/file.stl",
  "extension_inches": 2
}

{
  "stl_path": "/path/to/file.stl",
  "scale_factor": 1.5
}

{
  "stl_path": "/path/to/file.stl",
  "scale_x": 1.2,
  "scale_y": 1.0,
  "scale_z": 1.5
}

{
  "stl_path": "/path/to/file.stl",
  "rotate_x": 45,
  "rotate_y": 0,
  "rotate_z": 90
}

{
  "stl_path": "/path/to/file.stl",
  "translate_x": 10,
  "translate_y": 5,
  "translate_z": 0
}

{
  "stl_path": "/path/to/model.stl",
  "tolerance": 0.01 // Optional, default = 0.01mm
}

{
  "stl_path": "/path/to/model.stl"
}

{
  "stl_path": "/path/to/model.stl"
}

{
  "stl_path": "/path/to/file.stl",
  "section": "top",
  "transformation_type": "scale",
  "value_x": 1.5,
  "value_y": 1.5, 
  "value_z": 1.5
}

{
  "stl_path": "/path/to/file.stl",
  "section": "custom",
  "transformation_type": "rotate",
  "value_x": 0,
  "value_y": 0, 
  "value_z": 45,
  "custom_min_x": -10,
  "custom_min_y": 0,
  "custom_min_z": -10,
  "custom_max_x": 10,
  "custom_max_y": 20,
  "custom_max_z": 10
}

{
  "stl_path": "/path/to/file.stl",
  "width": 400,
  "height": 400
}

{
  "stl_path": "/path/to/file.stl",
  "slicer_type": "orcaslicer",
  "slicer_path": "/path/to/orcaslicer",
  "slicer_profile": "/path/to/machine.json;/path/to/process.json",
  "filament_profile": "/path/to/flat-nylon-filament.json"
}

{
  "gcode_path": "/path/to/file.gcode",
  "extruder_temp": 200,
  "bed_temp": 60
}

{
  "stl_path": "/path/to/file.stl",
  "extension_inches": 2,
  "extruder_temp": 200,
  "bed_temp": 60,
  "host": "192.168.1.100",
  "type": "octoprint",
  "api_key": "YOUR_API_KEY"
}

{
  "host": "192.168.1.100",
  "type": "octoprint",
  "api_key": "YOUR_API_KEY"
}

{
  "host": "192.168.1.100",
  "type": "octoprint",
  "api_key": "YOUR_API_KEY"
}

{
  "host": "192.168.1.100",
  "type": "octoprint",
  "api_key": "YOUR_API_KEY",
  "filename": "my_print.gcode",
  "gcode": "G28\nG1 X100 Y100 Z10 F3000\n...",
  "print": true
}

{
  "host": "192.168.1.100",
  "type": "klipper",
  "api_key": "YOUR_API_KEY",
  "gcode_path": "/path/to/my_print.gcode",
  "print": true
}

{
  "host": "192.168.1.100",
  "type": "octoprint",
  "api_key": "YOUR_API_KEY",
  "filename": "my_print.gcode"
}

{
  "host": "192.168.1.100",
  "type": "octoprint",
  "api_key": "YOUR_API_KEY"
}

{
  "host": "192.168.1.100",
  "type": "octoprint",
  "api_key": "YOUR_API_KEY",
  "component": "extruder",
  "temperature": 200
}

{
  "platform": "darwin",
  "slicer_path": "/Applications/OrcaSlicer.app/Contents/MacOS/OrcaSlicer",
  "plugin_dir": "/Applications/OrcaSlicer.app/Contents/MacOS",
  "run_bridge_probe": true,
  "bridge_command": "\"/Applications/OrcaSlicer.app/Contents/MacOS/pjarczak-bambu-linux-host-wrapper\" \"$HOME/Library/Application Support/OrcaSlicer/macos-bridge/runtime/pjarczak_bambu_linux_host\""
}

{
  "method": "bridge.handshake",
  "bridge_command": "\"/Applications/OrcaSlicer.app/Contents/MacOS/pjarczak-bambu-linux-host-wrapper\" \"$HOME/Library/Application Support/OrcaSlicer/macos-bridge/runtime/pjarczak_bambu_linux_host\""
}

{
  "three_mf_path": "/path/to/your_model.3mf",
  "bambu_model": "p1s",
  "bed_type": "textured_plate",
  "host": "your_bambu_ip",
  "bambu_serial": "YOUR_SERIAL",
  "bambu_token": "YOUR_TOKEN",
  "slicer_type": "orcaslicer-bambulab",
  "slicer_path": "/path/to/FULU/OrcaSlicer",
  "use_ams": true,
  "ams_mapping": [0, 1, 2, 3],
  "bed_leveling": true,
  "flow_calibration": false,
  "vibration_calibration": false,
  "timelapse": false
}

Recursos Disponíveis

Exemplos de Comandos para o Claude

Aqui estão alguns exemplos de comandos que você pode dar ao Claude após conectar o servidor MCP:

Controle da Impressora

• "Qual é o status atual da minha impressora 3D?"
• "Mostre-me a lista de arquivos na minha impressora."
• "Envie este G-code para minha impressora: [conteúdo do G-code]"
• "Comece a imprimir o arquivo chamado 'benchy.gcode'."
• "Cancele o trabalho de impressão atual."
• "Defina a temperatura do extrusor para 200°C."
• "Defina a temperatura da mesa para 60°C."

Manipulação e Impressão de STL

• "Pegue este arquivo STL e estenda a base em 2 polegadas, depois envie para o slicer e coloque na fila da minha impressora."
• "Estenda a base do model.stl em 1,5 polegadas."
• "Escalone este arquivo STL em 150% uniformemente."
• "Escalone o model.stl para ter o dobro da largura, mas mantenha a mesma altura."
• "Rotacione este modelo 90 graus em torno do eixo Z."
• "Mova este modelo STL para cima em 5mm para criar um espaço embaixo."
• "Você pode modificar apenas a parte superior deste modelo para torná-la 20% maior?"
• "Analise este arquivo STL e me diga suas dimensões e detalhes."
• "Gere uma visualização deste arquivo STL para que eu possa ver como ele é."
• "Crie visualizações SVG do meu modelo a partir de diferentes ângulos."
• "Torne a base deste modelo mais larga sem alterar sua altura."
• "Fatia o arquivo STL modificado usando o PrusaSlicer."
• "Confirme se as temperaturas no G-code são 200°C para o extrusor e 60°C para a mesa."
• "Processe este arquivo STL, torne a base 2 polegadas mais longa, fatie-o e comece a imprimir, mas confirme as temperaturas primeiro."
• "Imprima ~/Downloads/my_model.3mf na impressora Bambu."
• "Envie ~/Desktop/calibration_cube.3mf para a impressora Bambu usando os slots 0 e 2 do AMS e desligue o nivelamento da mesa."
• "Cancele o trabalho de impressão na minha Bambu P1S."
• "Quais são as configurações na minha predefinição de filamento Bambu 'Generic PETG'?"
• "Mostre-me minhas predefinições de processo Bambu."

Limitações da Impressora Bambu Lab

Devido à natureza da API da impressora Bambu Lab, existem algumas limitações:

1. Requisito de 3MF imprimível: print_3mf precisa, em última análise, de um 3MF fatiado que inclua pelo menos uma entrada Metadata/plate_<n>.gcode para que o servidor possa calcular o MD5 e iniciar o trabalho corretamente. Arquivos 3MF não fatiados podem ser fatiados automaticamente primeiro quando SLICER_TYPE=orcaslicer-bambulab ou SLICER_TYPE=bambustudio estiver configurado.

2. Ressalva do comportamento do AMS: O mapeamento do AMS é passado através do comando de arquivo de projeto MQTT, mas o comportamento real ainda depende do firmware da impressora, do filamento carregado e dos metadados do projeto fatiado.

3. Caminho de controle de temperatura: As atualizações de temperatura são implementadas através do despacho de comandos G-code (M104/M140) via MQTT, então o comportamento efetivo ainda depende da aceitação do firmware da impressora e do estado atual da impressora.

4. Canal de transferência de arquivos: Os uploads usam o caminho FTPS da Bambu (porta 990) diretamente através de basic-ftp com TLS implícito. Algumas operações de leitura/lista ainda usam auxiliares bambu-js.

5. Escopo do caminho de início direto: startJob atualmente tem como alvo arquivos .gcode no armazenamento da impressora; trabalhos .3mf devem ser iniciados através de print_3mf para que os metadados e a seleção de placa sejam tratados.

6. Consistência de status: As leituras de status forçam uma atualização pushall quando possível, mas a semântica completa de status em tempo real e fluxo de eventos em todos os modelos Bambu ainda precisa de maior robustez.

7. Escopo da ponte FULU BambuNetwork: A ponte FULU expõe a funcionalidade BambuNetwork através de seu próprio runtime e protocolo RPC. Este MCP pode inspecionar/testar esse runtime e emitir chamadas RPC de ponte protegidas, mas o print_3mf local ainda usa o caminho MQTT/FTPS local explícito do servidor, a menos que uma mudança futura mapeie um payload completo de impressão em nuvem FULU com segurança.

Limitações e Considerações

Uso de Memória

• Arquivos STL Grandes: Processar arquivos STL grandes ou complexos pode consumir memória significativa. Toda a geometria do STL é carregada na memória durante as operações.
• Múltiplas Operações: Executar várias operações de STL em sequência (especialmente em arquivos grandes) pode fazer a memória se acumular se a coleta de lixo não acompanhar.
• Ambiente MCP: Como isso roda como um servidor MCP, esteja ciente de que o ambiente MCP do Claude tem restrições de memória. Operações complexas em arquivos STL muito grandes podem causar problemas de falta de memória.

Limitações da Manipulação de STL

• Modificação de Seção: O recurso de modificação específica de seção funciona melhor em geometrias mais simples. Malhas complexas ou não-manifold podem produzir resultados inesperados.
• Extensão da Base: O algoritmo de extensão da base funciona adicionando uma nova geometria sob o modelo. Para modelos com partes inferiores complexas, os resultados podem não ser perfeitos.
• Tratamento de Erros: Embora tenhamos adicionado tratamento robusto de erros, alguns casos extremos em arquivos STL complexos ainda podem causar problemas.

Limitações da Visualização

• Representação SVG: A visualização SVG é uma representação esquemática simplificada, não uma renderização 3D real.
• Modelos Complexos: Para modelos muito complexos, a visualização pode não representar com precisão todos os detalhes.

Considerações de Desempenho

• Operações de Fatiamento: Processos de slicer externos podem ser intensivos em CPU e podem levar um tempo considerável para modelos complexos.
• Relatório de Progresso: Para arquivos grandes, as atualizações de progresso podem parecer paradas em certos estágios de processamento.

Recomendações de Teste

• Comece com arquivos STL menores (< 10MB) para testar a funcionalidade
• Monitore o uso de memória ao processar arquivos grandes
• Teste modificações em geometrias simples antes de tentar as complexas
• Considere executar em um sistema com pelo menos 4GB de RAM disponível para operações maiores

Apêndice: Notas de Segurança do MCP

Veja Recomendado: use com codemode-mcp para reduzir a sobrecarga de tokens com superfícies de ferramentas grandes.

Injeção de Prompt: Riscos e Mitigações

A injeção de prompt é um problema em aberto para agentes que usam ferramentas. Mitigações práticas:

• Credenciais de privilégio mínimo e tokens de curta duração.
• Validação rigorosa de esquema e listas de permissões explícitas para ações/hosts.
• Portões de confirmação humana para operações destrutivas.
• Sandboxing de execução com limites de recursos/tempo.
• Trate a saída da ferramenta como entrada não confiável por padrão.

Badges

Badge	Descrição
	A versão atual do pacote no npm
	Este projeto é licenciado sob GPL-2.0
	Este projeto é escrito em TypeScript 4.9+
	Este projeto é mantido ativamente
	Aceitamos contribuições via Pull Requests
	Requer Node.js 18.0.0 ou superior
	Número de downloads por mês do npm
	Número de estrelas no GitHub que este projeto recebeu

Licença

GPL-2.0