Extensions/ComfyUI LC Vision Nodes
ComfyUI Extension

ComfyUI LC Vision Nodes

ComfyUI LC Vision Nodes by lonecatone23 — a Qwen-VL GGUF vision/captioning pack built to actually survive shared-VRAM ComfyUI workflows: a Loader + Run split (so the model stays resident instead of being torn down every call), multi-reference input (several independent images plus a video in one call, not just a single batched slot), and an install script that resolves a matching llama-cpp-python vision wheel for the user's own machine instead of pointing at a manual wheel-matching guide. Companion to ComfyUI_LC123_nodes; separate Registry name.

By lonecatone23·Created 2 months ago·Updated 3 days ago· 16
lonecatone23/ComfyUI_LC_Vision_nodes
Nodes12
On cloudLocal install
CategoryLC Vision, LC Vision/movie
Stars16
Updated3 days ago
Readme

ComfyUI LC Vision Nodes

Custom nodes for ComfyUI by lonecatone23.

Local Qwen-VL vision tools built to survive a real ComfyUI session: model stays loaded, several references in one call, and it heals itself when the upstream backend's own decode bug fires.

Companion pack to ComfyUI_LC123_nodes, kept separate on purpose.

Release history lives in git tags. This page describes the pack as it is right now, not a changelog.


✋ llama-cpp-python: manual install and troubleshooting

LC Vision runs on the vision build of llama-cpp-python from the JamePeng fork. The one on PyPI can't load Qwen3-VL. On NVIDIA, install.py sets it up for you (ComfyUI-Manager runs it on install and update). Use this section when the Loader says llama_cpp is missing, or when you install by hand.

Find ComfyUI's Python first

  • 🛑 Every command below runs with ComfyUI's own Python, by its full path. A plain python or pip almost always installs into a different Python, and the Loader keeps saying llama_cpp is missing.
  • Portable: ComfyUI_windows_portable\python_embeded\python.exe
  • Desktop app, venv or other installs: the python.exe inside that install's .venv\Scripts, venv\Scripts or python_env folder (venv/bin/python on Linux).
  • 💡 Not sure? The Loader's error message prints the exact path ComfyUI runs on.
  • Check your Python and CUDA versions (Windows PowerShell, swap in your path):
$py = "C:\ComfyUI_windows_portable\python_embeded\python.exe"
& $py -c "import sys, torch; print(sys.version.split()[0], torch.version.cuda)"
  • Prints something like 3.12.10 13.0: Python 3.12, CUDA 13.0. You need both for the wheel.

The easy way: run install.py yourself

cd "C:\ComfyUI_windows_portable\ComfyUI\custom_nodes\ComfyUI_LC_Vision_nodes"
& $py install.py
  • It picks the right wheel, checks its sha256, installs it and tells you what it did. Restart ComfyUI after.
  • It does nothing if a working vision build is already there, so it's safe to run any time.

The manual way: pick the wheel yourself

  • Open the fork's releases and find v0.3.49 (the version LC Vision is tested on) for your system.
  • Reading a wheel name, e.g. llama_cpp_python-0.3.49+cu130-cp312-cp312-win_amd64.whl:

| Part | Means | Options | |---|---|---| | cu130 | CUDA 13.0 | cu124, cu126, cu128, cu130, cu131 | | cp312 | Python 3.12 | cp310 to cp314 | | win_amd64 | Windows | linux_x86_64 for Linux, macosx_11_0_arm64 for Apple Silicon (Metal) |

  • Pick the newest CUDA that isn't newer than your torch's CUDA. Torch on 12.9 = cu128. Torch on 13.0 = cu130.
  • Install it (this is the cu130 / Python 3.12 / Windows one, swap in yours; the + in the link is written %2B):
& $py -m pip uninstall -y llama-cpp-python
& $py -m pip install --no-deps --force-reinstall --no-cache-dir "https://github.com/JamePeng/llama-cpp-python/releases/download/v0.3.49-cu130-win-20260831/llama_cpp_python-0.3.49%2Bcu130-cp312-cp312-win_amd64.whl"
& $py -m pip install "diskcache>=5.6.1" "jinja2>=2.11.3" "typing-extensions>=4.5.0"
  • --no-deps keeps pip from touching your torch and numpy. The last line adds the three small packages llama-cpp-python needs.
  • Check it:
& $py -c "import llama_cpp; from llama_cpp.llama_chat_format import Qwen3VLChatHandler; print('OK', llama_cpp.__version__)"
  • OK 0.3.49 = done. Restart ComfyUI.

AMD, Intel and other non-NVIDIA GPUs

  • ⚠️ The prebuilt fork wheels are CUDA-only (plus Metal on macOS). Without an NVIDIA CUDA runtime they can't load, so install.py stops there and changes nothing.
  • You need to build the fork for your backend yourself, with a C++ toolchain (Visual Studio Build Tools, "Desktop development with C++", on Windows) and ComfyUI's own Python.
  • Vulkan (AMD or Intel), Windows PowerShell: install the Vulkan SDK first, then:
& $py -m pip install --upgrade cmake ninja scikit-build-core
$env:CMAKE_ARGS = "-DGGML_VULKAN=on"
& $py -m pip install --no-build-isolation --force-reinstall --no-cache-dir "llama-cpp-python @ git+https://github.com/JamePeng/llama-cpp-python.git"
& $py -c "import llama_cpp; print(llama_cpp.__version__)"
  • The last line should print a version. If it errors, the build went somewhere else or failed.
  • AMD HIP / ROCm: the fork's README has the steps (Windows needs the ROCm SDK environment variables set first; Linux uses CMAKE_ARGS="-DGGML_HIP=ON").
  • CPU only: the same commands with no CMAKE_ARGS. It works, slowly.
  • note: I have only tested this pack on NVIDIA. These build steps come from the fork's own README, so treat them as a starting point.

Troubleshooting

  • "llama_cpp is not installed, or the installed copy cannot load"
    • Nine times out of ten it went into the wrong Python. The error prints the right one: install with that path.
    • Read the part in brackets: it's the real import error, and the lines below match most of them.
  • "Missing 'jinja2'" (or diskcache, typing-extensions)
    • The wheel went in without its small dependencies. Run the exact command the error prints, then restart.
  • "is the original llama-cpp-python build" or "has neither Qwen3VLChatHandler nor Qwen25VLChatHandler"
    • Another custom node pack installed the PyPI version over the fork. Run install.py again (it replaces it) or do the manual install above.
    • 💡 If it keeps coming back after updates, another pack has llama-cpp-python in its requirements. Re-run install.py after updating that pack.
  • Windows: "DLL load failed" or "Could not find module ... llama.dll"
    • The wheel's CUDA is newer than your NVIDIA driver. Update the driver (CUDA 13 wheels need a 580 or newer driver), or install the next lower cu wheel.
    • Still failing: install the latest Microsoft Visual C++ Redistributable (x64).
  • Linux: works, but very slow / runs on CPU
    • The wheel's CUDA plugin can't find the CUDA 12 libraries. Run install.py: it tells you whether the plugin loads and prints the build command when it doesn't.
    • LC Vision loads them from your venv's nvidia packages when torch is a CUDA 12 build. On a CUDA 13 torch, build against your own CUDA: CMAKE_ARGS="-DGGML_CUDA=on" "/path/to/python" -m pip install "llama-cpp-python @ git+https://github.com/JamePeng/llama-cpp-python.git"
  • pip says "Requirement already satisfied" and nothing changes
    • Add --force-reinstall --no-cache-dir, as in the commands above.
  • Build from source fails with "No CMAKE_C_COMPILER" or "CMake not found"
    • Install Visual Studio Build Tools with "Desktop development with C++" (Windows) or build-essential + cmake (Linux), then open a new terminal and try again.
  • "backend registry count: 0" or "no backends are loaded"
    • Another custom node pack loaded its own copy of llama.cpp (ggml) first, and the fork's plugins bound to it. The error names the folder that copy came from: disable that pack, or ask its author to use the shared llama-cpp-python.
    • Linux: a system ggml package (/usr/lib/libggml.so, from pacman / apt) does the same. Remove that package, or start ComfyUI with LD_LIBRARY_PATH pointing at the venv's llama_cpp/lib folder first.
    • 💡 LC Vision loads its own copy at startup to stay ahead of this. If that ever trips up another pack, set LC_VISION_NO_GGML_PRELOAD=1 to switch it off.
  • "Fatal Decode Error" or "llama_decode failed" while running
    • That's not an install problem. Run handles it by resetting and, if needed, reloading the model once. If it keeps happening, report it.
  • Still stuck? Open an issue with the Loader's full error line. It holds the real import error and the Python path, which is everything I need.

Introduction

ComfyUI-QwenVL-Mod is the node most people reach for to run Qwen-VL GGUF models in ComfyUI, and it's genuinely feature-rich. Problem is, the GGUF backend crashes partway through a session more often than it should, and that's not bad luck. Three real, fixable causes:

  • The vision backend only exists in a fork. Qwen3VLChatHandler/Qwen25VLChatHandler live in JamePeng/llama-cpp-python, never merged upstream. That fork ships wheels as GitHub Release assets only, one per exact Python × platform × CUDA combo, not on PyPI. A plain pip install -r requirements.txt can never resolve the right one on its own.
  • No memory citizenship. It manages its own torch.cuda.empty_cache() calls and never asks ComfyUI's own comfy.model_management for room. Share the GPU with a staged MiniMax H3 pipeline and it grabs whatever's left over, which can be nothing.
  • A real state bug on reused models. Llama.reset() never touches _hybrid_cache_mgr, a KV-cache checkpoint the fork builds for hybrid/sliding-window models. Reuse the same Llama object twice (completely normal in a real workflow) and it throws Fatal Decode Error at Pos 0.

None of that gets fixed by updating a GPU driver. It needs an installer that resolves the right wheel for the machine it's actually running on, a Loader that plays by ComfyUI's memory rules, and a Run node that clears the specific stale state instead of trusting a reset() that doesn't do what it says.


LC Vision Loader 🔬

Loads a Qwen-VL GGUF model + its mmproj vision handler once, then hands a persistent handle downstream. ComfyUI's own node caching keeps it resident across queues as long as its inputs don't change.

  • Model discovery: scans every path registered under the LLM folder key (models/LLM/GGUF by default), pairs each model .gguf with an mmproj .gguf in the same folder. Only lists pairs that actually have both.
  • Auto-download on first use: the dropdown also lists a small curated set of Download: entries (Qwen3-VL 4B and 8B, each abliterated, each at Q8_0 or f16) that aren't downloaded yet. Picking one pulls it, and its mmproj-f16, straight from HuggingFace into the same folder discovery already scans. Q8_0 for low-VRAM or new setups, f16 for well-equipped machines and cloud rigs. An entry drops off the list once it's actually on disk.
    • After the download, the node switches itself to the real file name, so the next run just works.
    • Qwen3.5 VL (4B Q8, 9B Q4_K_M, 9B Q8) is in the list too. Qwen3-VL stays the ★ pick: in my tests Qwen3.5 was slower and guessed more.
    • Or download from LC Settings ⚙️ > Vision > Vision models.
    • Every download is pinned to one commit of its repo and checked against its sha256 before it is used.
  • ★ Report suggestion (only with LC123 installed and its System & Model Optimization Report run once):
    • A ★ in front of the model that suits your card, and a line on the node: ★ Report suggests: Qwen3-VL 8B Q8_0 · n_ctx 32768.
    • Hover the line for the Quality / Optimal / Fast rows.
    • It is only a hint. Nothing is picked for you, and the saved model name never changes.
  • device: auto / cuda / cpu: any option runs from the same installed wheel, so CPU inference on an NVIDIA machine doesn't need a separate CPU build. ⚠️ The prebuilt wheel is a CUDA build: on AMD, Intel or any machine without an NVIDIA CUDA runtime it cannot load, see AMD, Intel and other non-NVIDIA GPUs below.
  • n_ctx: 4096 / 8192 / 16384 / 32768, default 8192. It is reserved in VRAM up front (about 0.6 / 1.1 / 2.3 / 4.5 GB). 4096 for one image and a short prompt, 8192 for Caption and Prompt Enhancer, 16384–32768 for Moviemaker with several references or video frames. Workflows saved with another number keep it.
  • keep_model_loaded: on (the default) keeps the model in VRAM between runs. Off: every LC Vision node unloads it once it has answered, so your image model gets the whole card, and the next node or run loads it again (a few seconds). 💡 Turn it off on smaller cards, e.g. with SDXL / Pony / Illustrious.
  • Less VRAM, same answers: flash attention and an 8-bit context cache are on automatically (about 0.5 GB less on a 4B, up to 2 GB on an 8B at 16k). Older llama-cpp-python builds just load the plain way.
  • n_gpu_layers: -1 offloads everything, 0 forces CPU-only, anything else offloads that many layers.
  • n_batch also sets n_ubatch to match. ⚠️ llama-cpp-python defaults n_ubatch to 512 independently of n_batch. Raising only n_batch silently does nothing unless something also raises n_ubatch. This node does that for you.

LC Vision Caption 📝

Handle + prompt + references → text.

  • Up to three independent reference images plus a separate reference video, each labeled distinctly (<Reference 1>, <Reference 2>, <Target Video>) instead of merged into one batch. That's the actual gap in the upstream node this pack exists to close.
  • max_image_side downscales references before sending. Oversized references were the direct cause of the original node's "exceeding capacity" crashes, keep it in proportion with the Loader's n_batch.
  • max_tokens is a length limit the model actually follows: it's told to fit under it and end on a whole sentence. If it still runs over, the text is cut back to the last complete sentence, so a low limit gives a shorter caption, never a chopped one. Same for Prompt Enhancer.
  • style_tag (shared with Prompt Enhancer): pushes the response toward a specific visual style regardless of what the reference actually looks like. None / Realistic / Human After All / Anime / Cartoon / Cinematic / Hentai / Fantasy / B&W / Noir / Cyberpunk / Illustration / NSFW.
  • Self-heals on the upstream decode bug. Resets context first, and if that specific llama_decode failed error still surfaces, rebuilds the model from the Loader's own parameters and retries once, automatically. Any other error is not swallowed.

LC Vision Reviewer 🕵️ (BETA)

A quality gate for finished renders. Asks the vision model yes/no questions and passes the image on with passed and a report.

  • Checks: hands, faces, text (signs spelled right), artifacts, plus a prompt match when you wire the positive prompt in.
  • custom_checks: your own, one per line, written so yes = good (e.g. Is she wearing a parka?).
  • on_fail: flag (default) always passes the image on. block stops everything wired after it (the save, the upscaler, etc.).
  • A batch of more than 4 frames is read as a video: a few frames across the clip are checked together.
  • ⚠️ A vision model is a shortlist, not a judge. It misses things. Trust your eye over it.

LC Vision Prompt Enhancer 📝

Text-only rewrite pass over the same model handle. A vision model is still a perfectly good text-only LLM when nothing gets attached to the message.

  • Presets live in lc_vision_presets.json, not code. Ships with four original presets (Enhance, Refine, Creative Rewrite, Detailed Visual), Character Anchor, and four for Flux 3 Klein.
  • Flux 3 presets: Flux 3 Text to Image, Flux 3 Edit, Flux 3 Layout (boxes) and Flux 3 Edit (boxes) are Black Forest Labs' own prompt upsampler instructions, unchanged. The edit presets need the picture you edit in image_1.
  • image_1 / image_2: optional pictures the model sees while it rewrites.
  • Custom preset sits at the top of the dropdown. Reads the system prompt straight from the custom_system_prompt socket instead of the JSON file, for full per-workflow control. A new node starts on Enhance, and an empty custom_system_prompt falls back to Enhance instead of erroring.
  • Character Anchor preset for character datasets: give it the reference picture(s) and a few notes ("blonde hair, fit") and it writes one short description of the person only (face, eyes, hair, skin, build). Never the clothing, pose, background or light, so every prompt in a list can set those. Its inputs don't change between rows, so it runs once per list.
  • style_tag, same shared list as Caption.
  • MOSS BBOX: base prompt into LC MOSS Layout Prompt's prompt box, its output into prompt_text. The output stays a layout: the scene and every box are enhanced on their own, box names and positions kept. Box captions stay short (about 60 tokens): longer, the subjects outgrow their boxes. Bypass the Layout Prompt and the base prompt comes through as a normal prompt. No base prompt: the scene stays empty and the model picks the setting.
  • ✨ boxes in LC Bounding Boxes (LC123): an idea row on the box editor. With a picture, the vision model finds the subjects and writes their boxes, descriptions and palettes (Qwen3-VL 8B is the default: its own box grid is the editor's); without one, it plans the boxes from the idea. Signs with words become text boxes. Runs outside the queue, never during a render, and unloads when done.
  • 🌐 360 from card in LC H3 Story (LC_AV): the vision model reads a place's room picture and writes the whole place out, all the way round, for the Story's ✨ 360 to draw from. Same model choice as ✨ boxes; it loads for the one answer and unloads.
  • Think-leak retry: if the output looks like leftover planning text instead of the actual rewritten prompt, one retry asks explicitly for just the final text.

LC Vision Danbooru Caption 🏷️

Prompts built for SDXL, Pony and Illustrious. One image in, or a rough idea in the prompt box, out comes a prompt short enough for SDXL.

  • mode: Image analysis writes the prompt from the image (the prompt box is not used). Prompt enhance rewrites the idea in the prompt box.
  • output: short caption, detailed caption, Danbooru tags, or prompt gen mixed (one or two plain sentences, then the tags). Each finetune likes a different one: Pony and Illustrious lean on tags, realism finetunes on captions.
  • Real Danbooru tags only. Every tag is checked against the real tag list and repaired or dropped: "denim jeans" becomes jeans, "smiling" becomes smile, made-up tags are removed, and no humans next to 1girl is cleaned out.
  • max_tokens: how long the prompt can be, for every output. The instructions follow it. Rough guide: short caption 80, detailed caption 150, tags 150, mixed 200.
  • style_tag: the same styles as the other LC Vision nodes. On tags it adds the real style tags (Anime = anime coloring, anime screencap, Realistic = realistic, photorealistic, etc.).
  • quality_tags: none, Illustrious (masterpiece, best quality, ...), NoobAI (very awa, masterpiece, ...) or Pony (score_9, score_8_up, ...). Their opposites go into the negative (worst quality, low quality or score_4, score_5, score_6). Off by default: they sometimes do more harm than good.
  • negative box under the prompt: your own negative goes first, the automatic tags follow, duplicates removed.
  • positive and negative outputs. The negative always holds the anatomy, artifact and censorship tags (bad anatomy, malformed hands, fused fingers, blurry, watermark, censored, mosaic censoring, bar censor, ...).
  • ★ hint on the node: the Qwen3-VL size that suits your card for this node (it needs only a 4k context), e.g. 4B Q8_0 on 8 GB, 8B Q6_K on 10 GB, 8B Q8_0 on 12 GB and up. Set the Loader to it with n_ctx 4096 and turn the Loader's keep_model_loaded off.
  • One image slot and small token counts on purpose. The other LC Vision nodes are for long prompts (video, Krea 2, Qwen-Image).

LC Vision Moviemaker 🎥

Plans a video as N independently-generated segments in one LLM call, not N calls, so the whole arc stays continuous while each segment still comes out as its own self-contained MiniMax H3 prompt.

  • One call, whole plan. Story, length_seconds, segments, and preset all go in together. The model writes every segment in one response using a delimiter this node controls, so segment 2 can explicitly continue where segment 1 left off.
  • Output sockets grow with segments. Same autogrow idea as LC Batch Image. Add another wire and the count raises automatically.
  • Presets cover 3 MiniMax H3 modes: T2V, R2VA, FL2VA, each with an NSFW variant. 💡 They are a starting point. Refine them in lc_vision_moviemaker_presets.json or with Custom.
  • end_pad_seconds (0.5): LLMs undershoot a stated length, so this much is shaved off before the model sees it. Raise it if segments still stop early.
  • Custom preset, same pattern as Prompt Enhancer. The structural rules (clock, continuity, reference handling, timing) still apply underneath it, only the creative wording gets swapped.
  • Four reference images plus one reference video. reference_image_1..4 write back as <Picture N> tied to [Shot N]. reference_video labels as <Target Video> and feeds motion/style continuity rather than needing the same per-reference description treatment as a still.
  • Segments plan on their own local clock. Early on, the model tried (and reliably failed) to track a running global timestamp across segments itself, it kept resetting to 0:00 no matter how explicitly that was spelled out. Each segment now plans on its own self-contained clock instead, the thing it's actually good at, and the real global timeline gets stitched in afterward by code. Exact every time.
  • length_seconds defaults to 10.

LC Vision Showrunner (BETA) 🎬

Moviemaker's big brother for long videos: it plans a chain of short segments that pick up from each other. Its plan goes into LC H3 Make in LC AV, which renders and joins them. (LC H3 Story in LC AV is the hand-written way to the same plan.)

  • One style block for every segment. Who's in it, where, the light and the camera are written once and pasted word for word into every segment, so nothing gets reworded halfway through.
  • One continuous take. Every segment continues from the last 1.6 s of the one before (overlap_seconds), so its new action is planned on the time that's left. A CUT only happens where your story writes one ("cut to..."). Walking into a new place happens inside the take.
  • Ends settled. Each segment ends on a calm pose with the face visible, so the next one has a clean handoff. A line of dialogue never gets split across two segments, and the story's own lines are checked for.
  • Projects. 💾 Save (and every Run) writes the Shot List, the Reference Assembler's list and the settings to output/LC_H3/<project>/project.json. 📂 Load brings one back; the Reference Assembler keeps its own pictures when it already has some.
  • Plans once. The plan saves to output/LC_H3/<project>/plan.json and reloads in about 2 s without loading the model, until you change the story or the timing, or turn on replan.
  • Staging and props. The camera leads the main person so the face stays visible, and anything that comes back (the cup, the bag) is described once and repeated word for word, so it doesn't change between segments.
  • Fixes the joins. Before each CONTINUE segment it looks at how the one before really ended and rewrites the start to match. Most jumps at a join come from the plan saying "she opens the door" when the door is already open, and H3 snaps the pose to match the words. Timestamps and spoken lines are protected: a rewrite that loses either is thrown out.
  • extend_segments (on): a shot with a long line gets its own longer segment, up to 10 s, instead of a warning to shorten it. Off: every segment is segment_seconds long.
  • 💡 segment_seconds 5 is a good default. Shorter segments = less VRAM. The first segment is 5 s and each CONTINUE adds about 3.5 s, so about 16 segments make a minute.

LC Vision Shot List (BETA) 📋

The story for the Showrunner, filled in like a form instead of written from scratch. No AI involved.

  • The place, the cast (name, man / woman, look) and one row per shot: framing, camera move, action, who speaks and the line.
  • It writes the story the way the Showrunner reads it best: the place, the cast by name, "Cut to ..." for every new shot and at most one short line per shot.
  • segments: a suggested segment count: one per shot. A long line gets a longer segment from the Showrunner's extend_segments. Plug it into the Showrunner's segments.
  • 🧹 Clear empties the whole list for a new project (click twice). The Reference Assembler is never cleared.
  • warnings: what to fix, like a line too long for its shot or a speaker who is not in the cast. Empty when it all looks good.

LC Vision Storyboard (BETA) 🎞️

Reference pictures for a Showrunner movie, made with an image model in a separate workflow. Nothing here is required: a movie runs without it.

LC Vision Storyboard Builder

  • Reads the project and lists what is missing: a face for each cast member, a place picture for each place, and an anchor (the opening wide shot of a place with several people, holding who stands where).
  • One prompt, empty latent and seed per picture, so the sampler makes them all in one queue.
  • base_model: Krea 2 (Z-Image is set up for when its workflow exists).
  • make: missing only, or everything again. Your own pictures are never replaced.
  • only: names to make again, like Earl, the bank lobby. Each picture's seed comes from seed plus its name, so a redo of one keeps the others.
  • 1344 x 768 landscapes match the movie's 960 x 544 shape.

LC Vision Storyboard Save

  • Writes the pictures to input/lc_h3_refs/<project>/ and adds them to the project. 📂 Load on the Showrunner puts them in the Reference Assembler.

LC Vision Storyboard Sheet

  • A card for every picture the movie can use, right on the node: ✅ Use puts it in the Reference Assembler, ↻ makes it again, ✎ changes its prompt. Nothing to wire.

LC Vision Redirect (BETA) 🔬

The Showrunner does this itself now. Kept so older workflows still open; it passes the plan straight through when the Showrunner already fixed the join.


LC Note translation 🌐

LC Vision is also the translator behind LC Note 📝 (in LC123). There's no node for it and nothing to wire.

  • Pick a ❌ language on an LC Note and click Translate now. LC Vision loads a model on its own (text only), translates the note and its title, and unloads it again, so it never sits in your VRAM between clicks.
  • It uses your best local LC Vision model: an 8B quant first, then a 4B quant. Run an LC Vision Loader once if you don't have one yet.
  • Links, code, file names and numbers are locked before translation and checked after. If the model changes one, it retries on its own.
  • 💡 It's a 4B-8B model, so it's good, not native. Have someone proofread the languages that matter most to you. Hand edits to a translation are kept.

Vision Assistant 🔬

A sidebar tab (the LC logo on the left) that reads the open workflow for you. Works on any workflow.

  • Checkup: runs by itself on every workflow. No model, no VRAM. It catches:
    • missing packs (one card per pack) and nodes from the wrong pack (another pack under the same name, or an older version)
    • missing models with download links, or a one-click switch when you already have the same model under another name or format (qwen3-4B for qwen_3_4b), or the file was renamed upstream
    • files in a subfolder (one-click fix), placeholder files, models that need a license accepted on Hugging Face first
    • the wrong text encoder, a VAE that doesn't fit the model, model formats your card can't run well
    • settings that don't fit the model: steps and cfg for a turbo model or LoRA, clip skip, shift, Flux guidance, low denoise from scratch, ControlNets that never switch on, etc.
    • damaged wiring (one-click repair) and your last error in plain words
    • with LC123's System & Model Optimization Report: its problems and tips. 💡 Hide these tips hides the ones you don't need; problems always show.
    • 💡 Swap for LC nodes comes first: nodes from other packs that have an LC twin doing the same job (rgthree, Comfyroll, Easy-Use, pysssss, KJNodes, WAS, essentials, Crystools, mxToolkit, Detail Daemon, Depth Anything V2, FL Image Adjuster, etc.). Tick the ones to swap: settings and wires carry over and the LC node takes its place.
      • Works when that pack isn't installed too, so a workflow full of missing nodes can run on LC nodes instead. The missing-pack card says how many the swap can replace.
      • A node only shows when every wired socket has a match. Settings the LC node has no home for are listed under it.
      • Hide unticked stops offering the ones you want to keep.
      • Undo is on the Snapshots tab. Needs the LC pack that has the twin.
    • 📝 Convert notes to LC Notes comes next: core Note, Markdown Note and any other note node ("note" in its name, holds text, nothing wired). Text, title, colours and place carry over; plain text keeps its line breaks and every web address becomes a real link. Rich notes from other packs keep their headings, bold, lists, tables and code, and their download buttons become LC Note download buttons with their 📂 Place in line, even when that pack isn't installed. Why: LC Notes translate, fix spelling and turn links into link cards. Hide unticked works here too. Undo is on the Snapshots tab. Needs LC123.
  • Chat: ask about the workflow in plain words ("What's broken?", "Can you fix it?", "Where do I put my image?"). Select a node first and ask "how does this work?" to have it explained.
    • 🛑 It never changes anything without asking: every change gets Yes, do it / No, with Undo.
    • "Where is...?" makes the nodes glow and zooms to them.
  • Guided tour: "Explain this workflow", then ▶ Guided tour walks you through it part by part on the canvas, with numbered markers on the settings that matter.
    • Authors: Snapshots > Guided tour > Save to workflow ships your tour inside the file. Saved tours are locked (right-click to unlock and edit) and play on any card with no model.
    • Editing a tour: right-click it in Snapshots > Guided tour, 🔓 Unlock to edit, right-click again, Edit tour…
      • Change the tour's name and each step's title and text.
      • + Add a setting… under a step marks one more setting with the next number on the canvas, with a box for why it matters. × removes a marker. Up to 8 per step.
      • 💡 To mark a node outside the step, select it on the canvas first. Its settings show at the top under Selected on the canvas.
      • Add a step (at the bottom): pick what it lights up (any group, or the nodes you selected on the canvas) and where it goes (at the end or after step N), then + Add step.
      • ↑ ↓ move a step, × removes it.
      • LC Model Optimizer model/clip/vae ⚙️: showcase your own files. Paste a Hugging Face file link for the model, text encoder or VAE and it shows at the top of the LC Model Optimizer's ★ Recommended list for everyone who opens the workflow (it downloads on their first run). Other links are shown to them to get it. Blank = the defaults. Needs LC123.
      • Save locks the tour again. Save the workflow to keep it.
    • Rename or merge a group and the tour still finds it by where its nodes are. The Snapshots tab lists any card that points at a deleted group, node or setting.
    • The tour editor and tour card follow LC Note's language (14 languages).
  • Movie: shows up when a workflow has LC H3 Make (LC AV), or the older LC H3 Segment. It follows LC H3 Story's project or the Showrunner's. Every segment of the project with a thumbnail and a player, plus face, join and color checks in plain words with a fix button (Redo segment N, Make all remaining). Ask about this movie opens Chat with the numbers already typed in.
  • Batch snapshot: a look at the run before it starts. A single image always goes straight through. Run only stops to ask when it looks like a mistake: more than 16 images, several runs on a fixed seed, a big upscale on many images. It says which of those settings you changed since opening the workflow. The Snapshots tab shows what the next Run makes. Off in LC Settings ⚙️ > Vision.
  • Snapshots and Library: save the settings you changed (models, LoRAs, steps, bypasses) and put them back in one click. Prompts, seeds and input images stay out unless you tick them.
    • A snapshot remembers each model file's size and hash. Applying it later warns when a file has the same name but is not the same model any more.
  • Models in this workflow (under the checkup): every model file the workflow uses, ✅ here or ❌ missing, its size and which node uses it. A file you moved to another subfolder still counts ("found in MiniMax\Utility"), and RIFE weights in ComfyUI-Frame-Interpolation's folder are found too.
    • Find on CivitAI finds the exact page by the file's hash. Search CivitAI looks up a missing file by name (check it is the right one).
    • 📌 Save download links keeps the exact pages in the workflow, so whoever opens it can download anything they are missing.
    • CivitAI is only contacted when you press a button, and it only gets the hash, never the file.
  • VRAM: none until you ask the chat something. Auto picks the model for your card (8B Q8 on 20 GB+, down to 4B Q4 on 8 GB, CPU chat on smaller cards) and unloads it a minute after the last answer, or the moment you hit Run.
  • Settings: LC Settings ⚙️ > Vision (works without LC123): Assistant on/off, chat model (Auto / Off / a model), batch snapshot on/off, default n_ctx for new Loaders, the model list with a Download button, and Show them again for hidden tips and hidden swaps.
  • 💡 Hit ? in the panel for the full help.

💡 Quick tips

  • Restart ComfyUI after installing. Brand-new pack, needs a restart to be discovered.
  • Start with device: cpu on the Loader for your very first test so it can't collide with whatever else has the GPU, then switch to cuda or auto once you know it works.
  • Seeing [LC Vision] Decode failed on a reused model instance...; rebuilding and retrying once. in the console is expected, not a bug. That's the self-heal catching the upstream decode bug and recovering on its own. Only flag it if the retry fails too.
  • 4B suits Moviemaker and video workloads (more memory headroom for multi-frame batches). 8B suits Caption and image fidelity.
  • ✋ Moviemaker's [Shot N] label identifies which reference a moment involves. It is not a cut instruction. Ask it for one continuous take per segment if you see it start cross-cutting.

Example workflows

In workflows/:

  • LC Vision LLM Modules: Caption, Prompt Enhancer, Moviemaker and Reviewer, wired up and ready. Drop your own model and references in.

Licensing note

ComfyUI-QwenVL-Mod (GPL-3.0) has a genuinely good 22-preset library for its Prompt Enhancer. That's real creative content, not mechanical plumbing, so none of it is ported here. Prompt Enhancer ships with its own original presets instead. The four Flux 3 presets are Black Forest Labs' prompt upsampler instructions from black-forest-labs/flux-3-image-klein-pup (Apache-2.0), unchanged.

The GGUF-header reader in lc_vision_loader.py is the one piece that resembles upstream code in shape. It isn't ported, it's an independent implementation against the public GGUF spec, about as mechanical as code gets.

danbooru_tags.csv is the tag list from SmilingWolf's WD tagger models (Here), Apache-2.0. Used by LC Vision Danbooru Caption to keep only real Danbooru tags.

Install

  • Get the files. Clone it into ComfyUI/custom_nodes/:

    git clone https://github.com/lonecatone23/ComfyUI_LC_Vision_nodes.git
    

    Or grab the zip from the repo page and unzip it there instead.

  • Check the folder. __init__.py needs to sit directly in ComfyUI/custom_nodes/ComfyUI_LC_Vision_nodes/, not nested a level down.

  • Run install.py (ComfyUI-Manager does this automatically on install/update). It checks for a vision-capable llama_cpp first and does nothing if you already have one. Otherwise it detects your Python, platform, and CUDA version, and installs the matching llama-cpp-python 0.3.49 wheel from JamePeng/llama-cpp-python releases, checked against its sha256 first.

  • Restart ComfyUI. The console should print the LC Vision load line (12 nodes). If it doesn't, the folder structure is off: check the folder again.

  • 💡 Hard-refresh your browser after any web/ JS update going forward. It won't pick up changes on its own.

  • Not NVIDIA, or the Loader says llama_cpp is missing? See llama-cpp-python: manual install and troubleshooting at the top.

License

MIT. See LICENSE.

"True Nothing is. Permitted Everything is"- Yoda Auditore, Assassin's Wars