ChimeraForge

Chimeraforge

A local-first, model-agnostic LLM deployment planner. It turns "which model, quantization, GPU, and backend -- how many, will it fit, will it hit my SLO, what will it cost" into a fast answer with explicit evidence and assumptions, from your shell, your Python, or your AI assistant.

uvx chimeraforge plan --model-size 8b --hardware "RTX 4090 24GB"

The trust principle

Since 0.96.0, serving quote budget checks compare dated whole-instance prices to an exact monthly USD cap.

Since 0.95.0, passive fleet reports render an existing receipt against its original plan in Markdown or HTML.

Since 0.94.0, read-only Kubernetes inspection accepts an operator serving declaration directly and retains every declared resource.

Since 0.93.0, offline inventory arithmetic checks a saved plan against a supplied NVIDIA CSV without a local GPU query.

Included in 0.92.0

• Continuous fleet export serves cached native gauges on loopback, with all-member freshness and failure views and owned shutdown. Scrapes make no backend calls.
• Whole-campaign diagnostics render complete native campaigns as HTML, SVG or Markdown, retaining every execution, original member and unknown value.
• Native chat trace replay preserves ordered role histories across ordinary, saved-plan, fleet and campaign paths. Missing native usage stays unknown.
• Operator-authored serving declarations capture concrete intent, quote dated whole instances and check native configuration without optimizer predictions.
• Selected-batch inventory preflight adds the saved active-sequence KV increment to the saved batch-one interval for each original device.

Every number is labeled `measured`, `extrapolated`, `derived`, `estimated`, or `unknown`, and the tool refuses to fake the ones it can't stand behind. VRAM and KV-cache are derived -- exact arithmetic over the model's real architecture, not a measurement. Throughput is a measured lookup only on the rig the corpus was measured on; on any other GPU that row is scaled by memory bandwidth and reported as extrapolated, carrying the row it came from, the rig it was measured on and the ratio applied, because a 17.8x bandwidth extrapolation (RTX 4080 Laptop 432 GB/s -> B200 7700 GB/s) is not a measurement of your card. Failing that it is an explicit roofline estimate -- never presented as data it isn't. Quality below the bundled corpus reports unknown, not a made-up score. A 0-result plan names the exact gate that rejected every candidate instead of a generic "nothing found." No telemetry, no phone-home, works air-gapped.

Give it a model -- a size class, a Hugging Face repo, an Ollama tag, or manual overrides for an unreleased model -- and it searches the (model x quantization x backend x GPU count x tensor/pipeline parallelism) space against VRAM, quality, latency, cost, energy, and an opt-in safety gate, then hands back the cheapest config that meets your SLO.

34 commands, one tool: plan - check - bundle - study - serving - deploy - deploy-verify - deploy-inspect - inventory-check - suggest - measure - workload - monitor - monitor-fleet - monitor-fleet-exporter - validate - doctor - contribute - catalog - safety - bench - trace - trace-fleet - trace-fleet-campaign - trace-campaign - trace-envelope - score - gate - eval - compare - refit - report - mcp - serve. This is the command set for Chimeraforge 0.96.0.

The empirical corpus traces to Technical Reports TR108-TR137 (~204,000 real measurements on consumer GPUs). See the CHANGELOG for the full feature history.

What the planner itself reads. The ~204,000 measurements are the research program's total across its reports. The tables plan looks numbers up in are far smaller:

Anything outside those rows is extrapolated (scaled by memory bandwidth from the reference GPU), derived (exact arithmetic) or estimated (roofline), and every number in a plan says which. The data records its own limits:

• Every throughput row is FP16. Quantized throughput is the FP16 row times a quant multiplier, not a measurement of that quant.
• Every row was measured on one GPU. Other hardware is bandwidth-extrapolated and labelled 'extrapolated', not 'measured'.
• The largest model measured is 3.21B; predictions above that extrapolate the power law.
• No SGLang rows exist; that backend falls through to the fp16/power-law path.

---

Install

Try it with no install:

uvx chimeraforge plan --model-size 8b --hardware "RTX 4090 24GB"

pipx run chimeraforge plan --model-size 8b --hardware "RTX 4090 24GB"

Install for real:

pip install chimeraforge            # planner + model resolution (HF/Ollama) + suggest/measure/safety/bench

pip install "chimeraforge[bench]" # + GPU environment metadata for benchmarks (pynvml) pip install "chimeraforge[mcp]" # + MCP server so Claude/GPT/Cursor can call the planner pip install "chimeraforge[eval]" # + quality evaluation (ROUGE-L; BERTScore additionally needs bert-score + torch) pip install "chimeraforge[refit]" # + coefficient refitting (numpy, scipy) pip install "chimeraforge[all]" # everything

Python 3.11+ (since 0.82.0; the patched filelock dependency requires it). The core install covers the planner and network-facing commands (httpx is a core dep). Registry planning and the local catalog work offline; HF/Ollama resolution or discovery needs explicit network access. bench / measure / safety need a running backend (Ollama, vLLM, TGI, or SGLang; safety supports Ollama only). Windows / macOS / Linux.

Release scope. Chimeraforge 0.96.0 adds budget checks for dated serving quotes. It includes static passive fleet reports from 0.95.0, declaration-based Kubernetes inspection from 0.94.0, offline inventory arithmetic from 0.93.0 and the five workflows introduced in 0.92.0.

pip install "chimeraforge[mcp]==0.96.0"

Inventory arithmetic (since 0.77.0): inventory-check and async api.check_inventory check all original ordered GPU selectors and reported-free memory against a saved per-GPU batch-one baseline. Every result keeps deployment_ready: null; MIG status and UUIDs do not establish physical independence, allocation or runtime fit. See the complete inventory contract.

Secure monitoring (since 0.78.0): verified HTTPS, named-environment bearer and optional client certificates now cover standalone/saved/fleet metrics and every metadata bracket. Credentials stay runtime-only and per endpoint. See secure monitoring.

Quickstart

# Plan a registry size class on your GPU

chimeraforge plan --model-size 8b --hardware "RTX 4090 24GB" --request-rate 2.0

Plan ANY model -- a Hugging Face repo or an Ollama tag

chimeraforge plan --model Qwen/Qwen2.5-7B-Instruct --hardware "RTX 4090 24GB" chimeraforge plan --model ollama:qwen3:14b --ollama-url http://localhost:11434

Split a model too big for one GPU across several (tensor parallelism)

chimeraforge plan --model Qwen/Qwen2.5-72B-Instruct --hardware "H100 80GB" --tp 4

Shrink the KV-cache, print the cost/latency/quality trade-off menu

chimeraforge plan --model-size 8b --hardware "RTX 4080 12GB" --kv-quant q8 --pareto

Benchmark a live model and plan on the MEASURED numbers

chimeraforge plan --model qwen3:14b --measure

Discover + rank what fits your GPU and budget

chimeraforge suggest --source ollama --hardware "RTX 4090 24GB" --budget 500

Save and recheck an offline plan

chimeraforge plan --model-size 3b --hardware "RTX 4090 24GB" --no-network --save offline-plan.json chimeraforge check offline-plan.json --json

Keep one Hub checkpoint through planning and export

# Metadata/config only: no model weights are downloaded by the planner

chimeraforge plan --model HuggingFaceTB/SmolLM2-135M-Instruct \ --revision 12fd25f77366fa6b3b4b768ec3050bf629380bac \ --hardware "RTX 4080 12GB" --platform linux --request-rate 0.01 \ --quality-target 0 --budget 100000 --save checkpoint-plan.json --json chimeraforge check checkpoint-plan.json --json # offline chimeraforge check checkpoint-plan.json --network --json # explicit Hub inspection

Branches and tags are accepted too; resolution first establishes one immutable commit, then reads that commit's config and declared file metadata. Repeat --revision MODEL=REF when planning multiple HF models. A cached moving ref is a dated producing observation, not proof of its current state.

Select a supported saved candidate before deployment export. vLLM, TGI and SGLang commands carry --revision with the resolved commit; an Ollama conversion cannot retain that pin and is refused. The receipt hashes the config bytes actually consumed and records declared weight metadata. It does not verify downloaded weight/tokenizer bytes or identify a running server. Legacy plans still load with their original identity gaps. See the Python checkpoint loop.

---

Plan with your traffic, not your guesses

chimeraforge workload --from-log requests.jsonl --out workload.json

chimeraforge plan --model-size 8b --hardware "RTX 4090 24GB" --workload-profile workload.json

Derives the request rate, prompt and output lengths, traffic variance and prefix-cache hit rate from a request log or a live vLLM/SGLang /metrics endpoint. The variance one matters most: plan otherwise takes it as one of four presets, and it drives the whole queueing tail.

Metric names are per-engine and explicit -- vLLM has renamed two of these between versions, and a scraper that silently falls back to a stale name reports a fabricated measurement. An unknown engine is an error, and a field the source did not expose stays absent rather than acquiring a default.

Decision briefs

chimeraforge plan --model-size 8b --hardware "RTX 4090 24GB" --request-rate 2 --report brief.md

Writes a markdown record of the decision: the recommendation, every assumption as an input rather than a finding, the alternatives table, the planner's warnings verbatim, and the exact comma