Check that this MCP server process is alive. Does not contact Blender.

Check that Blender is running with the AI Bridge started.

Call this first if any other Blender tool fails to connect.

Blender version, build and Python version of the running instance.

Bridge health: version, host/port, scene name, open .blend path, workspace directories, command counters and the last error.

Use this to diagnose connection problems or to find out where previews, checkpoints and exports are written.

List every action the Blender bridge accepts.

Useful when a structured tool is missing: the action may still exist, and execute_blender_python can always fill the gap.

Overview of the current Blender scene: every object with its type and location, counts by type, total vertices/triangles, active camera, selection, collections, materials, render settings and world bounds.

Call this before modelling so you know what is already there.

List scene objects with name, type, location, size and visibility.

Lighter than get_scene_info when you only need names of one kind.

Everything about one object: transform (rotation in degrees), dimensions, visibility, collections, parent and children, material slots, world bounds, and for meshes the geometry statistics, UV layers and modifier stack.

Returns statistics, not raw mesh arrays -- use get_mesh_data for those.

The current selection and the active object.

The active object in full detail, or null when nothing is active.

Collection tree with object membership and visibility flags.

Every material in the blend file with its users and blend settings.

Every camera with transform, lens, field of view and clipping range.

Every light with type, energy, colour and type-specific settings.

Every image datablock: path, resolution, colour space and usage.

Raw vertex/edge/face arrays for a mesh.

Only for small meshes you need to reason about vertex by vertex; it refuses meshes above limit. For size, topology and material information use get_object or analyze_game_asset instead.

Add a primitive mesh object to the scene.

Rotation is in DEGREES. Sizes are radius/size/depth in Blender units; the primitive-specific options are ignored by primitives that do not have them. Returns the created object's full record.

Create a cube at (x, y, z).

Kept for compatibility with the original bridge; create_primitive is the general tool and takes rotation, scale and collection too.

Create an Empty. Useful as a parent, a pivot, or the offset target of an Array modifier.

Delete one object. DESTRUCTIVE -- make a checkpoint first if it matters.

Delete several objects. DESTRUCTIVE -- make a checkpoint first.

Duplicate an object, optionally moving the copy.

Rename an object. Blender appends .001 if the name is taken.

Make an object active. Many operators act on the active object.

Set the selection. Tools that default to "the selection" use this.

Clear the selection.

Worth doing before export or a tool that falls back to "the selection", so a stale selection cannot pull in objects you did not mean to touch.

Hide an object. Hidden objects are skipped by render_preview's auto framing.

Unhide an object in the viewport and (by default) in renders.

Move objects into a collection, unlinking them from their current ones.

Create a collection, optionally nested inside another.

Parent one object to another (or clear its parent).

Set an object's ABSOLUTE location, rotation (degrees) and/or scale.

Omitted components are left alone. Use translate/rotate/scale_object for relative changes.

Move an object by a delta (relative).

Rotate an object by a delta in degrees (relative).

Scale an object. By default scale multiplies the current scale.

Bake rotation and scale into the mesh data.

Game engines generally expect assets with applied rotation and scale and a scale of exactly 1. This modifies the mesh -- checkpoint first.

Move an object's origin without moving its geometry.

Build a mesh from explicit geometry.

Indices are validated before anything is created, so a bad face index is a clean error rather than a broken mesh. Keep it to a few thousand vertices; for anything procedural and large, use execute_blender_python with bmesh.

Join mesh objects into one. The others are consumed. DESTRUCTIVE.

Split one mesh object into several.

Make face normals consistent and outward-facing.

Run this when a render shows black or inside-out shading.

Switch objects to smooth shading, optionally with an auto-smooth angle.

Switch objects to flat (faceted) shading.

Conservative mesh hygiene: merge coincident vertices and drop loose geometry. Modifies the mesh -- checkpoint first.

Convert every face to triangles, permanently.

Usually unnecessary: exporters triangulate on the way out. Use this only when the triangulated topology itself must live in the blend file.

Add and configure a modifier in one call.

Returns the modifier's resulting state and the object's full stack. An unknown property name fails with the list of valid ones.

Change settings on an existing modifier. Angles are DEGREES.

Remove a modifier without applying it.

Bake a modifier into the mesh. IRREVERSIBLE without undo or a checkpoint.

Returns before/after geometry counts so you can see what it cost.

Bake the whole modifier stack, in order. IRREVERSIBLE -- checkpoint first.

The object's modifier stack with each modifier's key settings.

Add a Bevel modifier -- the cheapest way to make hard edges catch light.

Add a Subdivision Surface modifier. Each level multiplies faces by ~4 -- keep levels low for game assets.

Add a Mirror modifier -- model half an asset and get the other half free.

Add a Solidify modifier to give a flat surface real thickness.

Add an Array modifier to repeat geometry (fences, stairs, pillars).

Add a Boolean modifier to cut one object with another.

Booleans make messy topology -- check the result with analyze_game_asset and a render before applying.

Add a Decimate modifier to reduce triangle count.

For LOD chains prefer create_lod, which builds named copies and leaves the source untouched.

Add a Weighted Normal modifier.

Put this last in the stack, after a bevel with harden_normals, to get clean hard-surface shading that survives export.

Create a Principled BSDF material.

Colors are [r, g, b] or [r, g, b, a] floats in 0..1 LINEAR space -- not 0-255 and not sRGB hex. Returns the material's resulting properties.

A material's Principled BSDF values, render settings and users.

Update Principled BSDF properties on an existing material.

Fails clearly if a property is driven by a texture node -- edit that node instead, or disconnect it first.

Assign a material to objects.

By default this replaces every existing slot, which is what a single-material game prop wants. Pass replace=false to add a second material slot instead -- each extra slot is an extra draw call in most engines.

Unassign a material from an object, or delete the material datablock.

The material's full shader node graph: nodes, their socket values and every link. Read this before rewiring anything.

Add a shader node to a material.

Set default values on a node's unlinked input sockets, keyed by socket name.

Link one node's output to another node's input.

Socket names come from get_material_nodes; a numeric string selects by index.

Remove every link feeding one input socket.

Delete a shader node. Refuses the Material Output node unless forced.

Load an image file into Blender and report its metadata.

Paths are validated: reads outside the workspace (or the open .blend file's folder) are refused unless the user enables it in the add-on preferences.

Create a blank generated image, for example as a bake target.

Metadata for one image datablock: resolution, depth, colour space, path.

Add an Image Texture node and wire it into the material.

Give either image (already loaded) or filepath. With role='normal' the image is set to Non-Color and routed through a Normal Map node, which is what game normal maps need.

Point an existing Image Texture node at a different image.

UV layers on a mesh, and which is active.

Add a UV map. A mesh can hold at most 8 (a second one is the usual place for a lightmap).

Choose which UV map is active.

Automatically unwrap meshes. The right first choice for a prop with no seams marked.

Creates a UV map if the mesh has none.

Unwrap along marked seams.

Only useful once seams exist -- use mark_seams_by_angle first, or smart_uv_project for a seamless automatic result.

Mark UV seams on sharp edges -- a decent preparation step before unwrap_selected on hard-surface models.

Delete a UV map from a mesh.

Textures bound to that map will lose their coordinates, so check list_uv_layers first if the mesh has more than one.

Create a camera.

To point it at something, give look_at/look_at_object here, or use frame_objects_with_camera which also works out the distance.

A camera's transform and lens settings.

Choose which camera the scene renders from.

Move a camera and adjust its lens in one call.

Rotate an object so its -Z axis points at a target.

Cameras and lights look down -Z, so this aims them. Give either target coordinates or target_object.

Position a camera so the given objects exactly fill the frame.

Distance is computed from the render aspect ratio and the camera's field of view, and the clipping range is widened to suit. Use this before render_preview when you want to control the angle.

Create a light.

For a quick, even setup to inspect an asset, use create_preview_lighting instead of placing lights one at a time.

Update a light's settings. Angles are DEGREES.

Delete a light object and its data.

Build a neutral three-point studio rig sized to the subject.

Creates AI_Key, AI_Fill and AI_Rim area lights in an AI_PreviewLighting collection, with power scaled to the asset's size. Safe to re-run: it replaces the previous rig. Use this before render_preview when the scene has no lighting of its own.

Remove the AI_PreviewLighting rig and its collection.

Set the world background colour and strength.

The world lights the scene: a strength of 0 makes shadows pitch black.

Current render engine, resolution, samples and output format.

Change the scene's persistent render settings.

render_preview already overrides resolution, samples and format for its own render and restores them afterwards -- use this only when you want the change to stick.

Render a preview image and return its absolute path.

THEN OPEN THAT IMAGE AND LOOK AT IT. Read the returned image_path with your file reading tool, or call read_preview_image. Geometry statistics cannot tell you whether an asset has the right shape, sensible proportions, correct normals or a material that reads properly -- only the picture can.

Auto-frames the given objects, creates an AI_PreviewCam if the scene has no camera, renders with EEVEE at 512x512 by default, and restores the scene's render settings afterwards. Images land in workspace/previews.

Render the same subject from several angles at once.

The fastest way to catch problems a single view hides -- a front view will not show that the back is hollow. Returns one image path per view; look at all of them.

Most recent preview renders on disk, newest first.

Return a rendered preview as an image so it can be looked at directly.

Use this when you cannot read the PNG from disk yourself; otherwise reading image_path with your own file tool is cheaper. Only reads from the workspace previews directory.

Where the bridge writes previews, checkpoints, exports and logs, plus the currently open .blend file and whether it has unsaved changes.

Save the user's open .blend file in place.

Only do this when the user asks. Fails if the file has never been saved -- use save_blend_as then.

Save a copy of the scene into the workspace.

Never writes outside the workspace and, by default, never changes which file Blender considers open.

Save a timestamped checkpoint copy before risky work.

Writes _.blend into workspace/checkpoints. The user's own .blend file is never touched or re-targeted. Do this before applying modifiers, deleting objects, or any multi-step change you might need to back out of. begin_operation makes one automatically.

Checkpoints on disk, newest first.

Load a checkpoint, replacing the current session.

DESTRUCTIVE: everything unsaved in Blender right now is lost. Confirm with the user before calling this with confirm=true.

Step back through Blender's undo history.

Undo reflects Blender's UI history, so it reverses whatever happened last -- including the user's own edits. For rolling back your own work reliably, prefer checkpoints.

Step forward through Blender's undo history.

Insert a named undo checkpoint so the user can step back to here.

Export to a single self-contained .glb file.

The usual choice for game engines and web viewers: geometry, materials and textures in one file. Returns the absolute path and file size.

Export to .gltf with separate .bin and texture files.

Use export_glb unless you specifically need the textures as loose files.

Export to .fbx for Unreal or Unity pipelines.

Defaults to meshes/empties/armatures with modifiers applied. Returns the absolute path, file size and the triangle count that was exported.

Export to .obj. Simple static geometry only -- no animation, no PBR.

Files in the workspace exports directory, newest first.

Read-only report on an asset: object and mesh counts, vertices, triangles (base and after modifiers), materials, referenced textures, bounding dimensions, and a list of issues -- missing UVs, unapplied transforms, non-manifold geometry, objects with no material.

Modifies nothing. Pair it with a render: statistics catch budget problems, renders catch everything else.

Check an asset against explicit budgets and conventions.

Returns passed/errors/warnings. Constraints you do not set are reported as warnings rather than failures, so a plain call is still a useful health check. Read-only: it never modifies the asset, so fix anything it finds with the relevant tool.

Create a UCX_ box collider matching an object's bounding box.

Built in the object's local space, so a rotated asset gets a tight oriented box. Named UCX__01, displayed as wireframe and excluded from renders -- the convention Unreal expects.

Create a UCX_ convex hull collider.

Builds a convex hull and decimates it toward max_vertices, re-hulling afterwards so the result stays convex. Use this for shapes a box cannot approximate; use create_box_collision when a box will do, since it is cheaper at runtime.

Every UCX_ collision object in the scene with its complexity.

Generate an LOD chain by duplicating and decimating.

Creates _LOD0, _LOD1, ... and NEVER modifies the source object. Returns the triangle count of each level so you can see what each step actually saved.

Run Python inside Blender on the main thread. The escape hatch.

Use this when the structured tools cannot express what you need: bmesh surgery, geometry nodes, uncommon operators, bulk edits. Prefer the structured tools when they fit -- they validate inputs and return tidy results.

Captures stdout and stderr, returns the traceback on failure, and reports which objects appeared or disappeared. Assign to a variable named result (or pass return_expression) to send a value back.

This is TRUSTED LOCAL EXECUTION: the code has the same reach as Blender's own scripting console, in the user's live session. There is no shell tool, no subprocess and no outbound network in this bridge -- do not try to add them here.

Evaluate one Python expression in Blender and return its repr.

A quick lookup that does not need a whole script.

Open a named operation: an undo boundary plus a checkpoint.

Wrap multi-step asset work in begin_operation / end_operation so it reads as one task in Blender's history and can be abandoned in one call.

Close the open operation and summarise what changed.

Returns which objects were created and removed, and how long it took.

Abandon the open operation and roll back.

With a checkpoint this reloads it, which DISCARDS everything done since begin_operation -- including any of the user's own edits in that window. Without one it falls back to stepping the undo stack, which is best effort; the response says which path was taken.

Whether an operation is open, its label, elapsed time and checkpoint.