Gpt 6 Astra

Astra is a catalogue name, not a model card

It's a GPT 6-family text model that KIE.ai resells, wrapped as a ComfyUI node in KIE Next/LLM/OpenAI/GPT. Text in, text out, network call out, per-call billing, nothing on your GPU.

Two honesties before the how-to. First, the odd capitalisation in the menu - "Gpt 6 Astra" next to "GPT 6 Luna" - isn't a typo: the pack builds display names from KIE's own documentation titles, and the reseller isn't consistent about them. Second, "Astra" is a name the reseller uses. There's no spec sheet to consult, no published ranking against Sol or Luna, and nobody on a forum who's benchmarked it for you. Which means the only meaningful review of Astra is the one you run.

Where it fits in a workflow, and where it doesn't

The realistic use is a text stage: expand a thin prompt before a local sampler, caption an image you've wired into the images input, or produce structured output - a list of variations, a JSON object of prompt fields - that a downstream node parses.

Now the part nobody selling an API node says: for plain prompt rewriting, a small local LLM is enough, and it's free, instant, offline and uncensored. Hosted frontier text is what you buy when the writing itself is the hard part - convoluted multi-constraint briefs, difficult phrasing, output that must parse on the first attempt - or when you have no GPU headroom for yet another model. Paying per call to prettify "cat, sunset, 50mm" is a waste of money.

How the pack handles it

Nodes are generated at server startup from KIE's published API documentation, so the class name is derived: KIE_Next_Gpt_6_Astra_3ac2c03c - slug plus an eight-character hash of the operation and model, kept stable so saved workflows survive pack updates.

Unlike the pack's image and video nodes, which submit a task and poll until it finishes, these LLM nodes use a direct transport: one HTTP request to the documented endpoint and one response back. The pack pulls the assistant text out of that response and returns it as a STRING, keeping the untouched payload in raw_json.

Controls worth your attention

prompt is the required field. system_prompt is the one that decides whether you get a prompt or a lecture; "output only the final prompt, no explanation" does more for output quality than switching models.

reasoning_effort - low, medium, high, xhigh - defaults to high, which is intentionally slow and token-hungry. For rewriting, drop to medium; the difference you'll notice is latency, not prose. max_output_tokens spans 1 to 131072, default 4096, and truncation is silent: a cap that's too low shows up as a suspiciously terse answer rather than an error.

images is one optional IMAGE socket, uploaded for you - that's your captioning route. web_search toggles KIE's web-search tool where the endpoint supports it, useful for prompts referencing real objects, places or cameras. tools_json is for tool definitions; history_json is a JSON array of prior messages, and since the node retains nothing between runs, it's the only way to carry context. expert_override_json merges raw JSON into the request for anything the pack doesn't surface.

Outputs

text goes into your graph. raw_json is your debugging window when output looks wrong. usage_json gives token accounting - comparing it across two runs tells you whether a reasoning setting earned its keep. credits_consumed and credits_left show the spend, and both are also printed on the node as a receipt after each successful run, which is genuinely handy when a batch is quietly expensive.

Install

cd ComfyUI/custom_nodes
git clone https://github.com/felipederosilva/ComfyUI-KIE-Nodes-Next
pip install -r requirements.txt

Restart ComfyUI, then set your key once at Settings → KIE.ai Nodes Next → Connection → Paste / replace KIE.ai API key. It's checked against KIE before overwriting a working key, and only a masked fingerprint is displayed afterwards. Servers can set KIE_API_KEY instead - it takes priority over the saved key. Dependencies: requests, Pillow, numpy, PyYAML; the LLM nodes add nothing and download nothing. Registry/Manager publishing is described in the README as "prepared," so a Manager search that finds nothing means you clone it (or drop a ZIP from dist/ into custom_nodes).

Choosing between this and its siblings

The pack generates a whole row of near-identical GPT nodes from the same documentation. Pick by measurement, not by version number:

1. Run the same awkward prompt through Astra and one older sibling.
2. Compare the returned text.
3. Compare token counts in usage_json and spend in credits_consumed.

If the older model holds up, you've saved yourself a permanent upgrade - and if Astra clearly wins on the prompts you actually write, you've learned something concrete instead of trusting a product name. While you're comparing, check the widget lists too: not every node in this family exposes the same controls (the older chat-style GPT 5.2 has no max_output_tokens at all), so if output length control matters, confirm it exists before you rewire a workflow around it.