MCP 3D Printer Server

Agradecimientos a FULU y Louis Rossmann

Gracias a la Fundación FULU y a Louis Rossmann por defender la propiedad del consumidor, los desarrolladores de código abierto, los derechos de reparación y los usuarios que no deberían tener hardware funcional empeorado por software bloqueado. Este servidor MCP trata el fork FULU OrcaSlicer-bambulab como un objetivo de primera clase para el laminador de proyectos Bambu.

MCP 3D Printer Server

Descripción

Este es un servidor que permite a los usuarios de MCP conectarse con los endpoints de API de estas impresoras 3D:

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

Este servidor es un servidor de Protocolo de Contexto de Modelo (MCP) para conectar Claude con sistemas de gestión de impresoras 3D. Permite que MCP interactúe con impresoras 3D a través de las API de varios sistemas de gestión de impresoras como OctoPrint, Klipper (a través de Moonraker), Duet, Repetier e impresoras Bambu Labs.

Nota sobre el uso de recursos: Este servidor MCP incluye funciones avanzadas de manipulación de modelos 3D que pueden consumir mucha memoria al trabajar con archivos STL grandes. Consulte la sección "Limitaciones y consideraciones" para obtener información importante sobre el uso de memoria y el rendimiento.

Características

• Obtener el estado de la impresora (temperaturas, progreso de impresión, etc.)
• Listar archivos en la impresora
• Subir archivos G-code a la impresora
• Iniciar, cancelar y monitorear trabajos de impresión
• Establecer temperaturas de la impresora
• Manipulación avanzada de archivos STL:
  • Extender la base para una mejor adhesión
  • Escalar modelos de manera uniforme o a lo largo de ejes específicos
  • Rotar modelos alrededor de cualquier eje
  • Trasladar (mover) modelos
  • Modificar secciones específicas de archivos STL (superior, inferior, centro o personalizado)
• Análisis completo de STL con información detallada del modelo
• Generar visualizaciones SVG de múltiples ángulos de archivos STL
• Informe de progreso en tiempo real para operaciones largas
• Manejo de errores con diagnósticos detallados
• Laminar archivos STL para generar G-code
• Confirmar configuraciones de temperatura en archivos G-code
• Flujo de trabajo completo de extremo a extremo desde la modificación de STL hasta la impresión
• Imprimir archivos .3mf directamente en impresoras Bambu Lab (mediante comando MQTT)
• Laminar proyectos Bambu con FULU OrcaSlicer-bambulab (SLICER_TYPE=orcaslicer-bambulab) y laminar automáticamente archivos 3MF sin laminar antes de la impresión Bambu cuando se configura un laminador de proyecto
• Inspeccionar y sondear el runtime FULU BambuNetwork (check_fulu_orca_setup) y llamar a métodos RPC de puente FULU seguros por defecto para diagnósticos y desarrollo (fulu_bambu_network_rpc)
• Leer archivos de ajustes preestablecidos de Bambu Studio (impresora, filamento, proceso) como recursos

Instalación

Requisitos previos

• Node.js 18 o superior
• npm o yarn

Instalar desde npm

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

Instalar desde el código fuente

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

Ejecutar con Docker

También puede ejecutar el servidor usando Docker y Docker Compose para un entorno contenerizado.

1. Asegúrese de tener Docker y Docker Compose instalados.
2. Copie .env.example a .env y configure sus ajustes.
3. Construya y ejecute el contenedor:

   docker-compose up --build -d
   

Uso de laminadores con Docker

Tenga en cuenta que la configuración predeterminada de Docker no puede usar directamente un laminador instalado en su máquina host. Montar el ejecutable del laminador directamente desde el host al contenedor no es confiable debido a las diferencias de sistema operativo y bibliotecas entre su host y el contenedor.

El enfoque recomendado es instalar su laminador preferido dentro de la imagen Docker. Esto hace que el contenedor sea autosuficiente.

Para hacer esto, necesitará modificar el Dockerfile. Aquí hay un ejemplo conceptual de cómo podría agregar PrusaSlicer, OrcaSlicer o la compilación FULU OrcaSlicer-bambulab (los comandos específicos pueden variar según el laminador, sus dependencias y los paquetes Alpine actuales):

# ... 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 ...

Después de modificar el Dockerfile, reconstruya su imagen (docker-compose build). También deberá asegurarse de que la variable de entorno SLICER_PATH en su archivo .env o docker-compose.yml apunte a la ruta correcta dentro del contenedor (por ejemplo, /usr/local/bin/orcaslicer). Para el fork FULU habilitado para Bambu, establezca SLICER_TYPE=orcaslicer-bambulab.

Disculpas por no incluir un laminador específico de fábrica, pero dada la gran variedad de laminadores (PrusaSlicer, OrcaSlicer, Cura, etc.) y configuraciones disponibles, preinstalar uno inflaría innecesariamente la imagen para muchos usuarios. Si un laminador en particular se convierte en una solicitud muy común, ciertamente puedo considerar agregar soporte oficial en una versión futura.

Configuración

Cree un archivo .env en el directorio donde ejecutará el servidor o establezca variables de entorno:

# 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

Agregue este servidor a la configuración de su cliente MCP (Claude Desktop, Claude Code, Cursor, Codex o cualquier cliente compatible con MCP). La mayoría de los clientes basados en JSON usan una entrada mcpServers con el comando y las variables de entorno:

{
  "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 impresoras que no son Bambu, reemplace las variables de entorno específicas de Bambu con API_KEY y el PRINTER_TYPE apropiado (consulte Sistemas de gestión de impresoras compatibles).

FULU OrcaSlicer-bambulab

Use FULU-Foundation/OrcaSlicer-bambulab como laminador de proyectos Bambu de primera clase estableciendo:

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

Los alias aceptados incluyen fulu_orca, fulu-orca, orca-studio y orca_bambulab. Para impresoras Bambu, esta es la familia de laminadores predeterminada cuando SLICER_TYPE no está configurado.

Lo que hace la integración:

• slice_stl usa la forma CLI del proyecto FULU/Orca (--slice 0 --export-3mf) para producir un 3MF laminado compatible con Bambu.
• print_3mf puede laminar automáticamente un 3MF sin laminar a través de FULU OrcaSlicer-bambulab, luego subir e iniciar el proyecto laminado a través de la ruta de impresión Bambu de este servidor.
• check_fulu_orca_setup verifica el ejecutable FULU, la carga útil del runtime de la plataforma, los comandos de configuración y el handshake opcional del puente BambuNetwork.
• fulu_bambu_network_rpc puede llamar al protocolo de puente FULU para diagnósticos y desarrollo. Los métodos de solo lectura están permitidos por defecto; los métodos de mutación requieren allow_mutating_method=true; los métodos de impresión FULU aún requieren bambu_model.

Lo que permanece deliberadamente explícito:

• La ruta de impresión Bambu existente de este servidor MCP es MQTT local más FTPS y aún necesita BAMBU_SERIAL, BAMBU_TOKEN y PRINTER_HOST.
• El puente BambuNetwork de FULU es un runtime separado. El MCP puede inspeccionarlo, sondearlo y emitir llamadas RPC de puente protegidas, pero no cambiará silenciosamente una impresión del control LAN local al control en la nube/BambuNetwork.
• BAMBU_MODEL sigue siendo obligatorio para las operaciones de impresión Bambu porque los ajustes preestablecidos de máquina incorrectos pueden producir G-code peligroso.

Estado actual de la prueba de banco

Esta integración ha sido probada contra los artefactos de lanzamiento actuales de FULU para macOS y una prueba de humo local con Benchy. El error del lado de MCP encontrado durante esa prueba fue real: los slicers de proyectos de la familia Bambu deben usar el JSON de preset de Orca/Bambu con --load-settings, no la bandera inválida --load-machine. Eso está corregido aquí.

La alternativa antigua de Bambu Studio todavía funciona. Establezca:

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

Con esa alternativa, el mismo Benchy 3MF se laminó exitosamente a través de la CLI de Bambu Studio en un 3MF de proyecto compatible con Bambu. Este es el camino conocido y funcional mientras se estabiliza el empaquetado de la plataforma FULU.

macOS aún no está confirmado como estable. En este Mac, los paquetes de lanzamiento arm64 y x86_64 de FULU para macOS encontraron el mismo problema de laminado por CLI durante las pruebas con Benchy: una ruta falló con SIGSEGV dentro del procesamiento de la CLI de OrcaSlicer, y los intentos repetidos dejaron procesos de macOS UE ininterrumpibles que ignoraron SIGKILL. El MCP ahora evita fingir que eso está resuelto. check_fulu_orca_setup puede inspeccionar el paquete y la carga útil del puente, pero los usuarios de macOS deben tratar el laminado por CLI de FULU como territorio de retroalimentación activa hasta que FULU envíe una combinación estable de CLI/entorno de ejecución para macOS.

Necesitamos evaluadores en Windows. La ruta de configuración de WSL 2, las verificaciones de carga útil y la forma del comando del puente están representadas en este MCP, pero la ruta completa de Windows aún necesita informes reales de personas que puedan validar install_runtime.ps1, verify_runtime.ps1, el sondeo del puente, el laminado por CLI y un flujo de impresión conocido y seguro en su propia máquina.

Seguiremos iterando con los comentarios de usuarios y colaboradores. Por favor, informe el sistema operativo, la arquitectura de la CPU, el nombre del artefacto de lanzamiento de FULU, el resultado de check_fulu_orca_setup, el stderr del comando del slicer y si la alternativa de Bambu Studio funciona en el mismo modelo.

Configuración del entorno de ejecución de FULU por plataforma

El README de FULU actualmente dice que macOS está en progreso, pero el árbol de fuentes ya incluye scripts de entorno de ejecución de Lima para macOS y scripts de entorno de ejecución de WSL para Windows. Este MCP conoce esos diseños de archivos y devuelve los comandos exactos a travé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 Windows y luego ejecute los scripts del paquete FULU desde el directorio que contiene 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 la compilación de FULU OrcaSlicer-bambulab normalmente, establezca SLICER_TYPE=orcaslicer-bambulab y apunte SLICER_PATH al ejecutable. Si desea diagnósticos a nivel de puente, establezca FULU_BAMBU_BRIDGE_COMMAND al pjarczak_bambu_linux_host empaquetado.

macOS:

Establezca el directorio de carga útil de la aplicación y luego ejecute los scripts que FULU copia en el paquete de la aplicación:

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"

El entorno de ejecución instalado por defecto es:

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

La forma del comando del puente es:

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

Si su aplicación se llama Orca Studio.app o vive en otro lugar, pase su ruta real de Contents/MacOS como plugin_dir o FULU_ORCA_PLUGIN_DIR.

Verifique la configuración a través de MCP

Pida a su cliente MCP que llame a check_fulu_orca_setup, o llámelo desde un agente con 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\""
}

El resultado informa archivos de carga útil faltantes, comandos de instalación/verificación, los valores de entorno de MCP a usar e información de protocolo de enlace/capacidad/entorno de ejecución del puente cuando el sondeo está habilitado.

Los selectores de ejecutable por llamada requieren MCP_ALLOW_EXECUTABLE_ARG=1. Por defecto, el comando del puente y sus rutas derivadas se leen de la configuración del entorno del servidor. Pasar bridge_command, o pasar slicer_path, plugin_dir o runtime_dir con run_bridge_probe=true, devuelve un error que nombra la bandera de aceptación. La inspección de configuración que no ejecuta aún puede usar los argumentos de ruta sin la bandera. Estos valores seleccionan qué ejecutable local lanza este servidor, por lo que aceptarlos para un sondeo permite que lo que esté dirigiendo el modelo (una descripción de un modelo descargado, un README en un archivo, metadatos 3MF) elija ese programa. La misma restricción se aplica a slicer_path en herramientas de laminado. Establezca la bandera solo para diagnósticos iterativos de confianza; déjela desactivada para uso normal.

RPC del puente FULU

fulu_bambu_network_rpc habla el protocolo de tramas del puente FULU desde el lado de MCP. El protocolo son tramas binarias little-endian con cuerpos JSON, usando métodos como bridge.handshake, bridge.capabilities, bridge.runtime_info y net.get_user_print_info.

Ejemplo 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\""
}

Los métodos de mutación están restringidos intencionalmente:

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

Ese segundo ejemplo está intencionalmente incompleto porque las llamadas reales de impresión de BambuNetwork necesitan la carga útil completa de parámetros de impresión de FULU/Bambu. La parte importante es que el MCP expone el puente sin fingir que una impresión en la nube puede inferirse de manera segura a partir de un nombre de archivo local.

Dónde vive esta configuración depende de su cliente y sistema operativo:

Codex usa TOML en lugar de la forma JSON anterior. Puede gestionar servidores MCP con codex mcp, o editar config.toml directamente con una entrada [mcp_servers.<name>].

Reinicie su cliente después de editar la configuración. Para Codex, ejecute /mcp o codex mcp list para confirmar que el servidor se cargó.

Recomendado: usar con codemode-mcp

Para cualquier servidor MCP con una gran superficie de herramientas, envolverlo detrás de codemode-mcp reduce drásticamente el uso de tokens. En lugar de exponer cada definición de herramienta al modelo, codemode permite que el agente escriba código contra una interfaz de dos herramientas (search() y execute()), cargando solo las herramientas que necesita bajo demanda.

Anthropic y Cloudflare demostraron de forma independiente que este patrón reduce los costos de tokens de MCP hasta en un 98%:

• Ejecución de código con MCP (Anthropic)
• Code Mode: dale a los agentes una API completa en 1,000 tokens (Cloudflare)

Esto se aplica a todos los servidores MCP, no solo a este.

Sistemas de gestión de impresoras compatibles

OctoPrint

OctoPrint es una interfaz web popular para impresoras 3D. Proporciona una API REST para controlar la impresora.

• Puerto predeterminado: 80 (http) o 443 (https)
• Autenticación: Se requiere clave de API

Klipper (a través de Moonraker)

Klipper es un firmware para impresoras 3D que funciona con el servidor de API Moonraker.

• Puerto predeterminado: 7125
• Autenticación: Depende de su configuración de Moonraker

Duet

Duet es una placa de control para impresoras 3D con su propia interfaz web (DuetWebControl).

• Puerto predeterminado: 80 (http) o 443 (https)
• Autenticación: Depende de su configuración de Duet

Repetier

Repetier-Server es un software host para impresoras 3D.

• Puerto predeterminado: 3344
• Autenticación: Se requiere clave de API

Bambu Labs

Las impresoras Bambu Lab usan MQTT para el estado y control y FTP para operaciones de archivos.

• Autenticación: Se requieren número de serie y token de acceso (establezca BAMBU_SERIAL y BAMBU_TOKEN)
• Modelo de impresora: Requerido (establezca BAMBU_MODEL). Valores válidos: p1s, p1p, x1c, x1e, a1, a1mini, h2d. Esto asegura que el laminador genere el G-code correcto para su impresora específica.
• Requisitos: La impresora debe estar en la misma red con el Modo Desarrollador y el Modo Solo LAN habilitados
• Compatible con: X1C, X1E, P1S, P1P, A1, A1 Mini, H2D

Cómo encontrar el número de serie y el token de acceso de su impresora Bambu

Para conectarse a su impresora Bambu Lab, necesita dos cosas:

1. Número de serie de la impresora:

   • Mire en la parte posterior o inferior de su impresora una etiqueta con un número de serie (generalmente comienza con "01P" o "01A" seguido de números/letras)
   • Alternativamente, abra Bambu Studio, conéctese a su impresora, vaya a Dispositivo > Gestión de dispositivos y vea la información de su impresora

2. Token de acceso:

   • El token de acceso es un código de seguridad necesario para conectarse directamente a su impresora
   • Para impresoras de la serie P1: Vaya a la pantalla táctil, seleccione Configuración > Red > Modo LAN, y verá el código de acceso
   • Para impresoras de la serie X1: Vaya a la pantalla táctil, seleccione Configuración > Red > Modo LAN, y habilite el Modo LAN para ver el código de acceso
   • Para A1 Mini: Use la aplicación Bambu Handy para conectarse a su impresora, luego vaya a Configuración > Red > Modo LAN

Nota: Si su impresora no está en la misma red local o no puede encontrar el token de acceso, es posible que necesite actualizar el firmware de su impresora a la última versión para habilitar el Modo LAN.

Notas de comunicación de Bambu (MQTT y FTP)

• MQTT: Este servidor usa el protocolo MQTT local (puerto 8883, TLS) basado en hallazgos de la comunidad (por ejemplo, OpenBambuAPI) para enviar comandos como iniciar impresiones y cancelar trabajos.
• FTP: El listado y la carga de archivos actualmente dependen del servidor FTP que se ejecuta en la impresora (a través del asistente de biblioteca bambu-js). Nota: Esta conexión FTP podría ser no segura (FTP plano) según las limitaciones actuales de la biblioteca. Úsela con conciencia de la seguridad de su red.

Prusa Connect

Prusa Connect es la solución basada en la nube de Prusa para gestionar sus impresoras.

• Puerto predeterminado: 80 (http) o 443 (https)
• Autenticación: Se requiere clave de API
• Compatible con: Prusa MK4, Prusa Mini, Prusa XL y otras impresoras Prusa con Prusa Connect

Para Prusa Connect en la nube, use connect.prusa3d.com con PRINTER_PORT=443, o incluya el esquema directamente con PRINTER_HOST=https://connect.prusa3d.com. El servidor normaliza ambas formas a HTTPS. Los hosts locales de PrusaLink continúan usando HTTP a menos que proporcione un host https:// o puerto 443.

Configuración de Prusa Connect

1. Asegúrese de que su impresora Prusa esté actualizada al firmware más reciente
2. Conecte su impresora a su red Wi-Fi
3. Cree una cuenta de Prusa Connect y registre su impresora
4. Genere una clave de API desde la interfaz web de Prusa Connect en Configuración > Acceso a API

Creality Cloud

Creality Cloud es el sistema de gestión de Creality para sus impresoras.

• Puerto predeterminado: 80 (http) o 443 (https)
• Autenticación: Se requiere token Bearer
• Compatible con: Serie Ender, serie CR y otras impresoras Creality con capacidades de red

Configuración de Creality Cloud

1. Instale la aplicación Creality Cloud en su dispositivo móvil
2. Cree una cuenta y agregue su impresora
3. Habilite el acceso a la red local para su impresora
4. Genere un token desde la aplicación Creality Cloud en Configuración > Opciones de desarrollador

Herramientas disponibles

{
  "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 Disponibles

Ejemplos de Comandos para Claude

Aquí hay algunos comandos de ejemplo que puede dar a Claude después de conectar el servidor MCP:

Control de Impresora

• "¿Cuál es el estado actual de mi impresora 3D?"
• "Muéstrame la lista de archivos en mi impresora."
• "Sube este código G a mi impresora: [contenido del código G]"
• "Inicia la impresión del archivo llamado 'benchy.gcode'."
• "Cancela el trabajo de impresión actual."
• "Establece la temperatura del extrusor a 200°C."
• "Establece la temperatura de la cama a 60°C."

Manipulación e Impresión de STL

• "Toma este archivo STL y extiende la base 2 pulgadas, luego envíalo al slicer y ponlo en cola en mi impresora."
• "Extiende la base de model.stl 1.5 pulgadas."
• "Escala este archivo STL al 150% uniformemente."
• "Escala model.stl para que sea el doble de ancho pero mantén la misma altura."
• "Rota este modelo 90 grados alrededor del eje Z."
• "Mueve este modelo STL hacia arriba 5mm para crear un espacio debajo."
• "¿Puedes modificar solo la parte superior de este modelo para hacerla un 20% más grande?"
• "Analiza este archivo STL y dime sus dimensiones y detalles."
• "Genera una visualización de este archivo STL para que pueda ver cómo se ve."
• "Crea visualizaciones SVG de mi modelo desde diferentes ángulos."
• "Haz la base de este modelo más ancha sin cambiar su altura."
• "Corta el archivo STL modificado usando PrusaSlicer."
• "Confirma que las temperaturas en el código G son 200°C para el extrusor y 60°C para la cama."
• "Procesa este archivo STL, haz la base 2 pulgadas más larga, córtalo e inicia la impresión, pero confirma las temperaturas primero."
• "Imprime ~/Downloads/my_model.3mf en la impresora Bambu."
• "Sube ~/Desktop/calibration_cube.3mf a la impresora Bambu usando las ranuras AMS 0 y 2, y desactiva el nivelado de la cama."
• "Cancela el trabajo de impresión en mi Bambu P1S."
• "¿Cuáles son los ajustes en mi ajuste preestablecido de filamento Bambu 'Generic PETG'?"
• "Muéstrame mis ajustes preestablecidos de proceso Bambu."

Limitaciones de la Impresora Bambu Lab

Debido a la naturaleza de la API de la impresora Bambu Lab, hay algunas limitaciones:

1. Requisito de 3MF imprimible: print_3mf en última instancia necesita un 3MF cortado que incluya al menos una entrada Metadata/plate_<n>.gcode para que el servidor pueda calcular el MD5 e iniciar el trabajo correctamente. Los archivos 3MF sin cortar se pueden cortar automáticamente primero cuando SLICER_TYPE=orcaslicer-bambulab o SLICER_TYPE=bambustudio está configurado.

2. Advertencia de comportamiento de AMS: El mapeo de AMS se pasa a través del comando de archivo de proyecto MQTT, pero el comportamiento real aún depende del firmware de la impresora, el filamento cargado y los metadatos del proyecto cortado.

3. Ruta de control de temperatura: Las actualizaciones de temperatura se implementan a través del envío de comandos de código G (M104/M140) a través de MQTT, por lo que el comportamiento efectivo aún depende de la aceptación del firmware de la impresora y del estado actual de la impresora.

4. Canal de transferencia de archivos: Las subidas usan la ruta FTPS de Bambu (puerto 990) directamente a través de basic-ftp con TLS implícito. Algunas operaciones de lectura/listado aún usan los ayudantes de bambu-js.

5. Alcance de la ruta de inicio directo: startJob actualmente apunta a archivos .gcode en el almacenamiento de la impresora; los trabajos de .3mf deben iniciarse a través de print_3mf para que los metadatos y la selección de placa se manejen.

6. Consistencia del estado: Las lecturas de estado fuerzan una actualización de pushall cuando es posible, pero la semántica completa de estado de eventos en tiempo real en todos los modelos Bambu aún necesita un endurecimiento más profundo.

7. Alcance del puente FULU BambuNetwork: El puente FULU expone la funcionalidad de BambuNetwork a través de su propio tiempo de ejecución y protocolo RPC. Este MCP puede inspeccionar/sondear ese tiempo de ejecución y emitir llamadas RPC de puente protegidas, pero el print_3mf local aún usa la ruta MQTT/FTPS local explícita del servidor a menos que un cambio futuro mapee una carga útil completa de impresión en la nube FULU de manera segura.

Limitaciones y Consideraciones

Uso de Memoria

• Archivos STL Grandes: Procesar archivos STL grandes o complejos puede consumir memoria significativa. Toda la geometría STL se carga en memoria durante las operaciones.
• Múltiples Operaciones: Ejecutar múltiples operaciones STL en secuencia (especialmente en archivos grandes) puede causar que la memoria se acumule si la recolección de basura no se mantiene al día.
• Entorno MCP: Dado que esto se ejecuta como un servidor MCP, tenga en cuenta que el entorno MCP de Claude tiene restricciones de memoria. Las operaciones complejas en archivos STL muy grandes pueden causar problemas de falta de memoria.

Limitaciones de Manipulación de STL

• Modificación de Secciones: La función de modificación específica de secciones funciona mejor en geometrías más simples. Las mallas complejas o no múltiples pueden producir resultados inesperados.
• Extensión de Base: El algoritmo de extensión de base funciona agregando una nueva geometría debajo del modelo. Para modelos con partes inferiores complejas, los resultados pueden no ser perfectos.
• Manejo de Errores: Aunque hemos agregado un manejo robusto de errores, algunos casos extremos en archivos STL complejos aún pueden causar problemas.

Limitaciones de Visualización

• Representación SVG: La visualización SVG es una representación esquemática simplificada, no un renderizado 3D real.
• Modelos Complejos: Para modelos muy complejos, la visualización puede no representar con precisión todos los detalles.

Consideraciones de Rendimiento

• Operaciones de Corte: Los procesos de slicer externos pueden ser intensivos en CPU y pueden tomar tiempo considerable para modelos complejos.
• Informe de Progreso: Para archivos grandes, las actualizaciones de progreso pueden parecer que se detienen en ciertas etapas de procesamiento.

Recomendaciones de Pruebas

• Comience con archivos STL más pequeños (< 10MB) para probar la funcionalidad
• Monitoree el uso de memoria al procesar archivos grandes
• Pruebe modificaciones en geometrías simples antes de intentar complejas
• Considere ejecutar en un sistema con al menos 4GB de RAM disponible para operaciones más grandes

Apéndice: Notas de Seguridad de MCP

Consulte Recomendado: use con codemode-mcp para reducir la sobrecarga de tokens con superficies de herramientas grandes.

Inyección de Prompts: Riesgos y Mitigaciones

La inyección de prompts es un problema abierto para agentes que usan herramientas. Mitigaciones prácticas:

• Credenciales de privilegio mínimo y tokens de corta duración.
• Validación estricta de esquemas y listas de permitidos explícitas para acciones/hosts.
• Puertas de confirmación humana para operaciones destructivas.
• Aislamiento de ejecución con límites de recursos/tiempo.
• Trate la salida de las herramientas como entrada no confiable por defecto.

Insignias

Insignia	Descripción
	La versión actual del paquete en npm
	Este proyecto está licenciado bajo GPL-2.0
	Este proyecto está escrito en TypeScript 4.9+
	Este proyecto se mantiene activamente
	Agradecemos contribuciones mediante Pull Requests
	Requiere Node.js 18.0.0 o superior
	Número de descargas por mes desde npm
	Número de estrellas de GitHub que ha recibido este proyecto

Licencia

GPL-2.0