ChatGPT, Claude, Gemini, Copilot, Cursor y otros asistentes de IA pueden construir un proyecto completo de Mokxi, la placa, los componentes, los cables y el código, y entregarte un enlace que lo abre en el editor y lo ejecuta. Pegar y usar enlaces es gratis y no requiere cuenta; el servidor MCP y la llamada HTTP requieren una cuenta de Mokxi, y en Gratis se construyen hasta 10 proyectos al día con ellos, mientras que Pro no tiene límite diario. No se guarda nada hasta que tú lo guardes.
Hay cuatro formas de entrar, de la más automática a la más manual:
- MCP (cualquier plan). Agrega el servidor MCP de Mokxi a tu app de IA. El asistente busca componentes y pines, parte de una plantilla que ya funciona, revisa el proyecto como lo hace el editor, corrige lo que está mal y te da un enlace.
- Pegar. Copia el prompt de Mokxi, pégalo en cualquier asistente de chat, dile qué construir y pega su respuesta en el cuadro Importar de Mokxi.
- Un enlace. Un asistente puede escribir un enlace que lleva el proyecto:
https://mokxi.com/app/#ai=seguido del proyecto como JSON codificado en URL, o uno que lleva solo un sketch:https://mokxi.com/app/#code=. - Una llamada HTTP (cualquier plan). Un script o la acción de un GPT personalizado pueden hacer
POSTdel proyecto ahttps://mokxi.com/api/ai/projecty recibir el enlace de vuelta.
Las cuatro leen el mismo formato de proyecto, abajo, y ejecutan las mismas verificaciones.
Cuando el asistente solo ha escrito código, hay un enlace más corto:
https://mokxi.com/app/#code= seguido del sketch, codificado en URL. Mokxi elige la placa y conecta los componentes que el código menciona. Consulta
Un enlace solo con código.
Conecta el servidor MCP
El servidor está en https://mokxi.com/mcp. Habla MCP sobre Streamable HTTP (del tipo sin estado: cada mensaje es un solo POST, no hay flujo de eventos). Cualquier cliente puede conectarse y listar las herramientas; llamar a una herramienta requiere iniciar sesión en una cuenta de Mokxi, en cualquier plan. Hay dos formas de iniciar sesión:
- Inicia sesión desde la app. Una app que solo acepta una URL (Claude, ChatGPT y otros) abre una página de Mokxi la primera vez que llama a una herramienta. Inicia sesión en Mokxi ahí, verifica el nombre de la app y elige Permitir. La app queda conectada hasta que la desconectes en Apps de IA conectadas de tu página de cuenta.
- An API token. Make one under API tokens on your
página de cuenta; empieza con
mkx_. Send it as anAuthorization: Bearerheader.
En Gratis, un asistente puede construir hasta 10 proyectos al día con el servidor (create_project; el contador se reinicia a medianoche UTC), y todas las demás herramientas no tienen límite diario. Pro no tiene límite diario, y tampoco ningún plan que incluya Pro: el precio de estudiante, Pro de por vida, un pase, un lugar en una clase de pago y una prueba de Pro. Sin sesión iniciada, o pasado el límite de proyectos del día en Gratis, una llamada a una herramienta responde con una línea que lo indica. El servidor solo lee el catálogo de componentes, las placas y las plantillas que trae el editor, y no guarda nada. Un cliente que necesite un servidor SSE no funcionará con él.
Claude (claude.ai y la app de escritorio)
Configuración, Conectores, Agregar conector personalizado. Dale el nombre Mokxi y la URL:
https://mokxi.com/mcp
La primera vez que Claude llama a una herramienta se abre la página de inicio de sesión de Mokxi. Inicia sesión y elige Permitir.
Claude Code
claude mcp add --transport http mokxi https://mokxi.com/mcp --header "Authorization: Bearer mkx_your_token"
ChatGPT
En Configuración, activa el modo de desarrollador en Conectores, luego agrega un conector con la URL https://mokxi.com/mcp. Elige OAuth como inicio de sesión y permítelo en la página de Mokxi que se abre, o dale tu token de API como su bearer token o clave de API.
Cursor
En .cursor/mcp.json (el del proyecto, o ~/.cursor/mcp.json para todos los proyectos):
{ "mcpServers": { "mokxi": { "url": "https://mokxi.com/mcp", "headers": { "Authorization": "Bearer mkx_your_token" } } } }
VS Code (GitHub Copilot)
En .vscode/mcp.json:
{ "servers": { "mokxi": { "type": "http", "url": "https://mokxi.com/mcp", "headers": { "Authorization": "Bearer mkx_your_token" } } } }
Gemini CLI
gemini mcp add --transport http mokxi https://mokxi.com/mcp --header "Authorization: Bearer mkx_your_token"
O en settings.json:
{ "mcpServers": { "mokxi": { "httpUrl": "https://mokxi.com/mcp", "headers": { "Authorization": "Bearer mkx_your_token" } } } }
Cualquier otro cliente MCP
Agrega un servidor remoto del tipo Streamable HTTP en https://mokxi.com/mcp. Un cliente que siga las reglas de inicio de sesión de MCP (OAuth 2.1 con PKCE y registro dinámico de clientes) encuentra todo lo que necesita en la respuesta 401 del servidor y en https://mokxi.com/.well-known/oauth-protected-resource. Cualquier otro cliente envía el encabezado Authorization: Bearer y tu token de API. El servidor habla las versiones de protocolo 2025-11-25, 2025-06-18, 2025-03-26 y 2024-11-05, y su tarjeta está en https://mokxi.com/.well-known/mcp.json.
Qué pedir
Di qué quieres construir y pide el enlace de Mokxi:
- "Hazme una luz nocturna con un Arduino Uno que encienda un LED cuando oscurezca, y dame el enlace de Mokxi."
- "Muéstrame cómo se conecta un sensor de distancia HC-SR04 a un ESP32, con código que imprima la distancia. Ábrelo en Mokxi."
- "Aquí está mi sketch. Conecta los componentes que necesita en un Nano y dame un enlace de Mokxi para verlo funcionar."
- "Haz un semáforo en MicroPython con una Raspberry Pi Pico en Mokxi."
- "Mi servo solo se mueve un poco. Pon este código y cableado en Mokxi para ver qué está haciendo el pin."
El asistente debe responder con un enlace que empiece con https://mokxi.com/app/. Ábrelo y el proyecto queda distribuido, cableado y en ejecución. Si te da el proyecto como JSON y sin enlace, pídele el enlace, o pega el JSON en Importar.
Las herramientas
| Herramienta | Qué hace |
|---|---|
get_project_format |
Las reglas del formato, los componentes y placas comunes con sus pines, y un ejemplo |
list_boards |
Cada placa que ejecuta Mokxi, su tipo, el código que acepta y sus pines |
search_parts |
Componentes por lo que son ("oled", "sensor de temperatura"), con pines y ajustes del catálogo del simulador |
get_part |
Un componente a detalle: pines, ajustes con rangos y unidades, y cómo lo cablea una plantilla de Mokxi |
get_example |
Un proyecto completo y funcionando para una placa, un componente o ambos, tomado de las plantillas de Mokxi, para que el asistente lo modifique |
validate_project |
La revisión propia del editor de un proyecto, con cada problema identificado por componente y pin |
create_project |
El enlace que abre el proyecto y lo ejecuta, una vez que no tiene errores |
create_code_link |
Un enlace que abre un sketch en una placa, para código que todavía no tiene un circuito resuelto |
Cada herramienta solo lee. El enlace lleva el proyecto completo en la parte de la dirección que va después del #, que un navegador nunca envía a un servidor, así que no se guarda nada en ningún lugar y los proyectos de tu plan no se tocan. Quien reciba el enlace lo abre sin cuenta. Una vez abierto, el proyecto es tuyo para guardarlo, cambiarlo o cerrarlo.
get_example tiene una plantilla inicial para la mayoría de las placas y componentes, no para todos. Cuando un componente no tiene plantilla en la placa pedida, te lo da en otra placa y dice qué cambiar. create_code_link acepta un sketch de hasta 24,000 caracteres.
El servidor tiene límite de peticiones por dirección, como toda ruta pública de Mokxi: 60 peticiones a la vez y luego una por segundo, y 20 revisiones de proyecto, plantillas iniciales o enlaces a la vez y luego uno cada cinco segundos.
Un enlace creado aquí indica de dónde viene: contiene utm_source=mcp y, cuando tu app de IA le da su nombre al servidor, también ese nombre. Así es como Mokxi cuenta cuántas personas llegan desde asistentes de IA. No incluye nada sobre ti ni sobre tu conversación.
Pegar desde un chat
In the editor, open Import (or go to mokxi.com/import) y abre Paste from ChatGPT or Claude. Press Copy prompt for your AI, paste it into the assistant, and add what you want to build. Paste the whole reply back into the Import box: Mokxi finds the project in it, lays it out and wires it.
Si algo del proyecto está mal, igual se abre con todo lo que estaba bien, y el informe enumera cada problema por componente y pin. Copiar para tu IA copia la lista con una petición para corregirla, lista para pegar de vuelta.
El formato del proyecto
Un proyecto es un objeto JSON:
{
"format": "mokxi-ai/1",
"name": "Button and LED",
"board": "uno",
"parts": [
{"id": "led1", "type": "led", "props": {"color": "red"}},
{"id": "r1", "type": "resistor", "props": {"value": 220}},
{"id": "btn1", "type": "pushbutton"}
],
"wires": [
["board.13", "r1.1"],
["r1.2", "led1.A"],
["led1.C", "board.GND"],
["board.2", "btn1.1a"],
["btn1.2a", "board.GND"]
],
"code": {
"sketch.ino": "void setup() {\n pinMode(13, OUTPUT);\n pinMode(2, INPUT_PULLUP);\n}\n\nvoid loop() {\n // The button pulls pin 2 to ground when pressed.\n digitalWrite(13, digitalRead(2) == LOW ? HIGH : LOW);\n}\n"
}
}
| Campo | Qué contiene |
|---|---|
format |
Siempre "mokxi-ai/1". Le dice a Mokxi qué es lo que se pega. |
name |
El nombre del proyecto, hasta 120 caracteres. |
board |
El tipo de placa, como "uno", "nano", "esp32" o "pico" (list_boards los tiene todos). null para un circuito sin placa. |
parts |
Todos los componentes excepto la placa. Cada uno tiene un id (una letra, luego letras, dígitos, _ o -), un type y props opcionales. |
wires |
Pares de extremos, ["partId.pin", "partId.pin"]. La placa es board, así que board.13 es su pin 13. Un tercer elemento puede nombrar un color: rojo, negro, verde, azul, amarillo, morado, cian o rosa. |
code |
Los archivos de la placa, por nombre: {"sketch.ino": "..."} para un sketch de Arduino, o {"main.py": "..."} para MicroPython en una Raspberry Pi Pico. |
No hay coordenadas ni protoboard. Mokxi pone la placa a la izquierda y los componentes en filas junto a ella, manteniendo juntos los que están cableados entre sí, y traza cada cable como lo hace el lienzo. Conecta cada pin directo al pin al que va.
Pins
Un pin se escribe como lo nombra el componente: A y C en un LED, 1 y
2 en una resistencia, 1a, 1b, 2a y 2b en un botón, VCC, TRIG,
ECHO y GND en un HC-SR04. get_part enumera los pines de cada componente, y lo mismo hace el archivo de cada componente en el paquete de conocimiento.
A board's pins can be written the way code names them: on an Uno, board.D13
is board.13; on an ESP32 DevKit, board.GPIO2 is board.D2; on a Pico,
board.15 is board.GP15 and board.A0 is board.GP26. Upper and lower
case do not matter where they do not change the pin.
Configuración
props son los ajustes del componente, tal como los muestra el panel de propiedades. Los números son números simples: el value de una resistencia está en ohms, el de un capacitor en microfarads y el de un inductor en milihenries. Mokxi también lee "4.7k" o "100nF" y lo convierte, con una nota. get_part da el rango, la unidad y las opciones de cada ajuste.
Más de una placa
Pon cada placa en parts, deja board fuera (la primera es board en un cable) y dale a code un conjunto de archivos por id de placa:
{
"format": "mokxi-ai/1",
"name": "Two Unos talking",
"parts": [
{"id": "a", "type": "uno"},
{"id": "b", "type": "uno"}
],
"wires": [["a.1", "b.0"], ["b.1", "a.0"], ["a.GND", "b.GND"]],
"code": {
"a": {"sketch.ino": "void setup() { Serial.begin(9600); }\nvoid loop() { Serial.println(\"hi\"); delay(1000); }\n"},
"b": {"sketch.ino": "void setup() { Serial.begin(9600); }\nvoid loop() { if (Serial.available()) Serial.write(Serial.read()); }\n"}
}
}
Qué se revisa
La revisión es la del propio editor, así que validate_project, el cuadro de Importar y un enlace dicen lo mismo.
Los errores detienen create_project hasta que se corrigen:
- un tipo de componente que Mokxi no tiene, con el más parecido que sí tiene ("¿Quisiste decir
ws2812?") - un pin que el componente no tiene, con los pines que sí tiene
- un cable a un componente que no está en el proyecto
- un ajuste que el componente no tiene, o un valor fuera de su rango
- una protoboard (déjala fuera), o una placa que Mokxi dibuja pero aún no simula
- un cable directo de un pin de alimentación de la placa a su tierra
- un nombre de archivo con una carpeta dentro, o un sketch de Arduino sin archivo
.ino
Las advertencias conviene revisarlas pero no lo detienen: un componente sin cablear, un componente con una sola pata cableada, una placa sin código, un sketch sin setup() o loop(), y un #include de una biblioteca que Mokxi no tiene.
Aquí Mokxi admite hasta 150 componentes, 400 cables y 20 archivos de código por proyecto, y los enlaces llegan a alrededor de un megabyte. Pasados unos 8,000 caracteres, algunas apps de chat cortan un enlace; pegar el JSON del proyecto en Importar siempre funciona.
Enlaces
create_project y POST /api/ai/project devuelven un enlace como https://mokxi.com/app/?utm_source=mcp#ai=1...: el proyecto comprimido. Un asistente sin herramientas puede escribir el suyo propio: https://mokxi.com/app/#ai= seguido del JSON pasado por encodeURIComponent. En cualquier caso el editor lo abre, lo acomoda, muestra lo que llegó y lo ejecuta una vez que su código compila.
Un enlace solo con código
Un sketch sin proyecto a su alrededor también se abre desde un enlace:
https://mokxi.com/app/#code=<the sketch, URL-encoded>&board=<board>
codees el sketch completo pasado porencodeURIComponent. Codifica también(,),!,'y*(%28,%29,%21,%27,%2A), para que una app de chat que vuelva el enlace clicable no lo corte antes de tiempo.boardes opcional. Es el tipo de una placa (list_boardslos tiene todos), comouno,nano,mega2560,esp32,esp32c3opico. Sin él, Mokxi adivina la placa según los include y los pines que usa el sketch.
El editor abre el sketch en esa placa y cablea los componentes que nombra el código: un servo en su pin attach, un sensor DHT en su pin de datos, un LED y una resistencia en cada salida, un botón en cada entrada. Lo que no pudo colocar aparece en una lista para que la persona lo cablee. Todo lo que va después del # se queda en el navegador: no se envía al servidor de Mokxi.
Por ejemplo, un blink en un ESP32:
https://mokxi.com/app/#code=void%20setup%28%29%20%7B%20pinMode%282%2C%20OUTPUT%29%3B%20%7D%0Avoid%20loop%28%29%20%7B%20digitalWrite%282%2C%20HIGH%29%3B%20delay%28500%29%3B%20digitalWrite%282%2C%20LOW%29%3B%20delay%28500%29%3B%20%7D&board=esp32
Usa #ai= cuando conoces el cableado y lo quieres exactamente como está escrito, y
#code= cuando lo único que hay es el código. Una persona también puede pegar el código, o una respuesta completa del chat, en el cuadro de https://mokxi.com/import/ai-code.
Por MCP, create_code_link escribe este enlace.
POST /api/ai/project takes the project as its body (or as
{"project": ...}) and answers {"ok": true, "url": "...", "summary": "...", "warnings": [...]},
or 422 with {"error": "invalid_project", "ok": false, "errors": [...]}. Like the MCP server, it works on
every plan and cannot be called without a token: send the API token of your account
as Authorization: Bearer mkx_.... Make the token under API tokens on your
página de cuenta. Sin uno responde 401 with
{"error": "token_required", ...} and a line saying how to get one. On Free it counts toward the same
10 projects a day as create_project, and past them it answers 429 with
{"error": "daily_limit", ...}; Pro has no daily limit. The sign-in an AI app does for the MCP server does not work here. It accepts calls from any origin.