export const meta = { title: "Run a Local AI Assistant with DaVinci Resolve: Setup, Hardware, and Limits", description: "Set up LM Studio as a macOS MCP host for DaVinci Resolve, add ResolveMCP manually, choose a tool-capable model, and test with one bin.", tldr: "Install LM Studio, load a tool-capable local model, add ResolveMCP through Integrations > Install > Edit mcp.json, not the HTTP server. Confirm with status, read-only inspection, and one test bin in a project copy.", slug: "davinci-resolve-local-ai-assistant", publishedAt: "2026-11-04", readingTime: 10, thumbnail: "https://cdn.aspectlabs.dev/blog/davinci-resolve-local-ai-assistant/cover-83db811a785b.png", authors: [ "edison" ], primaryTopic: "post-production", topics: [ "post-production" ], tags: [ "editing", "hardware" ], faq: [ { question: "Do I need to enable LM Studio's OpenAI-compatible server for this Resolve MCP setup?", answer: "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." }, { question: "Where is the Resolve MCP executable on macOS?", answer: "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." }, { question: "Can any local model in LM Studio control DaVinci Resolve through MCP?", answer: "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." }, { question: "Is a read-only prompt actually enforced by the Resolve MCP server?", answer: "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." }, { question: "What should I do if LM Studio does not show the Resolve MCP tools?", answer: "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." } ], draft: false } 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](/blog/post-production/davinci-resolve-mcp-claude-chatgpt-codex) 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](https://modelcontextprotocol.io/docs/learn/architecture): 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](https://www.blackmagicdesign.com/media/partial/release/20260908-03) or later, with Blackmagic’s native Resolve MCP executable installed as part of the app. - [LM Studio 0.3.17 or later](https://lmstudio.ai/blog/lmstudio-v0.3.17), 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. 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](https://lmstudio.ai/docs/app/system-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: ```text 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: ```text 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. 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: ```text /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: ```text 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: ```text Integrations > Install > Edit mcp.json ``` LM Studio opens its `mcp.json` file in the in-app editor. On macOS, that file lives at: ```text ~/.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. For a new file with no existing MCP servers, use this complete JSON: ```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: ```json "davinci-resolve": { "command": "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Applications/ResolveMCP", "args": [] } ``` After you save, LM Studio should [automatically load the MCP servers](https://lmstudio.ai/docs/app/mcp) 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. ## 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: ```text 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: ```text 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: ```text 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. ## 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](/features/asset-intelligence). 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](https://lmstudio.ai/blog/lmstudio-v0.3.17#install-new-servers-mcpjson). 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](https://lmstudio.ai/blog/lmstudio-v0.3.17#be-cautious). See the published tool-confirmation interface. Check the current app UI when following the tutorial. - [Resolve setup with desktop assistants](https://aspect.inc/blog/post-production/davinci-resolve-mcp-claude-chatgpt-codex). Our existing Resolve guide provides the broader setup walkthrough and visual context for the native integration.