Run a Local AI Assistant with DaVinci Resolve: Setup, Hardware, and Limits

You can use a local model in LM Studio to inspect your DaVinci Resolve project and create bins from written instructions. This guide connects LM Studio to Resolve’s native MCP server on macOS, then walks you through creating a test bin in a duplicate project. We checked the configuration and tool discovery in LM Studio 0.4.26 with DaVinci Resolve Studio 21.1.0 on macOS 26.2. We did not download or run a local model, so the model-driven prompts and memory performance below remain untested. We separately created the example bin through Codex using Resolve’s native MCP tools. LM Studio acts as the MCP host: it runs your local model and connects it to Resolve's tools. You don't need to enable LM Studio’s local inference server for this route, and you don't need to open port 1234. LM Studio can act as an MCP host directly from the app by loading an MCP server entry from mcp.json.

What you're connecting

There are three moving parts:

DaVinci Resolve Studio 21.1 or later, with Blackmagic’s native Resolve MCP executable installed as part of the app.
LM Studio 0.3.17 or later, acting as the MCP host.
A local model in LM Studio that supports tool use.

Resolve’s MCP server is the bridge into Resolve. LM Studio loads your local model and exposes MCP tools to it. The model reads your prompt and decides when to call a tool.

What connects to what. LM Studio runs the model and sends tool calls through the native ResolveMCP process. This describes the app-based connection; it is not evidence of a completed setup or an entirely offline workflow.

That distinction matters. If the model can't call tools, you can still chat with it locally, but it won't be able to inspect Resolve or create anything in the project. If LM Studio can't find the Resolve MCP executable, the model may be fine, but no Resolve tools will appear. If Resolve isn't running or the project isn't open, the server may load but have nothing useful to operate on. Blackmagic’s Resolve entry point is File > Setup AI Assistants. Use it as the Resolve-side integration entry point, especially on a fresh Resolve 21.1 Studio install. Don't assume that it automatically configures LM Studio. The concrete LM Studio route below is manual: you add Resolve’s MCP executable to LM Studio’s mcp.json.

Hardware requirements

Local AI and Resolve compete for memory. Resolve already wants GPU, CPU, storage, and RAM headroom, especially with camera originals, multicam, noise reduction, Fusion, or heavy grades. A local model adds another active workload on the same machine. For the macOS example here, LM Studio’s published requirements are a useful baseline: Apple Silicon, macOS 14 or newer, and 16 GB or more RAM recommended. LM Studio notes that 8 GB Macs may still run smaller models with modest context sizes, but that isn't the same thing as saying Resolve plus a tool-using local model will feel good on a real job. If your machine already struggles with the Resolve project, start with a smaller tool-capable model and a modest context size. Test it on a duplicate project and check that you can still use Resolve comfortably while the model runs. Check success with things you can observe: the model loads, chat works, tools appear, Resolve responds, and the machine remains responsive enough that an editor can still work.

Install and open LM Studio

Install LM Studio on the same Mac that's running Resolve. Open it before you touch the MCP configuration. First confirm that the app itself works before adding Resolve to the mix. In LM Studio, choose a model that fits your available memory and supports tool use. Confirm in LM Studio’s model and runtime UI that you selected this local model for the chat. Don't treat general model popularity as enough, because the requirement here isn't just “can answer questions.” The model needs to call tools through MCP. LM Studio’s model browser and runtime UI can change over time, so use the app’s current tool-capability indicators rather than relying on a fixed model recommendation. Before connecting Resolve, run an ordinary local chat with a neutral prompt. Ask something simple, such as:

In one sentence, suggest a clear name for a temporary Resolve test bin.

This doesn't prove anything about Resolve, and the model’s wording doesn't prove where inference is running. It only checks that the selected model loads, inference runs, and your basic LM Studio install is healthy. If regular chat is broken or painfully overloaded, don't continue into MCP troubleshooting yet. Fix the local model setup first.

Prepare Resolve

Open DaVinci Resolve Studio 21.1 or later. Open a project that you can safely duplicate. If you're testing in a shared project library, cloud project, or active finishing project, stop and make a disposable copy first. From Resolve, go to:

File > Setup AI Assistants

This action configures supported desktop assistants and may open an extension installer. In our Resolve 21.1.0 installation, its confirmation listed Claude Desktop, Claude Code, and Codex in ChatGPT. LM Studio was not listed, so it still required the manual configuration below. Keep Resolve open with the test project loaded.

Resolve’s supported assistant setup. File > Setup AI Assistants configured the listed clients. LM Studio is absent from this dialog and requires the manual mcp.json entry below.

For this LM Studio setup, you still need to add the MCP server manually in LM Studio. The important thing is that Resolve’s native MCP executable exists on disk and can be launched by LM Studio. On a standard macOS install, the native executable path is:

/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Applications/ResolveMCP

Check the actual path on your machine. If Resolve is installed somewhere else, or if your app bundle name differs, use the real path. A common mistake is copying a path from a guide without checking whether it exists locally. For reference only, the Windows default executable path is installation-dependent and is commonly:

C:\Program Files\Blackmagic Design\DaVinci Resolve\ResolveMCP.exe

This article’s working example stays on macOS.

Add Resolve MCP to LM Studio

In LM Studio 0.4.26, open the right-hand sidebar and select Integrations, the hammer tab. Choose:

Integrations > Install > Edit mcp.json

LM Studio opens its mcp.json file in the in-app editor. On macOS, that file lives at:

~/.lmstudio/mcp.json

Use the in-app editor unless you have a specific reason not to. LM Studio loads MCP servers from this file when you save it.

Add the native ResolveMCP command. LM Studio 0.4.26’s mcp.json editor contains the Resolve application path and an empty args list. This is the configuration we saved on the test Mac.

For a new file with no existing MCP servers, use this complete JSON:

{
  "mcpServers": {
    "davinci-resolve": {
      "command": "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Applications/ResolveMCP",
      "args": []
    }
  }
}

The empty args list is intentional because the native wrapper behavior for Resolve’s MCP server launches ResolveMCP without additional arguments. If your mcp.json already has an mcpServers object, don't paste a second top-level mcpServers object into the file and don't replace the servers that are already there. Merge only this davinci-resolve entry into the existing mcpServers object, using commas where valid JSON requires them:

"davinci-resolve": {
  "command": "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Applications/ResolveMCP",
  "args": []
}

After you save, LM Studio should automatically load the MCP servers defined in the file, and it spawns a separate process for each local MCP server. You don't need to start a local HTTP server in LM Studio, and you don't need the OpenAI-compatible server path for this setup. In our test, saving this entry made mcp/davinci-resolve appear in Integrations. Enabling it and expanding its Tools list showed get_resolve_status, search_scripting_api, and run_script. Tool discovery worked with no model loaded. It confirms that LM Studio can start the MCP server, but you still need a tool-capable model to send the requests below.

Confirm that Resolve tools appear. LM Studio discovered the native Resolve tools without a model loaded. Each visible tool is set to Ask. This shows server discovery, not a model executing a tool.

Check the connection

Open a chat in LM Studio with your tool-capable local model selected. Check that the Resolve tools are available, including:

get_resolve_status
search_scripting_api
run_script

Start with the smallest possible tool call. Ask the model:

Use the Resolve MCP tool get_resolve_status and tell me whether Resolve is reachable. Do not make any changes to the project.

LM Studio may show a tool confirmation dialog. Read it. For early testing, allow one tool call at a time instead of permanently allowing everything. Once you trust the behavior, you can adjust tool permissions later in LM Studio’s app settings. If get_resolve_status succeeds, ask for a read-only project inspection:

Read-only request: inspect the current Resolve project and tell me the project name, whether a timeline is open, and the top-level media pool bins you can see. Do not create, rename, delete, move, relink, render, or modify anything.

The words “read-only” are only a scope instruction to the assistant, not a permission boundary, and they don't restrict what a tool call you approve or the MCP server can do. The Resolve MCP server can expose a tool that runs scripts, so you should still review tool calls before approving them. Use the read-only prompt here to make the model inspect the project before it tries to act. Confirm that LM Studio shows an actual Resolve MCP tool response. Then compare the returned project name, timeline state, and bin list with what you can see in Resolve’s UI. Treat the connection as working only if the tool response exists and the returned information matches the open project closely enough for this small inspection.

Create a test bin

Now create a duplicate project. You can do this in Resolve using your normal project management workflow, such as saving a copy or duplicating the project from the Project Manager. Name it clearly enough that nobody mistakes it for the active job. Once the duplicate is open, ask LM Studio for one small, obvious change:

In the currently open duplicate Resolve project, create one top-level media pool bin named MCP_Local_Test. Do not change timelines, clips, grades, renders, project settings, or any existing bins.

Review the tool call before approving it. After it runs, confirm the bin appears in Resolve. Once the bin appears in Resolve, ask the assistant to list the bins again and check that its response includes the new one. For your next task, ask it to explain the script it plans to run before you approve it. The screenshot below shows MCP_Local_Test in a blank project named Aspect_Local_MCP_Tutorial. We created and read back this bin through Codex’s native Resolve MCP connection, then saved and exported the project. This checks the Resolve operation; we have not yet tested whether a local model in LM Studio produces the same result.

A test bin created through the native MCP tools. MCP_Local_Test appears in the blank Aspect_Local_MCP_Tutorial project. Codex created and read back this bin through Resolve MCP. No local LM Studio model was used for this operation.

Where local assistants help in post workflows

We recommend using this setup for tasks you can describe precisely and verify in Resolve: creating bins, organizing media based on names or metadata, running simple searches, and reporting what is in the current project. These are tasks where your prompt can include exact names, rules, and a clear stop condition. The risk rises when the request is broad or aesthetic. “Make this edit better” isn't a useful instruction. “Find all clips in the interview bin with names containing CAM_A and create a bin called Interview CAM_A Selects” is much safer. The model needs scope, naming rules, and a clear stop condition. The native Resolve MCP tools include a general script-running path, which is powerful. That also means the model may translate your request into scripting operations. For production use, ask it to describe intended actions before execution, especially for anything that touches media pool structure, timelines, grades, renders, relinks, or project settings.

Why source media context still matters

An assistant connected to Resolve can inspect what Resolve exposes through its tools and scripting API. That doesn't automatically mean it understands the broader production context: which drive is authoritative, which proxy set is safe to use, which camera originals are still pending, which review notes are current, or which stringout was superseded yesterday. You can use Aspect alongside Resolve to help an assistant find your source media and review context. Aspect is optional for the LM Studio connection above. It becomes useful when your instructions refer to footage, selects, or review notes that aren't available in the open Resolve project. For example, “use the approved selects from yesterday’s review” requires access to those selects and notes. Give the assistant that information before asking it to edit so it can identify the files you mean.

Common mistakes

If the connection isn't working, start with these checks:

LM Studio can't launch the MCP server if the command path doesn't exist exactly as written. Check the Resolve app location and confirm ResolveMCP is present inside the bundle.
If the Resolve tools don't appear after saving mcp.json, check the JSON structure, make sure you didn't create duplicate top-level mcpServers objects, and restart LM Studio if needed.
Ordinary chat may work even when tool use doesn't. Choose a model with tool-calling support and load it again.
Keep Resolve open, with the duplicate project loaded, before asking for project inspection or edits.
Some MCP servers or prompts can push too much context into a local model. Use narrower prompts, smaller project queries, and modest context settings.

Isolate the layer that failed. Chat failure is a model or LM Studio issue. Tool visibility failure is usually mcp.json or server loading. Resolve inspection failure is usually Resolve state, executable path, permissions, or an assistant/tool-call issue.

Limits to keep in mind

A local model runs on your machine and can avoid sending prompts to a hosted model service. Other parts of the setup may still access your files or the network. You need to download models and software, and an MCP server may access local resources. Check what each component can access before using it with private material. Performance is also not just about the model. Resolve may be decoding camera media, caching, rendering thumbnails, running effects, or holding large timelines in memory. The local assistant is an additional workload. If you want to use this on a workstation that's already near its limits, keep the model small and the tasks narrow. Compatibility isn't universal either. Resolve version, LM Studio version, model capability, operating system, app paths, and project state all matter. Treat the first setup as a small workstation test, not a facility-wide rollout.

Visual references and setup guides

LM Studio's MCP editor screenshots. The official 0.3.17 walkthrough shows Install > Edit mcp.json and the editor. Its example uses another MCP server; use our Resolve entry for this tutorial.
LM Studio's tool-confirmation example. See the published tool-confirmation interface. Check the current app UI when following the tutorial.
Resolve setup with desktop assistants. Our existing Resolve guide provides the broader setup walkthrough and visual context for the native integration.

FAQ

No. For the app-based MCP route described here, LM Studio loads the Resolve MCP server from mcp.json. You do not need to enable LM Studio's local HTTP inference server or open port 1234.

On a standard macOS install, the native Resolve MCP executable is at /Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Applications/ResolveMCP. Check the actual path on your machine, especially if Resolve is installed somewhere else or the app bundle name differs.

No. Ordinary local chat is not enough. The selected model must support tool use so it can call MCP tools. If chat works but no Resolve tools are used, check that you loaded a tool-capable model and that LM Studio can see the Resolve MCP server.

No. A read-only prompt is an instruction to the assistant, not a technical permission boundary. You should still review tool calls before approving them because the Resolve MCP server can expose script-running capability.

Check that mcp.json contains one valid top-level mcpServers object, that the davinci-resolve entry is merged into it correctly, and that the command path points to the real ResolveMCP executable. If the JSON and path are correct, save the file and restart LM Studio if needed.