Log in to the MM-AR metamodeling platform. This MUST be called first before using any other MM-AR tools. Returns a confirmation that the session is active.

Check if there is an active MM-AR session (i.e., if the user is currently logged in).

Log out from the MM-AR platform by clearing the stored session token.

List all available modeling languages (SceneTypes) in MM-AR. Each SceneType defines a modeling language with its classes, relations, and rules. Returns an array of SceneType objects with their UUIDs and names.

Get the full details of a specific modeling language (SceneType) by its UUID. Returns the complete SceneType including all its classes, relationclasses, attributes, ports, and roles.

Get all classes (node/shape types) defined in a specific modeling language (SceneType). Classes represent the elements that can be placed on a diagram.

Get all relation types (edge/connection types) defined in a specific modeling language (SceneType). Relationclasses define how elements can be connected to each other, including their roles (source/destination rules).

Get the full details of a specific class (node type) by its UUID. Returns the class with its attributes, ports, and geometry (VizRep).

Get the full details of a specific relation type (edge type) by its UUID. Returns the relationclass with its role_from, role_to, attributes, and connection rules.

List all available attribute types in MM-AR (e.g., String, Float, Integer, Boolean, Enumeration, Table). These are the primitive data types that attributes can use. You MUST know these UUIDs before creating attributes on classes or relationclasses.

Get full details of a specific attribute type by UUID. Returns the type definition including its regex validation pattern, name, and description.

Get the full details of a specific meta-attribute by UUID. Returns the attribute definition including its type, default value, sequence, and UI component.

Get the full details of a specific role by UUID. Returns the role definition including its class_references (which classes it can connect to), port_references, and cardinality (min/max).

Get the full details of a specific port by UUID. Ports are connection points on classes.

Create a complete modeling language (SceneType) in MM-AR in a SINGLE atomic transaction. This is the primary way to create metamodels.

IMPORTANT RULES:

1. Pre-generate ALL UUIDs (v4) for every object in the payload (SceneType, Classes, Attributes, RelationClasses, Roles).

2. Call mmar_list_attribute_types FIRST to get AttributeType UUIDs (e.g., String, Float).

3. Classes are created BEFORE RelationClasses — role class_references must point to class UUIDs in the same payload.

4. Duplicate UUID → 409 CONFLICT.

5. The entire operation is atomic — all or nothing.

The scene_type_data JSON must follow this structure: { "uuid": "", "name": "My Language", "description": "...", "classes": [{ uuid, name, geometry, attributes: [{ uuid, name, attribute_type: { uuid, name }, default_value, sequence }], ports: [] }], "relationclasses": [{ uuid, name, geometry, role_from: { uuid, name, class_references: [{ uuid, min, max }] }, role_to: { uuid, name, class_references: [{ uuid, min, max }] }, attributes: [], ports: [] }], "attributes": [], "ports": [], "procedures": [] }

Update an existing modeling language (SceneType). Uses smart diff-based updates by default — new children are added, existing ones are updated.

Set hardpatch=true for FULL REPLACEMENT mode: children not in the payload will be DELETED. Use with caution.

Send the complete desired state of the SceneType (same structure as mmar_create_scene_type).

Delete a modeling language (SceneType) and ALL its contents (classes, relationclasses, attributes, etc.) permanently. This cannot be undone.

Create a new class (node/shape type) and add it to an existing SceneType. Use this for incremental metamodel building instead of recreating the whole SceneType.

The class_data JSON should include: uuid, name, geometry (VizRep function or null), is_reusable, is_abstract, attributes (array), and ports (array).

Update an existing class (node type). Send the complete desired state — the server will diff and apply changes to attributes, ports, and other properties.

Delete a class (node type) from a metamodel permanently. This also removes its attributes, ports, and any role references to it.

Create a new relationclass (edge/connection type) and add it to an existing SceneType.

IMPORTANT: The classes referenced in role_from.class_references and role_to.class_references MUST already exist in the SceneType.

The relationclass_data JSON should include: uuid, name, geometry, role_from (with uuid, name, class_references[{uuid, min, max}]), role_to (same structure), bendpoint, attributes, ports.

Update an existing relationclass (edge type). Send the complete desired state — the server will diff and apply changes to roles, attributes, and other properties.

Delete a relationclass (edge type) from a metamodel permanently. This also removes its roles, attributes, and ports.

Add a new attribute to an existing class. The attribute_data must include uuid, name, attribute_type (with uuid and name of an existing AttributeType), default_value, sequence, and ui_component.

Add a new attribute to an existing SceneType (scene-level attribute, not on a class). Same structure as class attributes.

Update an existing meta-attribute. Send the updated attribute data including name, default_value, sequence, ui_component, and attribute_type.

Update an existing role on a relationclass. Use this to change cardinality (min/max) or which classes a role can connect to (class_references). Send the complete desired state of the role.

Create a new port (connection point) on a class. Ports define where connections can attach to an element.

Update an existing port. Send the complete desired state of the port.

List all model instances (diagrams) for a specific modeling language (SceneType). Returns an array of SceneInstance objects with their UUIDs, names, and content.

Get the full details of a specific model instance (diagram) by its UUID. Returns the complete SceneInstance including all class instances, relationclass instances, attribute instances, role instances, and port instances.

Create a new model instance (diagram) for a specific SceneType. The scene_instance_data should be a JSON object with at minimum: uuid (generate a new UUID v4), name, and optionally class_instances, relationclasses_instances, role_instances, attribute_instances, and port_instances arrays.

Update an existing model instance (diagram). Uses smart diffing — new elements are added, existing ones updated.

IMPORTANT: This is the RECOMMENDED way to add connections (relationclass instances). Include uuid_scene_type in the payload. New relationclasses_instances entries will be created.

The payload must include at minimum: uuid, name, uuid_scene_type. Add relationclasses_instances array with connection objects including role_instance_from/to.

Delete a specific model instance (diagram) and all its contents by UUID.

Get all class instances (elements/nodes) within a specific scene instance (diagram).

Get the full details of a specific class instance (element/node) by its UUID. Returns the class instance with its attribute instances, port instances, and position.

Create a new class instance (element/node) within a scene instance.

IMPORTANT: The API does NOT auto-create attribute instances. You MUST include them in the payload. For each attribute on the meta-Class, create an attribute_instance with:

• uuid: new UUIDv4

• name: same as meta-attribute name

• value: the desired value (or the meta-attribute's default_value)

• uuid_attribute: the meta-attribute's UUID

Example payload: { "uuid": "", "uuid_class": "", "name": "My Element", "coordinates_2d": {"x": 0, "y": 0, "z": 0}, "attribute_instance": [ { "uuid": "", "name": "Name", "value": "My Element", "uuid_attribute": "" } ] }

Update an existing class instance. Send the complete desired state including position, attribute instances, etc.

Delete a specific class instance (element/node) from a diagram by its UUID.

Get all relationclass instances (connections/edges) within a specific scene instance (diagram).

Get the full details of a specific relationclass instance (connection/edge) by its UUID.

Create a new relationclass instance (connection/edge) within a scene instance.

Include:

• uuid, uuid_class, uuid_relationclass (all set to the meta-Relationclass UUID)

• role_instance_from: { uuid, uuid_role, uuid_has_reference_class_instance }

• role_instance_to: { uuid, uuid_role, uuid_has_reference_class_instance }

• attribute_instance: [...] (for each attribute on the meta-Relationclass)

line_points are AUTO-POPULATED from source/target coordinates — you do NOT need to provide them.

Update an existing relationclass instance (connection/edge). Send the complete desired state.

Delete a specific relationclass instance (connection/edge) from a diagram by its UUID.

Get the full details of a specific attribute instance by its UUID. Returns the attribute value, type reference, and which element it belongs to.

Get all attribute instances for a specific class instance (element).

Get all attribute instances for a specific relationclass instance (connection).

Update the value of an attribute instance. Use this to change data values on elements (e.g., setting a name, description, or any custom attribute).

Delete a specific attribute instance by its UUID.

Get the full details of a specific role instance by its UUID. Returns the role instance with its class instance reference and cardinality.

Get the source (from) role instance of a specific relationclass instance.

Get the destination (to) role instance of a specific relationclass instance.

Update an existing role instance. Use this to change which class instance a connection endpoint references.

Get the full details of a specific port instance by its UUID.

Get all port instances within a specific scene instance.

Create a new port instance within a scene instance.

Update an existing port instance. Send the complete desired state.

Delete a specific port instance by its UUID.

Get all bendpoint instances for a specific relationclass instance (connection). Bendpoints define intermediate waypoints on a connection line.

Create a new bendpoint on a relationclass instance (connection). Bendpoints add waypoints to the connection line for routing.

Update an existing bendpoint. Use this to change the waypoint position.

Delete a specific bendpoint from a connection by its UUID.