{"id":70,"date":"2025-07-20T14:21:00","date_gmt":"2025-07-20T06:21:00","guid":{"rendered":"https:\/\/blog.liu-qi.cn\/?p=70"},"modified":"2026-04-18T21:57:40","modified_gmt":"2026-04-18T13:57:40","slug":"comfyui%e5%85%a5%e9%97%a8%ef%bc%88%e4%ba%8c%ef%bc%89%ef%bc%9a%e5%a6%82%e4%bd%95%e6%89%93%e9%80%a0%e8%87%aa%e5%b7%b1%e7%9a%84%e5%b7%a5%e4%bd%9c%e6%b5%81%ef%bc%8c%e8%ae%a9ai%e7%94%9f%e5%9b%be-%e4%bf%ae","status":"publish","type":"post","link":"https:\/\/en.blog.liu-qi.cn\/2025\/07\/20\/comfyui%e5%85%a5%e9%97%a8%ef%bc%88%e4%ba%8c%ef%bc%89%ef%bc%9a%e5%a6%82%e4%bd%95%e6%89%93%e9%80%a0%e8%87%aa%e5%b7%b1%e7%9a%84%e5%b7%a5%e4%bd%9c%e6%b5%81%ef%bc%8c%e8%ae%a9ai%e7%94%9f%e5%9b%be-%e4%bf%ae\/","title":{"rendered":"ComfyUI Basics Part 2: How to Build Custom Workflows for More Efficient AI Image Generation and Editing"},"content":{"rendered":"

This is the second article in the ComfyUI introductory series. If you are completely new to ComfyUI, it is recommended to first read the previous article:Breaking Down the Workflow to Get You Started with ComfyUI<\/a>\u3002<\/p>\n

Originally, at the end of the last article, we were going to talk about Flux Kontext image editing.<\/p>\n

However, Doubao recently launched ‘Super Creative 2.0’. I truly feel that in most scenarios, its image editing capabilities are not inferior to Kontext, and even surpass it in creativity. If you want to use it directly and quickly handle 70% of problems, honestly, I recommend everyone try Doubao.<\/p>\n

Here’s a demonstration of Doubao’s effect with an image:<\/p>\n

\"\"<\/p>\n

Like Kontext, it performs local repainting without altering parts fixed in the prompt, but it has a lower barrier and is even free. After using it, I personally feel that the Flux Kontext model itself has become less important.<\/p>\n

Therefore, although this article will still cover Kontext, the focus will be on demonstrating how to comfortably use a model with specific capabilities through building a Kontext workflow. Hopefully, it will inspire your thinking on ComfyUI workflow design. I hope you approach this article with such expectations. If you need a comprehensive introduction and review of Flux Kontext’s capabilities and usage methods, you may need to read some additional articles.<\/p>\n

Actually, it’s not just Doubao; the Black Forest Studio also offers a Playground (https:\/\/playground.bfl.ai\/) for using Flux Kontext through conversational chat.<\/p>\n

At this point, I feel I must first answer a question before I can continue writing: Why use ComfyUI? Using it directly on a webpage seems fine too, so why bother learning ComfyUI?<\/p>\n

Behind this is actually related to another widely mentioned issue recently:<\/p>\n

ChatBot or Agent?<\/p>\n

In today’s context, it can also be written as:<\/p>\n

ChatBot or WorkFlow?<\/p>\n

\"\"<\/p>\n

ChatBots have a lower usage barrier, but they can only perform single, one-off operations.<\/p>\n

However, in most real-world application scenarios, what we need to complete is often a set of operations. Due to interaction requirements during the process, the context window limitations of large models, etc., AI struggles to complete an entire set of operations in one go through conversational communication.<\/p>\n

This results in the fact that if we want to use a ChatBot to complete complex tasks, we must go through cumbersome multi-turn conversations, with both controllability and efficiency being low.<\/p>\n

WorkFlows solve this problem.<\/p>\n

They themselves represent a set of operations, and can incorporate the capabilities of large models for intelligent decision-making.<\/p>\n

For example,<\/p>\n

I often use the AI field shortcut feature in Feishu’s multi-dimensional tables, such as this table:<\/p>\n

\"\"<\/p>\n

Don’t think that only workflows connected by lines between nodes count as workflows.<\/p>\n

Actually, many templates built with multi-dimensional tables are essentially workflows. Even your daily routine of arriving at the office in the morning, making a cup of coffee, turning on the computer, organizing yesterday’s tasks and planning today’s work is also a workflow.<\/p>\n

The function implemented by the above table is to recommend travel plans in Chinese cities tailored to foreign friends with different backgrounds; any friend’s background or target city can be switched at any time.<\/p>\n

You can imagine how complex it would be to implement this in a ChatBot if these variable options change frequently and in large quantities.<\/p>\n

Let me now expand on the configuration of the last field shortcut; the prompt is written like this:<\/p>\n

\"\"<\/p>\n

What do you think it resembles?<\/p>\n

Imagine putting it into ComfyUI: the friend’s hometown, age, gender, hobbies, etc., as information nodes. Some are initial nodes (like gender), others are secondary nodes (like what fun things there are), each pulling out a connection line to connect to the input endpoint of the final node that generates the recommendation result.<\/p>\n

Multi-dimensional tables and ComfyUI are just two different forms of workflow presentation.<\/p>\n

Now look at the next table, which is also a previously shared poster imitation template:<\/p>\n

\"\"<\/p>\n

Doesn’t it look very similar to the image reverse-engineering and regeneration workflow we created in the previous ComfyUI article?<\/p>\n

\"\u56fe\u7247\"<\/p>\n

The underlying logic is actually the same, but in the table template’s workflow, more steps involve LLM intervention, making it more intelligent.<\/p>\n

This is also one of the tips I want to share to make AI image generation\/editing workflows more efficient:<\/p>\n

Appropriately incorporate LLMs (Large Language Models).<\/p>\n

Let’s use Flux Kontext as an example, since that was the original topic.<\/p>\n

The latest version of ComfyUI is so much more convenient than before.<\/p>\n

Simply click ‘Workflow’ in the upper right corner, select ‘Browse Templates’, and you can import various official built-in ComfyUI workflow templates with one click.<\/p>\n

Here, both locally run dev version workflows and those using online APIs are provided, under the ‘Flux’ and ‘Image API’ tabs respectively.<\/p>\n

\"\"<\/p>\n

\"\"<\/p>\n

APIs are, after all, paid services, and the model scale is also larger. Moreover, the full fp16 local model is still a bit demanding for my 4090 with only 24GB VRAM, so I use the fp8 quantized version provided by Comfy. Therefore, in some detailed effects, the API inevitably performs better than local execution.<\/p>\n

However, local models have the advantage of not relying on the network and not costing money.<\/p>\n

In a situation where both options have their merits, my usual approach is to have them all.<\/p>\n

So, the first step in building my own workflow was to assemble them together, so I could use whichever one I wanted.<\/p>\n

Assembling workflows in ComfyUI is also very simple.<\/p>\n

Just hold down Ctrl, select the nodes to copy, Ctrl+C to copy, and then paste them into the target workflow window.<\/p>\n

\"\"<\/p>\n

Like this, I pasted the API workflow into the local workflow window.<\/p>\n

\"\"<\/p>\n

Let’s break down these two workflows one by one.<\/p>\n

First, the relatively complex local workflow.<\/p>\n

\"\"<\/p>\n

Ignore the default Step 1, 2, 3 groupings; let’s look at the parts within the three colored selection boxes I’ve drawn.<\/p>\n

First, look at the bottom-left blue box area, which contains four nodes:<\/p>\n

First, two ‘Load Image (from Output)’ nodes. Currently, one is in an ignored state, meaning only one image is loaded.<\/p>\n

Then, the ‘Image Stitch’ node’s function is to combine two images together. This is because while Flux Kontext can handle multi-image references, it actually only accepts a single image input, so multiple images must be combined beforehand. I’ll demonstrate this later; if only one image is uploaded, as shown in the current state, the stitch node still outputs just one image.<\/p>\n

Finally, the ‘FluxKontextImageScale’ node resizes the image. You can see the original image size is 22082944, and after processing, the preview image size becomes 880<\/em>1184, a size more suitable for local model processing.<\/p>\n

\"\"<\/p>\n

This ‘Load Image (from Output)’ is not very convenient; it can only select previously generated images as input and needs a slight modification. Let’s replace them with two regular ‘Load Image’ nodes, so we can upload any image.<\/p>\n

Right-click the second image upload node, and in the pop-up menu, click ‘(Un)Ignore Node’ to enable it.<\/p>\n

\"\"<\/p>\n

Let’s upload a red hat. Now, in the preview window, you can see the effect of the ‘Image Stitch’ node; it has combined these two images into one. The ‘direction’ parameter is ‘right’, so image2 (the hat) is stitched to the right side of the person.<\/p>\n

\"\"<\/p>\n

Having looked at the blue box section for uploading images, now let’s examine the red and yellow boxes.<\/p>\n

\"\"<\/p>\n

The workflow encompassed by these two boxes should be very familiar to you; it’s the local Flux image generation workflow from the previous article. The only difference is that the image generation model has been changed to the Kontext model, and the positive prompt has been pulled out separately.<\/p>\n

Switching to the API image generation workflow, this one is even simpler.<\/p>\n

\"\"<\/p>\n

The left part uploads the original image, and the right part generates the new image.<\/p>\n

The Kontext API in this workflow is provided via Comfy relay, which is faster than directly connecting to the Black Forest Studio’s API. Top-ups and usage are processed through Comfy; you can find the top-up option by clicking your avatar in the upper right corner.<\/p>\n

\"\"<\/p>\n

However, Comfy’s Kontext node does not offer adjustable content moderation settings, so sometimes requests to modify abstract or NSFW images may be directly rejected.<\/p>\n

Therefore, another commonly used Kontext API is the official Black Forest version, which supports nodes for manually setting moderation levels. Let’s add this to the all-in-one workflow as well.<\/p>\n

You need to install the ‘Flux Kontext Creator for ComfyUI’ node; the specific installation method can be found in the previous article.<\/p>\n

\"\"<\/p>\n

Then, configure the config.ini file and API key according to the instructions in the README file on GitHub. I won’t demonstrate the specific steps.<\/p>\n

https:\/\/github.com\/ShmuelRonen\/FluxKontextCreator<\/p>\n

\"\"<\/p>\n

As for obtaining the API key and making top-ups, you need to visit the official Black Forest website mentioned earlier (https:\/\/dashboard.bfl.ai\/). By default, registration gives you 200 credits for a free trial.<\/p>\n

\"\"<\/p>\n

The usage of the ‘Flux Kontext Creator for ComfyUI’ node is basically the same as Comfy’s Kontext API node, with the same connection method, but it adds parameters for manually selecting ‘pro’ and ‘max’ nodes and manually setting moderation intensity.<\/p>\n

\"\"<\/p>\n

Right-click and ‘Add Group’ to organize nodes with the same function into a group with a colored background, as shown in the image above.<\/p>\n

\"\"<\/p>\n

Now, we want to put the three image generation paths\u2014local, Comfy API, and BFL API\u2014into a single workflow, where the original image loading and prompt modules can be shared among all three.<\/p>\n

So, we can connect the output endpoint of the uploaded image to the input image endpoints of all three; then, add an input string node and connect it to the prompt text boxes of the three, so that just by entering the prompt in the input string node, all three sub-workflows can use it.<\/p>\n

\"\"<\/p>\n

You can add an ‘Ignore Multiple Boxes’ node in the empty space.<\/p>\n

\"\"<\/p>\n

Through this node, you can quickly control the enabled state of the function boxes.<\/p>\n

\"\"<\/p>\n

And with that, a simple all-in-one workflow is complete.<\/p>\n

\"\"<\/p>\n

Next, let’s refine it further to make it more ‘user-friendly’.<\/p>\n

First, the prompts.<\/p>\n

The built-in workflow templates in ComfyUI actually thoughtfully provide a set of prompt technique notes next to them for users to learn and reference.<\/p>\n

\"\"<\/p>\n

But the learning curve is still a bit steep. Moreover, Kontext only supports English, which is quite stressful for users who aren’t proficient in English.<\/p>\n

So, what should we do?<\/p>\n

For problems like this, my usual solution is: integrate an LLM.<\/p>\n

The results of multimodal generation models are what you see is what you get, making them easier to understand and implement. But when it comes to true intelligence, large language models are the way to go. The higher training and inference costs of LLMs are not without reason. The more you use large models, the more you appreciate this point.<\/p>\n

We can directly build a ‘Prompt Generator’.<\/p>\n

\"\"<\/p>\n

Input the ‘Prompt Techniques’ from earlier as the system prompt to the LLM:<\/p>\n

You are a 'Flux Kontext Prompt Generation Master', skilled at generating prompts that comply with Flux Kontext Prompt Techniques based on the user's described requirements.<\/code><\/pre>\n
Then, just upload the image and describe the desired changes in the simplest terms possible.<\/p>\n
For example, I input the requirement ‘Change her into a blue dress’.<\/p>\n
\"\"<\/p>\n
No need to worry about what changes and what stays the same, or whether the wording should be ‘she’ or ‘the woman’; the LLM will handle everything according to the specifications.<\/p>\n
\"\"<\/p>\n
After the entire workflow runs, she is changed into a blue dress.<\/p>\n
\"\"<\/p>\n
Taking it a step further, if the original image is complex and a simple requirement description isn’t enough for the LLM to understand what should change, what should be preserved, and how to phrase it.<\/p>\n
We can also add the reverse-engineering module mentioned in the previous article, use a ‘String Merge’ node to combine it with the original prompt, and also tell the LLM what’s in the image, so it can generate a more precise prompt.<\/p>\n
\"\"<\/p>\n
Another example: the API nodes have a drawback; they only allow generation in a few fixed aspect ratios.<\/p>\n
\"\"<\/p>\n
But the original images we upload could be horizontal or vertical, making adjustments inconvenient each time.<\/p>\n
How to make the aspect ratio adjust automatically? This can also be done using an LLM.<\/p>\n
\"\"<\/p>\n
First, we can use an ‘Image Size’ node to read the image dimensions and output the width-to-height ratio, for example, the output in the image above is 2208:2994.<\/p>\n
Then, we can directly use the LLM to judge:<\/p>\n
Please determine which of the following aspect ratios is closest to the image ratio I give you, and output (and only output) that ratio.<\/code><\/pre>\n
Output the closest size ratio.<\/p>\n
\"\"<\/p>\n
Then, connect this ratio to the API node’s aspect ratio parameter.<\/p>\n
Note that parameters can only be connected if their types match. Here’s a tip for confirming parameter types:<\/p>\n
Drag a connection line from the corresponding parameter to create a new node. At that point, you’ll see a hint about the parameter type. For example, in the image below, the parameter type for this ratio is: Combo.<\/p>\n
\"\"<\/p>\n
So, we need to add a format conversion node between the string and the ratio parameter: String to Combo.<\/p>\n
\"\"<\/p>\n
This way, automatic aspect ratio adjustment is achieved.<\/p>\n
Let’s find a new case to run through.<\/p>\n
For instance, I want to keep the furniture and decoration of the room below unchanged, but make it more girly.<\/p>\n
\"\"<\/p>\n
Now, I just need to input the image processing requirement:<\/p>\n
Keep the existing decoration and furniture, and style this room to be a cute girl's room.<\/code><\/pre>\n
The LLM automatically enriched the items for a girl’s room and required preserving the existing decoration and furniture:<\/p>\n
\"\"<\/p>\n
Then, it automatically recognized that the original image’s ratio was closer to a 3:4 vertical aspect, so the API image generation automatically outputs in a 3:4 ratio.<\/p>\n
Here are the final two images generated by the local model and the API:<\/p>\n
\"\"<\/p>\n
By analogy, we can also use image size acquisition for the multi-image reference mentioned earlier.<\/p>\n
The local Kontext model’s input and output images have the same aspect ratio. The multi-image processing method first combines them into one image before outputting, so the output image’s aspect ratio is the aspect ratio of the combined image.<\/p>\n
If both input images have backgrounds, they will usually be blended. But in cases like the example above where one stage has a white background, the result will likely still include a white background image in the output:<\/p>\n
\"\"<\/p>\n
To facilitate direct output, we can create a multi-image cropping function block here.<\/p>\n
Again, using the ‘Image Size’ node, and without even needing an LLM, directly calculate the cropping position based on the original and generated image resolutions using arithmetic expressions, then perform the crop.<\/p>\n
\"\"<\/p>\n
The effect is as shown in the image below:<\/p>\n
\"\"<\/p>\n
Already 5000 words, space is limited, and what can be covered in the article is just the tip of the iceberg.<\/p>\n
However, if you are a ComfyUI beginner who has followed from the previous article to here, you should now have some ideas about Flux Kontext and building ComfyUI workflows.<\/p>\n
Based on actual usage needs, you can later add various function nodes and modules to the workflow, such as image upscaling, facial optimization, and more. You can even connect the ComfyUI workflow directly to Photoshop via the SD PPP plugin, integrating it into your daily image processing workflow.<\/p>\n
\"\"<\/p>\n
These are left for you to explore on your own.<\/p>\n","protected":false},"excerpt":{"rendered":"
This guide demonstrates how to build custom ComfyUI workflows using the Flux Kontext model for efficient AI image generation and editing, with practical tips on integrating LLMs for smarter processes.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[24],"tags":[8,7,6,13],"class_list":["post-70","post","type-post","status-publish","format-standard","hentry","category-articles","tag-ai-","tag-comfyui","tag-13"],"_links":{"self":[{"href":"https:\/\/en.blog.liu-qi.cn\/index.php\/wp-json\/wp\/v2\/posts\/70","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/en.blog.liu-qi.cn\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/en.blog.liu-qi.cn\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/en.blog.liu-qi.cn\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/en.blog.liu-qi.cn\/index.php\/wp-json\/wp\/v2\/comments?post=70"}],"version-history":[{"count":0,"href":"https:\/\/en.blog.liu-qi.cn\/index.php\/wp-json\/wp\/v2\/posts\/70\/revisions"}],"wp:attachment":[{"href":"https:\/\/en.blog.liu-qi.cn\/index.php\/wp-json\/wp\/v2\/media?parent=70"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/en.blog.liu-qi.cn\/index.php\/wp-json\/wp\/v2\/categories?post=70"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/en.blog.liu-qi.cn\/index.php\/wp-json\/wp\/v2\/tags?post=70"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}