Install the bundled Blender addon and enable it, so the bridge can start.

Call this ONCE on a machine where blender_status reports not connected. It copies the addon into Blender's user addons directory and then lets Blender itself enable it and save the preference, leaving any other add-ons the user has enabled untouched.

Afterwards the user must restart Blender (or launch it if it is closed) - the bridge starts automatically with the addon.

Check whether the Blender bridge is reachable and what it is running.

Start with this. If connected is false, either the addon is not installed yet (call blender_setup once) or Blender is not running. Set BLENDER_MCP_AUTOLAUNCH=1 to let the server start Blender itself.

Get an overview of the open scene: objects, collections, materials, meshes, images, render settings, frame range and the active object.

Args: detailed: Include per-object modifiers, constraints, light and camera data.

Execute arbitrary Python inside Blender and return stdout, the expression value, or the traceback.

This is the general escape hatch: use it for anything the dedicated tools do not cover (node graphs, drivers, custom rigging, numpy-style math, bmesh work). Available names: bpy, bmesh, math, mathutils (Vector/Euler/Matrix/ Quaternion), json, os, sys, random, time, view3d (a context manager that injects a 3D viewport area so bpy.ops viewport calls work).

Example: python import bmesh bm = bmesh.new() bmesh.ops.create_cube(bm, size=2) me = bpy.data.meshes.new("C") bm.to_mesh(me) ob = bpy.data.objects.new("C", me) bpy.context.scene.collection.objects.link(ob) Result(ob.name)

Discover the bpy.ops operators available in this Blender build, with their descriptions and (optionally) their exact property names, types, enum options and defaults.

Use this to find the right operator before calling blender_run_operator.

Run any bpy.ops operator by name with automatic 3D viewport context fallback and validation of the property names.

Call blender_list_operators first if you are unsure of the exact id or property names.

Search Blender's operator namespace by keyword. Faster than blender_list_operators when you only know part of a name.

List objects in the scene with transforms, dimensions, materials and modifiers. Supports filtering and offset/limit pagination.

Args: collection: Only objects in this collection (includes children). type: Comma separated Blender types, e.g. 'MESH,LIGHT,CAMERA'. name_pattern: Regular expression matched against the object name. parent: A parent object name, or 'none' for top-level objects. detailed: Also include world matrix, shape keys and vertex groups.

Get everything known about one object: transforms, hierarchy, materials, modifiers, constraints, mesh statistics, custom properties and world matrix.

Add a mesh primitive to the scene and return its full description.

Example: a smooth torus at the origin -> type='torus', parameters={'major_radius': 1, 'minor_radius': 0.25, 'major_segments': 48, 'minor_segments': 16}, shade_smooth=True

Create a mesh object from explicit vertex and face data.

faces entries are zero-based vertex index loops; a face with 3 indices is a triangle, 4 a quad.

Duplicate objects together with their mesh data (an independent copy).

Permanently delete objects from the .blend file. This cannot be undone from the MCP server - save first if the scene matters.

Rename an object and, by default, its mesh/light/camera data block too.

Set or offset the transform of one or more objects.

With relative=True the values are added/multiplied onto the current transform instead of replacing it.

Bake transforms into mesh data. Use this before exporting or when a modifier must see real geometry rather than an object transform.

Set the selection and active object. Many operators operate on the selection, so this is how you target them.

Join several mesh objects into the first one, merging their geometry.

Parent one object to another (optionally keeping its world position).

Set smooth or flat shading on meshes. Pass auto_smooth_angle (for example 30) to keep sharp creases on a smooth surface.

Edit mesh topology: extrude, bevel, inset, subdivide, dissolve, delete, merge, recalculate normals and more.

Operates on the current edit-mode selection inside the object unless region='all'. Vertex/edge/face counts before and after are returned.

Add a modifier to an object. Non-destructive: use blender_apply_modifier or leave it in place for a live, tweakable result.

Bake a modifier's result into the mesh, making it permanent.

Create a collection, optionally nested under parent and optionally moving existing objects into it.

Add objects to an collection that already exists in the scene.

Use blender_create_collection first if the collection is missing. Objects stay linked to their other collections, so this adds a reference rather than moving them.

List all materials. With detailed=True also returns the node types and the current Principled BSDF input values of each material.

Create a Principled BSDF material and optionally assign it to objects.

Example - a glowing red metal -> name='NeonRed', base_color=[0.8, 0.02, 0.02, 1], metallic=0.9, roughness=0.25, emission_color=[1,0,0,1], emission_strength=5

Assign an existing material to objects, replacing their current slots.

Add a procedural or image texture node to a material and wire it into the Principled BSDF. This is the fast path to interesting surfaces without hand-building node trees.

Example - marbled stone -> material='Stone', node_type='noise', properties={'Scale': 6, 'Detail': 8, 'Roughness': 0.6}, input='Base Color'

Load an image from disk (including .hdr/.exr) and plug it into a material as Base Color. Creates the material if you do not name one.

Add a camera. lens in millimetres (50 = normal, 24 = wide, 85 = portrait) or fov_degrees as an alternative. Usually also pass point_at so it is actually aimed at something.

Aim any object along its local -Z axis at a target (its local +Y becomes 'up'). Works for cameras and spot lights.

Choose which camera the render uses. Call this before blender_render or blender_capture_viewport with mode='camera' if the scene has several.

Add a light. Typical energies: SUN 2-5, AREA 100-1000 W, POINT 50-500 W, SPOT 100-1000 W. size softens shadows on AREA/POINT lights.

Set the world/environment: flat colour, a neutral studio grey, a physical sky, an HDRI image, or a vertical gradient. The world is what you see through the background and what ambient light comes from.

Configure the renderer: engine, resolution, samples, colour management, transparency, motion blur, depth of field and output settings.

Take a picture of what Blender is showing and return it as an image.

This is how you check your work - call it after a change and look at the result. 'viewport' is nearly instant, 'render' is the real deal.

Render with the current engine and return the resulting image.

Cycles at 1080p can take minutes; check samples and resolution with blender_get_scene first, and consider the 'eevee' engine for iteration.

Save the scene to a .blend file. Pass a path for Save As, omit it to save in place. Unwritten work is lost if Blender crashes, so save as you go.

Open a .blend file, discarding the current scene. Save first.

Start a new empty scene, discarding everything currently open.

Import a 3D model from disk: .glb/.gltf, .fbx, .obj, .stl, .ply, .usd, .abc, .dae or .blend. Returns the names of the objects that were created.

Export the scene to a model file: .glb, .gltf, .fbx, .obj, .stl, .ply, .usd, .abc or .blend.

Jump to a frame and/or set the animation range and playback speed.

Insert keyframes on the current or given frame.

Defaults to keyframing the location of the active object. data_paths lets you key anything addressable, e.g. ['location', 'rotation_euler', 'data.energy'].

Report the frame range, all actions, and which objects are animated.

Audit the model and return a scored report: scale, dimensions, normals, topology, intersections, symmetry, naming, materials, UVs, transforms, pivots, poly budget, LODs, lighting and orphan datablocks.

This is the first tool to reach for after building something, and again before exporting. Pass target to check real-world proportions against a known vehicle or asset spec.

Each check reports ok, info, warn or error; a check that itself crashes is reported as an error entry rather than aborting the audit, so you always get a full picture.

Like blender_validate, but only the failures, each with a concrete fix.

Use this when you want to act rather than read: it returns an actionable list where every entry pairs a problem with the tool call that resolves it.

Deep statistics for one mesh.

Beyond face counts: manifold/boundary/wire edge census, whether the shell is closed, signed volume, surface area, min/max/zero-area faces, loose verts and edges, duplicate vertices within 1e-5, UV layers, vertex groups, shape keys and the modifier stack. Use it to decide between fixing a mesh and regenerating it.

Measure real-world distances that are tedious to eyeball: a bounding box, the distance between two object centres, or the extent of a whole assembly.

Generate a procedural texture and write it to a real PNG on disk.

Useful for plate text, hazard stripes, carbon weave, rust, brushed metal, leather grain and similar. The file is a normal image you can inspect, pack and ship - not a viewport-only effect.

Generate a matched BaseColor / Roughness / Metallic / Normal / AO set.

All five maps come from one height field and one seed, which is what makes them read as a single material. BaseColor is written sRGB, the data maps Non-Color. Pass material to connect everything to a Principled BSDF in one step, including an AO multiply onto Base Color.

Bake a material's procedural node setup down to image files on disk.

Needs UVs and a node-based material. Cycles is the reliable bake engine; if the bake fails the result says so and why instead of raising.

Pack every loose image into the .blend so the file is self-contained.

Do this before handing a .blend to someone else or committing it.

List every image datablock with size, source, colour space and packed state.

Set mode, active object, active collection and selection atomically.

Most operator calls need all four set correctly. Doing it in one round trip avoids leaving Blender in a half-applied state when one step fails.

Select objects by a predicate rather than by name.

Names are what agents get wrong on a large scene. This finds every mesh with loose geometry, without a material, without UVs, larger than N metres, belonging to a collection, or matching a glob.

Undo the last change pushed onto Blender's undo stack.

Pair it with blender_checkpoint to make a step reversible. Refuses to rewind across an Open File, because Blender's undo stack does not survive one and attempting it crashes Blender rather than raising.

Redo the last undone change, restoring the scene to the state it had before the matching blender_undo call.

Push a named marker onto the undo stack so a later blender_undo returns here.

Geometry operations that do not fit the generic modifier tool.

Covers mirror, array, solidify, screw, spin, weld, normal fixes, triangulation, decimation, remeshing, wireframe, shrink/fatten and a batch bevel. Edit-mode operations restore object mode automatically, even if the operator raises.

Inspect, mute, reorder, remove or apply modifiers across objects.

Modifier order changes results, and list shows the real evaluated stack rather than guessing from the UI.

Unwrapping and UV maintenance: report, smart project, unwrap, pack islands, weld, scale and centre. A UV layer is created if missing.

Create an armature, add bones, and bind meshes with automatic weights.

Also the escape hatch for crash setups: skin the body panels, then simulate.

Set a pose bone's location, rotation and scale. Useful for posing before a physics bake or for checking a rig's range of motion.

Rigid bodies, cloth, soft bodies, collision and force fields.

Set up separate panels as independent rigid bodies, add collision to the chassis, bake, and inspect. Rigid body constraints go through blender_run_operator with bpy.ops.rigidbody.constraint_add.

Hierarchy and housekeeping: duplicate a parent with all children, instance or realise collections, purge orphans, and inspect the depsgraph, enabled add-ons or datablock counts.

Turntable renders, a fast clay preview, render pass toggles, and contact sheets assembled from existing images. The clay preview uses Workbench, so it is near-instant even on a heavy scene.

Run many bridge commands in a single round trip.

Each step is {"command": <addon command>, "params": {...}}. Results come back per step, so one failure does not hide the steps that worked. This is the fastest way to build a scene, because it collapses dozens of round trips into one.

Command names are the addon's, not the tool names: add_primitive, create_mesh, set_transform, assign_material, add_modifier, validate, geometry, and so on.

Create a physically sensible PBR material from a named preset.

Presets set the Principled BSDF correctly for the real substance - car paint gets metallic plus a clear coat, glass gets transmission and IOR 1.52, leather and fabric get high roughness, emissive presets get emission colour and strength. Any socket can be overridden. Pass assign to put it on objects in the same call.

Build an arbitrary shader node graph from a declarative description.

This is the full-control path when a preset is not enough. Socket names are the real Blender ones, so anything from the manual works. Problems are reported per node rather than aborting, so one bad socket does not cost you the whole graph.

Dump a material's node graph: every node, its unconnected inputs with values, its outputs, and all links. Use it to find out what a material actually is before editing it.

Set one input socket on one node, by name. No guessing at socket indices.

Connect an output socket to an input socket inside a material.

Build a complete procedural surface in one call.

Wires a coordinate and mapping node to a noise, voronoi, wave or checker texture, then through a colour ramp into Base Color, a map-range into Roughness, and the raw field into a bump node. This is the graph most hard-surface and natural surfaces actually need, and it is tedious to assemble socket by socket.

Build the world shader: flat colour, vertical gradient, physical sky, or an HDRI image. Nishita with sun elevation gives a believable daylight environment without an HDRI download.

Write per-vertex colours as a gradient along an axis. Useful as a mask, for toon shading, or for baking masks into a vertex colour layer.

List every material with its users, the objects using it, node count, linked images and blend settings.

Fetch a URL to a local file and report its size and SHA-256.

Only http and https are allowed, the download is size-capped, and nothing downloaded is ever executed. Combine with blender_import_asset to pull a model straight onto the scene.

Import a 3D model from a URL or a local file, as separate editable objects.

Handles fbx, obj, gltf, glb, stl, ply, usd, usdz, abc, dae and blend. A URL is downloaded first, respecting the size cap. Everything arrives as ordinary objects you can then validate, modify and export.

Export the scene or a named set of objects to a model file.

Sensible defaults per format: fbx applies scale and bakes modifiers with materials embedded, glTF applies modifiers and exports textures, obj keeps normals and UVs. The call fails if the exporter reports success but no file appears, rather than claiming a lie.

List the asset libraries available for search and download.

Search a free CC0 asset library. Poly Haven needs no API key.

Returns ids you pass to blender_fetch_asset. Useful for grabbing a real HDRI or a photogrammetry texture instead of hand-rolling one.

Download an asset from a library by id, and optionally use it.

An HDRI becomes the world lighting in one call, which is the fastest route to a believable render without any HDRI hunting.

List every available Blender add-on with its enabled state and version.

Enable, disable or install a Blender add-on.

Installing requires confirm=true because it runs third-party code inside Blender. Only .zip archives are accepted, and the call is refused without that flag so an agent cannot silently install anything.

List the Python packages Blender's own interpreter can see, with sys.path and the project-local directory new packages go into.

pip install a package into a project-local directory.

Packages go to their own directory, never into Blender's bundled site-packages, so a bad dependency cannot break the application. Refused without confirm=true.

Append shader or geometry node groups from another .blend file, so you can reuse an existing shader library instead of rebuilding graphs by hand.

List every action with its frame range, user count, slot names and how many objects use it.

Create, assign, rename, copy or remove an action.

Handles Blender 4.4+ slotted actions, creating the slot up front so keys can be inserted immediately afterwards.

Insert keyframes on any data path, including modifier levels and custom properties, optionally filling a whole frame range.

Broader than the original keyframe tool, which only handled the three standard transforms.

Delete keyframes from a data path over a frame range, or clear the whole animation data on an object.

Inspect and shape the F-curves of an object's action.

This is where animation gets its character rather than just its timing: interpolation and easing, handle types, noise and cyclic modifiers, retiming the whole curve, or scaling its values.

Drive non-linear animation: push an action onto its own track so the active action stops driving the pose, then layer, blend and mute strips.

Add, list or remove drivers with real typed variables and expressions.

Useful for procedural motion that should not be baked: spin a wheel from the frame counter, bob something with a sine, or link a value to a custom property.

Create and drive shape keys: facial blends, damage states, LOD morphs or simple deformation without touching the base mesh.

Step a physics simulation forward, bake it to keyframes, or reset the point cache. Bake is how a cloth or soft-body result becomes a usable animation rather than a live simulation.

Drive the video sequencer: add movie or image strips to channels, set the frame range, and render the sequence out to a movie or image sequence.

This is the route to an actual rendered video rather than a single still.

Animate the camera: a keyed orbit turntable, a follow constraint, or a two-point dolly.

The orbit mode is the quickest route to a review turntable around a model - keys and constraints both, so it renders deterministically.

Report or set the frame range, fps and step, and manage timeline markers.

Report what the project is actually set to.

Covers the scene, the full render configuration including Cycles and EEVEE sampling and colour management, datablock counts, user preferences, file paths, linked libraries and registered handlers. This is the answer to "what are the current settings".

Change any single project setting by dotted path, and report the old and new value.

Deliberately one setting per call: a bulk setter would let a wrong path silently wreck a whole configuration.

Inventory every datablock in the file by type, with user counts, orphans and which library each came from. The fastest way to see what a .blend actually contains before merging or cleaning it.

List embedded Text datablocks and every .py file inside Blender's script paths, with sizes. Use it to find an add-on's or a script's real location.

List or search files, restricted to the user's home directory, Blender's script folders and the asset cache by default.

Pass allow_anywhere only when the user has actually asked for it.

Report Blender's interpreter, sys.path, script paths and whether given modules can be imported. Use it before relying on a library.

Report what a render would actually use: engine, effective resolution, frame range, resolved output path and whether that directory exists, colour management, camera and lights.

Quick health check on the project: missing camera, unpacked textures, orphan datablocks, missing linked libraries, meshes without materials, or Blender running headless.

Cheaper than a full validate when you just want to know what is wrong.

Unwrap meshes in one call and report the resulting UV coverage.

Picks a projection automatically when method is left at the default, so a scene of mixed hard-surface and organic meshes does not need hand-picking per object.

Repair stretched, overlapping or out-of-range UVs on existing meshes, then report what changed per object.

Create decimated LOD copies of meshes and put them in a LOD collection.

Reports the original and generated face counts so the trade-off is visible instead of assumed.

Repair mesh problems: merge duplicate vertices, recalculate normals and delete loose geometry, reporting the before/after counts per object.

Audit a generated model end to end and, with apply_fixes, repair the problems that have an unambiguous fix.

Built for the "I just generated this, is it usable" question: topology, UVs, materials, scale and naming in one pass.

Fetch the modelling quality guidelines the agent should follow.

Covers the things that actually decide whether a generated model reads as believable: real proportions instead of convenient ones, built structure rather than modifier stacks, deliberate camera and lighting before a render, and texture resolution that survives a close-up.

Build a complete lighting rig aimed at the subject.

Framing is derived from the target objects' bounds, so the lights land at a sensible distance instead of at a hard-coded guess.

Aim a camera at something and, optionally, frame it.

Saves a lot of blind iteration on 'why is my render empty'.

Search a free PBR texture library and download matching maps.

Pass apply_to to wire the result onto objects in the same call.

Search downloadable animation sources and list what is available.

Pass apply_to to import and attach the result in the same call.

Generate a procedural animation on the given objects.

Useful for previews and for checking that a rig actually moves something before spending time on a real animation.

Paint directly into an image datablock and write it to disk.

For placing decals, number plates, liveries or wear masks without leaving Blender.

List the add-ons Blender currently has enabled, with versions and the module names needed by blender_manage_addon.