LLM-text-processor_MOD

Want an LLM to caption your outputs, rewrite a booru-tag prompt into plain English, or describe what's actually in an image - without paying for an API? This is the node. It's a fork of KingManiya's well-regarded ComfyUI-LLM-text-processor, modified to accept up to ten separate image inputs. That's basically the whole MOD: the original takes one image, this one takes a handful.

One honest caveat before you get invested: the README says straight out this is a one-time fork that will not be updated. If one image is all you ever need, go to the upstream repo instead. You're here because you want the multi-image version, and for that it works well.

What it actually is

A local-LLM text processor. It runs GGUF models through llama.cpp - the same quantized format family behind much of ComfyUI's big diffusion models, but here you're loading actual language models like Qwen3-VL, Gemma 4, or gpt-oss. No cloud, no key. Its only Python deps are numpy and Pillow, both already in ComfyUI; all the heavy lifting happens in a separate llama-cli binary.

How it works

Under the hood the node shells out to llama-cli and waits. The model dropdown is populated by recursively scanning ComfyUI/models/LLM for .gguf files (mmproj files are hidden from that list, which is nice). Pick your model, optionally pick a matching mmproj vision projector, and the prompt is written to a temp file and handed to the binary.

The image handling is where this MOD earns its keep. Each connected image - and each frame of a ComfyUI batch - gets written to a temp PNG and passed to llama.cpp in the same request. So you can caption a full grid or a range of video frames in one call, not one painstaking image at a time.

Reasoning models get special treatment. The node passes a --reasoning flag and parses the output: anything between [Start thinking] and [End thinking] lands in the REASONING output, the clean answer goes to RESPONSE, and llama.cpp's speed line goes to PERF. Wire the thinking in somewhere or just ignore it.

The inputs that matter

Most of the surface is sampler knobs you'll never touch. The ones you actually set:

• model - your GGUF, from ComfyUI/models/LLM. Put files anywhere under that folder.
• mmproj - the vision projector. Required the moment you connect any image.
• system_prompt - presets are plain .txt files in ComfyUI/models/LLM/prompts/. Drop a captioner.txt there and it appears in the dropdown.
• prompt - the instruction sent to the model.
• max_tokens - raise this. More on that below.
• reasoning - off, on, or auto. off is the right default for simple captioning and rewriting.
• ctx_size - context window; bigger eats more VRAM.

Temperature, top_p, top_k, repeat_penalty, seed, and the memory_mode/n_gpu_layers trio can all stay at defaults until you know you need them.

Installing it

Easiest path is ComfyUI Manager: search for LLM-text-processor_MOD, install, restart. Or the manual way:

cd ComfyUI/custom_nodes
git clone https://github.com/Eklipsis/ComfyUI-LLM-text-processor-MOD.git

Restart ComfyUI and you'll find it under LLM Text Processor. Then put models in place:

ComfyUI/models/LLM/My-Model/model-q4_k_m.gguf
ComfyUI/models/LLM/My-Model/mmproj-bf16.gguf

The real install friction isn't Python - it's llama.cpp. The node auto-downloads official llama.cpp release binaries, but only on Windows x64 with CUDA 13. Everyone else has to have llama-cli working some other way first. That's the actual gotcha, not the git clone.

Problems you'll actually hit

• No models in the dropdown - nothing .gguf under models/LLM, or you haven't restarted since adding it.
• Image input fails - mmproj set to none, or the projector doesn't match your model. The node even parses llama.cpp's n_embd mismatch error into a readable "choose the mmproj that belongs to your model" message, so the failure mode is at least legible.
• Empty or cut-off response - max_tokens too low, and reasoning models burn tokens thinking before they answer. With multiple images and reasoning on, start at 4096+ tokens and a 16384+ context. 2048 is not enough.
• Out of memory - lower ctx_size before anything else, then a smaller quant.
• It freezes mid-graph - generation is a blocking subprocess; it runs until llama-cli returns or timeout_seconds (default 300) kills it. Expected behavior, just set your timeout accordingly.

The honest take

This is a tiny, well-scoped fork of a node people genuinely use - the original gets recommended on r/StableDiffusion for prompt-to-natural-language work, typically paired with a Qwen model. It's GPL-3.0, fully local, and shells out to a pinned official llama.cpp release, which is more than can be said for some sketchier "LLM vision" nodes floating around the ecosystem. But it's frozen in time. If ten image inputs are the thing you need, grab it; otherwise the upstream repo is the better long-term home.