coppeliasim-mcp
This MCP server lets an LLM drive a running CoppeliaSim 4.10 scene through safe, non-Lua tools: build and modify scenes, run the simulation, and read object and sensor state.
Simulation control: start, stop, pause, query state, get elapsed time, and step the simulation a precise number of steps.
Scene and model management: load/save/close
.tttscenes within a restricted directory, list and load.ttmmodels from the local CoppeliaSim library.Object inspection and editing: list objects, get/set positions and orientations, create primitive shapes, delete objects, and reparent objects.
Physics and appearance: mark objects as detectable, configure dynamic/respondable/friction/mass properties (using the correct Bullet friction setting), and change colors.
Joints and rigid links: create rotary/linear joints with motor modes, set joint targets/velocities, read joint positions/forces, and create rigid attachments via force sensors.
Proximity sensors: create cone sensors, read the last detection result, and perform on-demand detection checks without running the simulation.
Safety by design: no arbitrary Lua execution, read-only mode via
COPPELIA_MODO_LECTURA=1, and restricted file paths to reduce injection and filesystem risk.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@coppeliasim-mcp Create a cube and a proximity sensor, then run the simulation."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
coppeliasim-mcp
An MCP server that lets Claude Code (or any MCP client) drive a running CoppeliaSim 4.10 simulation: build scenes, move objects, create joints and proximity sensors, run the simulation and read sensors back.
It deliberately does not expose arbitrary Lua execution. That is the main difference from other CoppeliaSim MCP servers. See Security.
Tool names are Spanish by default, with optional English and Portuguese aliases — see Tool name languages.
Not affiliated with, endorsed by, or maintained by Coppelia Robotics AG. CoppeliaSim is a trademark of Coppelia Robotics AG. This is an independent third-party integration; for the simulator itself, go to coppeliarobotics.com.
Requirements
CoppeliaSim 4.10 running, with the ZMQ remote API add-on active. It ships enabled by default and listens on port 23000.
Python 3.10 or newer.
Related MCP server: Robonine MCP Server
Install
# Recommended: no clone, no virtualenv to manage
uvx coppeliasim-mcp
# Or install it
pip install coppeliasim-mcpRegister it with Claude Code:
claude mcp add coppelia -- uvx coppeliasim-mcpOr, for any MCP client that reads a JSON config:
{
"mcpServers": {
"coppelia": {
"command": "uvx",
"args": ["coppeliasim-mcp"]
}
}
}Install as a Claude Code plugin (server + skills)
Installing the plugin brings the MCP server and a set of skills that teach how to lay a CoppeliaSim project out so it stays reproducible:
/plugin marketplace add KevinInoCol/coppeliasim-mcp
/plugin install coppeliasim@coppeliasimThe plugin's .mcp.json runs uvx coppeliasim-mcp, so the server still comes
from PyPI — the repository only adds the guidance on top.
Skill | What it covers |
Project structure | one script per artifact, the connect/clean/create/build/verify order, and what belongs in the Python API rather than in these tools |
Building a scene | walls with doorways, the three independent properties (dynamic / respondable / detectable), and verifying in code that the robot fits and every area is reachable |
Differential robot and sensors | joint axis and control mode, the friction Bullet actually obeys, collision groups, sensor blind zones and the cone that sees the floor |
Each exists in Spanish, English and Portuguese; Claude picks one from context, and only the one-line descriptions stay in context permanently.
The skills are distilled from working projects, and every figure in them was measured rather than assumed.
Configuration
All settings are optional environment variables. They can also live in a .env
file in the working directory — see .env.example.
Variable | Default | What it does |
|
| Host of the ZMQ remote API add-on. |
|
| Its port. |
| current working directory | Only scenes under this folder can be loaded or saved. |
| the local CoppeliaSim library | Only |
|
| Set to |
|
| Tool-name aliases. |
|
| Seconds to wait for a reply before giving up. |
Tools
Simulation control — iniciar_simulacion, detener_simulacion,
pausar_simulacion, estado_simulacion, tiempo_simulacion,
paso_simulacion
Scenes and models — cargar_escena, guardar_escena, cerrar_escena,
listar_modelos, cargar_modelo
Objects — listar_objetos, obtener_posicion, fijar_posicion,
obtener_orientacion, fijar_orientacion, crear_primitiva,
eliminar_objeto, emparentar_objeto, fijar_detectable
Physics and appearance — fijar_dinamica, fijar_color
Joints — crear_junta, crear_union_rigida, obtener_posicion_junta,
fijar_objetivo_junta, fijar_velocidad_junta, obtener_fuerza_junta
Proximity sensors — crear_sensor_proximidad, leer_sensor_proximidad,
comprobar_sensor_proximidad
Together these build a working robot without leaving the tool catalog: shapes,
motorized joints, a rigid link, mass and friction, a sensor, then step the
simulation and measure. The differential drive robot in examples/ was
rebuilt call by call this way and travelled 98% of its theoretical distance.
What the server tells the model
At handshake the server sends the client model a short set of instructions, on
top of the tool catalog. It is deliberately about judgment rather than
mechanics: that these tools are for inspecting and verifying a scene, that a
control loop cannot run through them, and that anything reproducible belongs in
a Python script against coppeliasim_zmqremoteapi_client — the same API these
tools use — with the tools employed to check the result.
It costs ~440 tokens per request. The mechanics stay in this README, which the model reads only if you point it there.
Tool name languages
Tools are defined in Spanish (crear_primitiva, leer_sensor_proximidad, …).
Setting COPPELIA_IDIOMAS registers aliases in English and Portuguese that
point at the same functions — no duplicated logic, just more names in the
catalog.
| Tools | Catalog size | Cost per request |
| 31 | 22.7 KB | — |
| 62 | 38.4 KB | ~4,000 tokens |
| 93 | 54.2 KB | ~8,000 tokens |
The catalog is sent to the model on every request, so aliases are off by
default. Worth knowing before you turn them on: the model does not need
translated names to understand you in another language. Tool names are
identifiers, not user-facing text — ask for "move the cube forward" or "mova o
cubo para frente" and it will reach for fijar_posicion either way. Aliases help
when you want to read the catalog at a glance, or name a tool explicitly in a
prompt.
Examples
Two complete projects, built against a real simulator and measured rather than assumed — every figure quoted in this README came from them.
examples/Proyecto-01-Carrito-Diferencial/— a differential drive robot with obstacle avoidance, and where thebullet.frictionOldtrap was found.examples/Proyecto-02-Casa/— a house that verifies by BFS that every room is reachable, a robot built from dimensioned plans, and keyboard teleop.
They are plain Python against coppeliasim_zmqremoteapi_client, not tool calls:
that is what a project looks like. See examples/README.md.
Security
CoppeliaSim's Lua environment has access to os and io. A tool that runs
arbitrary Lua therefore turns any prompt injection — for example text embedded
in a third-party .ttt scene the model is asked to inspect — into command
execution on your machine. This server has no such tool, by design.
The rest of the surface is narrow on purpose:
cargar_escenaresolves the path (Path.resolve(strict=True)) before comparing it againstCOPPELIA_DIRECTORIO_ESCENAS, so../..and symlinks cannot escape it, and it only accepts scene extensions.guardar_escenawrites only under the same folder, and refuses to overwrite an existing file unless asked explicitly.cargar_modeloloads.ttmfiles only from the library that ships with your CoppeliaSim install. A.ttmcan carry Lua child scripts inside — the officialkinect.ttmcarries two — and they run on Play, so loading a model someone sent you is running their code. The tool reports how many scripts came with the model.COPPELIA_MODO_LECTURA=1disables every mutating tool at once.The scene directory defaults to the working directory, not to your home.
Notes that save debugging time
Things about the CoppeliaSim API that are easy to get wrong, and that the tools surface directly:
leer_sensor_proximidaddoes not detect. It returns the result of the simulator's last sensor pass, so with the simulation stopped it always reports nothing. Usecomprobar_sensor_proximidadto detect on demand.An object must be marked detectable to be seen by a proximity sensor. That is what
fijar_detectableis for, and it is the usual reason a sensor "doesn't work".A wide cone pointing horizontally sees the floor before it sees your obstacle. With half-aperture a and the sensor at height h, the floor enters the cone at h / tan(a). If that is under the sensor range, the sensor reports the ground.
Re-parenting renumbers sibling paths. After hanging
/Cylinder[1]off a chassis,/Cylinder[3]may become/Cylinder[1]. List objects again between successiveemparentar_objetocalls, or resolve handles up front.Parenting does not rigidly attach two dynamic shapes. Non-static shapes fall unless constrained by a joint or a force sensor — that is what
crear_union_rigidais for.Bullet reads
bullet.frictionOld, notbullet.friction. CoppeliaSim exposes both, and which one the engine obeys depends on the Bullet version selected in the scene. With the default Bullet 2.7 it is the old one, so setting onlybullet.frictiondoes nothing at all. Measured on a differential drive robot: a caster left at old-friction 1 dragged the robot down to 87% of its straight-line distance and 51% of its turn rate, skid-steering instead of pivoting on its drive axle.fijar_dinamicawrites both.A joint moves along its own +Z, and does nothing without a control mode. For a wheel driving toward +X the axis must lie along Y, and the motor stays deaf until
dynCtrlModeis set — a property, not an argument of the creation call.crear_juntahandles both.
Releasing
Publishing runs on a tag push, through
.github/workflows/publicar.yml:
# bump version in pyproject.toml first, then
git tag v0.1.0 && git push --tagsThe workflow refuses to publish when the tag and the version in
pyproject.toml disagree, installs the built wheel on Python 3.10 and 3.13, and
runs scripts/prueba_humo.py — an MCP handshake plus a
check that a call with no simulator present answers instead of hanging — before
it uploads anything. A PyPI version can never be overwritten or reused, so
failing in CI is much cheaper than burning a version number.
It authenticates with PyPI through Trusted Publishing (OIDC), so there is no token stored in the repository secrets.
License
MIT — see LICENSE.
The MIT license covers this server only. CoppeliaSim itself is licensed separately by Coppelia Robotics AG, and this package neither includes nor redistributes any part of it — it talks to a simulator you install and license yourself.
coppeliasim-mcp (español)
Un servidor MCP para manejar una simulación de CoppeliaSim 4.10 desde Claude Code o cualquier cliente MCP: construir escenas, mover objetos, crear juntas y sensores de proximidad, correr la simulación y leer los sensores.
No expone ejecución de Lua arbitrario, a propósito. Es la diferencia
principal con los otros MCP de CoppeliaSim que circulan. El Lua de CoppeliaSim
tiene acceso a os e io, así que una tool de ese tipo convierte cualquier
prompt injection —por ejemplo, texto dentro de una escena .ttt de terceros—
en ejecución de comandos sobre tu máquina.
Sin afiliación, respaldo ni mantenimiento por parte de Coppelia Robotics AG. CoppeliaSim es una marca de Coppelia Robotics AG. Esto es una integración independiente de terceros; para el simulador, ve a coppeliarobotics.com.
Requisitos
CoppeliaSim 4.10 abierto, con el add-on ZMQ remote API activo. Viene habilitado por defecto, escuchando en el puerto 23000.
Python 3.10 o superior.
Instalación
uvx coppeliasim-mcp # recomendado
pip install coppeliasim-mcp # o instalado
claude mcp add coppelia -- uvx coppeliasim-mcp # registrar en Claude CodeConfiguración
Variables de entorno, todas opcionales. También se pueden poner en un .env
en el directorio de trabajo — mira .env.example.
Variable | Por defecto | Para qué |
|
| Host del add-on ZMQ remote API. |
|
| Su puerto. |
| directorio de trabajo | Solo se pueden cargar y guardar escenas por debajo de esta carpeta. |
| la librería local de CoppeliaSim | Solo se pueden cargar modelos |
|
| A |
|
| Alias de nombres de tools. |
|
| Segundos de espera antes de dar una respuesta por perdida. |
Idiomas de los nombres de tools
Las tools se definen en español. COPPELIA_IDIOMAS registra alias en inglés y
portugués sobre las mismas funciones: no duplica lógica, solo añade nombres.
| Tools | Catálogo | Coste por petición |
| 31 | 22.7 KB | — |
| 62 | 38.4 KB | ~4.000 tokens |
| 93 | 54.2 KB | ~8.000 tokens |
El catálogo viaja en cada petición al modelo, así que los alias vienen
apagados. Y conviene saber esto antes de encenderlos: el modelo no necesita los
nombres traducidos para entenderte en otro idioma. Los nombres de tools son
identificadores, no texto de cara al usuario — pídele "move the cube forward" o
"mova o cubo para frente" y usará fijar_posicion igual. Los alias sirven para
leer el catálogo de un vistazo, o para nombrar una tool explícitamente.
Ejemplos
Dos proyectos completos, construidos contra un simulador real y medidos en vez de supuestos: todas las cifras que se citan en este README salieron de ahí.
examples/Proyecto-01-Carrito-Diferencial/— un carrito diferencial con evasión de obstáculos, y donde apareció la trampa debullet.frictionOld.examples/Proyecto-02-Casa/— una casa que verifica por BFS que se llega a todas las habitaciones, un robot construido a partir de planos acotados, y teleoperación por teclado.
Son Python contra coppeliasim_zmqremoteapi_client, no llamadas a tools: así es
como se ve un proyecto. Mira examples/README.md.
Cosas que ahorran horas de depuración
leer_sensor_proximidadno detecta. Devuelve el resultado del último barrido del simulador, así que con la simulación detenida siempre dice que no hay nada. Para detectar en el momento,comprobar_sensor_proximidad.Un objeto tiene que estar marcado como detectable para que un sensor de proximidad lo vea. Para eso está
fijar_detectable, y es la causa habitual de un sensor que "no funciona".Un cono ancho en horizontal ve el suelo antes que el obstáculo. Con media apertura a y el sensor a altura h, el suelo entra en el cono a h / tan(a). Si eso queda por debajo del alcance, el sensor reporta el piso.
Emparentar renumera las rutas de los hermanos. Al colgar
/Cylinder[1]de un chasis,/Cylinder[3]puede pasar a ser/Cylinder[1]. Vuelve a listar los objetos entre llamadas, o resuelve los handles antes de tocar la jerarquía.Emparentar no une rígidamente dos cuerpos dinámicos. Las formas no estáticas se caen si no las sujeta una junta o un force sensor — para eso está
crear_union_rigida.Bullet lee
bullet.frictionOld, nobullet.friction. CoppeliaSim expone las dos, y cuál obedece el motor depende de la versión de Bullet elegida en la escena. Con el Bullet 2.7 por defecto manda la vieja, así que escribir solobullet.frictionno hace nada. Medido sobre un robot de tracción diferencial: con la rueda loca en fricción vieja 1, recorría el 87% de lo que le tocaba en recta y el 51% en giro, derrapando en vez de pivotar sobre su eje motriz.fijar_dinamicaescribe las dos.Una junta se mueve sobre su propio +Z, y no hace nada sin modo de control. Para una rueda que avance hacia +X el eje tiene que estar sobre Y, y el motor sigue sordo hasta que se le pone
dynCtrlMode, que es una propiedad y no un argumento de la llamada de creación.crear_juntase ocupa de las dos cosas.
Licencia
MIT — mira LICENSE.
La licencia MIT cubre solo este servidor. CoppeliaSim se licencia por separado con Coppelia Robotics AG, y este paquete no incluye ni redistribuye ninguna parte de él: habla con un simulador que instalas y licencias tú.
Available Tools
31 toolscargar_escenaA
Carga una escena .ttt o .xml desde disco.
Solo se permiten rutas por debajo del directorio configurado en COPPELIA_DIRECTORIO_ESCENAS.
Inputs: ruta (required). Returns: result
cargar_modeloA
Carga un modelo .ttm de la librería de CoppeliaSim en la escena.
modelo: ruta relativa dentro de la librería, tal como la devuelve
listar_modelos (por ejemplo 'components/sensors/kinect.ttm').
Solo carga de esa librería, y no de una ruta cualquiera, a propósito: un .ttm puede llevar child scripts en Lua dentro —el kinect.ttm oficial lleva dos— y esos scripts se ejecutan al darle Play. Cargar un modelo que llegó de fuera es, en la práctica, ejecutar el código que traiga.
Inputs: modelo (required), x, y, z. Returns: result
cerrar_escenaA
Cierra la escena actual.
Inputs: no named parameters. Returns: result
comprobar_sensor_proximidadA
Detecta ahora mismo con un sensor de proximidad, sin necesidad de simulación.
Diferencia con leer_sensor_proximidad: esa tool NO detecta, solo devuelve
el resultado del último barrido que hizo el simulador, así que con la
simulación detenida siempre dice que no hay nada. Esta hace la detección en
el momento, y sirve para verificar una escena en reposo.
Inputs: sensor (required). Returns: result
crear_juntaA
Crea una articulación motorizada y la deja lista para recibir órdenes.
tipo: 'rotativa' (gira) o 'lineal' (desliza). eje: 'x', 'y' o 'z' — en qué dirección gira o desliza, respecto al padre. modo: 'velocidad' para un motor de rueda, 'posicion' para un brazo, 'libre' para que la junta gire suelta sin motor. par_maximo: par o fuerza que el motor puede dar (N·m o N). Si se queda corto, la junta no llega a la velocidad pedida y no hay ningún error que lo diga: simplemente va lenta. padre: ruta del objeto del que cuelga, por ejemplo el chasis de un robot.
Dos cosas que cuesta descubrir a solas:
Una junta se mueve a lo largo de su propio +Z. Para una rueda que avance hacia +X, su eje tiene que quedar sobre Y: eje='y'. Esta tool aplica el giro por ti.
El motor no obedece hasta que se le pone el modo de control dinámico. Es una propiedad de la junta, no un argumento de la llamada de creación, y una junta sin ella se queda quieta pase lo que pase.
Después de crearla: cuelga la rueda de la junta con emparentar_objeto,
dale masa con fijar_dinamica, y muévela con fijar_velocidad_junta.
Inputs: x, y, z, eje, +5 more. Returns: result
crear_primitivaA
Crea una forma primitiva en la escena y devuelve su ruta.
forma: 'cubo', 'esfera', 'cilindro', 'cono', 'capsula', 'disco', 'toroide'. Tamaños y posición en metros. alias: nombre con el que quedará en la escena. Sin él CoppeliaSim las llama 'Cuboid', 'Cuboid[0]', 'Cuboid[1]'..., y como emparentar renumera a los hermanos, la ruta que te devolvió una llamada puede referirse a otra pieza tres llamadas después. Con nombres propios eso no pasa.
Inputs: forma (required), x, y, z, +4 more. Returns: result
crear_sensor_proximidadA
Crea un sensor de proximidad cónico y lo orienta hacia el frente (+X).
x, y, z: posición en metros, relativa al padre (o al mundo si padre='mundo'). alcance: hasta dónde ve, en metros. apertura_grados: apertura total del cono. Cuanto más ancho, más 've' de lado. padre: ruta del objeto del que debe colgar, por ejemplo el chasis de un robot.
Dos trampas de geometría, por si el sensor 'no detecta lo que debería':
El sensor mira a lo largo de su eje +Z. Esta tool lo rota 90° sobre Y para que mire al frente (+X), que es la convención de avance habitual.
Un cono ancho en horizontal ve el SUELO antes que el obstáculo: con media apertura a y el sensor a altura h, el suelo entra en el cono a h/tan(a) metros. Si eso queda por debajo del alcance, el sensor reportará el piso. Estrecha la apertura o sube el sensor.
Inputs: x, y, z, alias, +3 more. Returns: result
crear_union_rigidaA
Crea un sensor de fuerza, que es como se sueldan dos cuerpos dinámicos.
Suena raro usar un sensor para unir cosas, pero es lo que documenta CoppeliaSim: emparentar dos formas dinámicas NO las une —siguen siendo cuerpos separados y se caen cada uno por su lado—, y la única forma de fijarlas es una junta o un sensor de fuerza.
Y hay un caso donde el sensor de fuerza es la única opción: cuando las dos piezas necesitan rozamientos distintos. Fusionar las formas las obliga a compartir el coeficiente, así que un chasis con agarre y una rueda loca que resbale no se pueden fusionar; hay que unirlos por aquí.
Uso: se crea colgando del chasis, y la pieza a unir se cuelga de él con
emparentar_objeto. De paso mide la fuerza que pasa por la unión, que se
lee con obtener_fuerza_junta.
Inputs: x, y, z, alias, +1 more. Returns: result
detener_simulacionA
Detiene la simulación en CoppeliaSim.
Inputs: no named parameters. Returns: result
eliminar_objetoC
Elimina un objeto de la escena por su ruta.
Inputs: nombre (required). Returns: result
emparentar_objetoA
Cuelga un objeto de otro, para que se muevan como un solo cuerpo.
padre: ruta del nuevo padre, o 'mundo' para devolver el objeto a la raíz. mantener_pose: True deja el objeto donde está; False lo lleva al origen del padre.
Ojo: emparentar renumera las rutas de los hermanos ('/Cylinder[3]' puede pasar a ser '/Cylinder[1]'). Si vas a emparentar varias piezas seguidas, vuelve a listar los objetos entre una llamada y la siguiente.
Inputs: padre (required), objeto (required), mantener_pose. Returns: result
estado_simulacionB
Consulta si la simulación está detenida, corriendo o pausada.
Inputs: no named parameters. Returns: result
fijar_colorB
Pinta una forma. Componentes de 0 a 1.
Sirve para algo más que la estética: en una escena de veinte cubos grises, el color es lo que permite decir cuál es cuál en una captura.
Inputs: b (required), g (required), r (required), nombre (required). Returns: result
fijar_detectableA
Marca o desmarca un objeto como detectable por los sensores de proximidad.
Un objeto no detectable es invisible para leer_sensor_proximidad, aunque
esté justo delante del sensor. Es la causa habitual de un sensor que 'no
funciona'.
Inputs: nombre (required), detectable. Returns: result
fijar_dinamicaA
Deja una forma lista para el motor de física: masa, contacto y rozamiento.
Sin esto una forma recién creada es decorado: ni cae, ni empuja, ni la empujan. Es el paso que falta entre 'crear_primitiva' y tener un robot.
dinamico: False la clava en el sitio (suelo, paredes, obstáculos). respondable: si choca con las demás. Un cuerpo dinámico no respondable atraviesa el suelo y se cae de la escena. densidad: kg/m³ para calcular masa e inercia a partir del volumen real de la forma. 0 significa 'no tocar la masa'. Para una masa concreta, divide esa masa entre el volumen. Solo funciona en formas convexas. friccion: 0 resbala, 1 agarra. Negativo significa 'no tocar el rozamiento'. chocar_con_hermanos: False evita que las piezas de un mismo robot choquen entre ellas (ruedas contra chasis), que es de donde salen los temblores, sin dejar de chocar con el suelo y el resto del mundo.
Inputs: nombre (required), densidad, dinamico, friccion, +2 more. Returns: result
fijar_objetivo_juntaB
Fija la posición objetivo de una articulación (radianes o metros).
Inputs: junta (required), posicion (required). Returns: result
fijar_orientacionB
Fija la orientación de un objeto con ángulos de Euler en radianes.
Inputs: alfa (required), beta (required), gamma (required), nombre (required), +1 more. Returns: result
fijar_posicionB
Mueve un objeto a la posición (x, y, z), en metros.
Inputs: x (required), y (required), z (required), nombre (required), +1 more. Returns: result
fijar_velocidad_juntaC
Fija la velocidad objetivo de una articulación.
Inputs: junta (required), velocidad (required). Returns: result
guardar_escenaA
Guarda la escena actual en un .ttt.
Solo escribe por debajo de COPPELIA_DIRECTORIO_ESCENAS, y se niega a pisar un archivo que ya exista salvo que le pases sobrescribir=True. Escribir encima de la escena de otro es de las pocas cosas que aquí no tienen deshacer, así que hay que pedirlo a propósito.
Inputs: ruta (required), sobrescribir. Returns: result
iniciar_simulacionB
Inicia la simulación en CoppeliaSim.
Inputs: no named parameters. Returns: result
leer_sensor_proximidadB
Lee un sensor de proximidad: si detecta algo, a qué distancia y en qué punto.
Inputs: sensor (required). Returns: result
listar_modelosA
Lista los modelos .ttm de la librería que trae CoppeliaSim instalado.
filtro: texto que debe aparecer en la ruta, sin distinguir mayúsculas ('kinect', 'robots/mobile', 'sensor'). Sin filtro devuelve los primeros que encuentre, que son cientos: conviene filtrar.
Inputs: filtro, limite. Returns: result
listar_objetosA
Lista los objetos de la escena actual con su ruta y su handle.
tipo: 'todos', 'shape', 'joint', 'dummy', 'sensor', 'camara', 'luz', 'path'.
Inputs: tipo. Returns: result
obtener_fuerza_juntaC
Lee la fuerza o par medido en una articulación.
Inputs: junta (required). Returns: result
obtener_orientacionC
Devuelve la orientación de un objeto como ángulos de Euler en radianes.
Inputs: nombre (required), relativo_a. Returns: result
obtener_posicionA
Devuelve la posición [x, y, z] de un objeto, en metros.
relativo_a: 'mundo' o la ruta de otro objeto (por ejemplo '/Cuboid').
Inputs: nombre (required), relativo_a. Returns: result
obtener_posicion_juntaA
Lee la posición de una articulación: radianes si es rotativa, metros si es prismática.
Inputs: junta (required). Returns: result
paso_simulacionA
Avanza la simulación un número exacto de pasos y devuelve el tiempo.
Para qué sirve: con la simulación en marcha libre no se puede medir nada de forma repetible, porque entre una lectura y la siguiente pasa el tiempo que quiera el reloj. Avanzando por pasos, cada lectura cae siempre en el mismo instante simulado, y dos ejecuciones dan el mismo número.
Deja la simulación en modo por pasos: a partir de aquí solo avanza cuando se
lo pidas. detener_simulacion la devuelve a marcha libre, y conviene
llamarla al terminar: una simulación esperando un paso que nadie manda
parece congelada.
Inputs: pasos. Returns: result
pausar_simulacionB
Pausa la simulación en CoppeliaSim.
Inputs: no named parameters. Returns: result
tiempo_simulacionA
Devuelve el tiempo de simulación transcurrido, en segundos.
Inputs: no named parameters. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 31 tools
Most tools map cleanly to a distinct resource-plus-action pair, such as position, orientation, joint target, or simulation state. The only near-overlaps are leer_sensor_proximidad vs comprobar_sensor_proximidad and emparentar_objeto vs crear_union_rigida, but the descriptions explicitly separate those use cases.
The set overwhelmingly follows a Spanish verb_noun pattern using verbs like crear_, fijar_, obtener_, cargar_, and listar_. A few query tools are noun-first instead of verb-first (tiempo_simulacion, estado_simulacion, paso_simulacion), which keeps it from being perfectly uniform.
31 tools is above the 25+ threshold and creates a large selection surface for an agent, even though each tool has a clear niche. The count could be reduced by grouping pose queries, simulation queries, or proximity-sensor variants.
Core workflows are covered well: scene management, object creation and posing, physics setup, joint control, and proximity sensing. Obvious gaps remain for a robotics simulator, such as camera/vision reading, object velocity, collision queries, and script execution, so agents may hit dead ends outside the basic robot-building path.
Maintenance
Related MCP Connectors
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal E…
MCP server for OpenAI API (chat completions, image generation, embeddings) via AceDataCloud
Make games with AI: one MCP server that connects your agent to Unity, Unreal and Godot editors.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceMCP server that lets Claude drive a running TouchDesigner instance to create operators, wire them, set parameters, run arbitrary Python, and introspect the td API.1MIT

Robonine MCP Serverofficial
AlicenseAqualityDmaintenanceA local MCP server that connects Claude Code or any MCP-compatible AI assistant to a Robonine robot arm.1MIT- AlicenseAqualityCmaintenanceA self-hosted MCP server that lets Claude (or any MCP client) drive Autodesk Fusion 360 on your own machine.983MIT
- FlicenseNot gradedqualityCmaintenanceFull-access MCP server for the Webots robot simulator that enables AI assistants to see, understand, and modify a running simulation, including scene-tree inspection/editing, robot control, viewport screenshots, and arbitrary code execution.5-