abstractvision 0.2.3

Model-agnostic generative vision abstractions (image/video) for the Abstract ecosystem

AbstractVision

Model-agnostic generative vision API (images, optional video) for Python and the Abstract* ecosystem.

What you get

• A small orchestration API: VisionManager
• A packaged capability registry (“what models can do”): VisionModelCapabilitiesRegistry backed by vision_model_capabilities.json
• Optional artifact-ref outputs (small JSON refs): LocalAssetStore and RuntimeArtifactStoreAdapter
• Built-in backends (execution engines): src/abstractvision/backends/
  • OpenAI-compatible HTTP: openai_compatible.py
  • Local Diffusers: huggingface_diffusers.py
  • Local stable-diffusion.cpp / GGUF: stable_diffusion_cpp.py
• CLI/REPL for manual testing: abstractvision
• Optional static Playground UI (server-backed): playground/vision_playground.html (docs: playground/README.md)

How it fits together (diagram)

flowchart LR
  Caller[Python / CLI / AbstractCore] --> VM[VisionManager]
  VM --> BE[VisionBackend]
  BE --> VM
  VM -->|optional| Store[MediaStore]
  Store --> Ref[Artifact ref dict]
  VM -->|no store| Asset["GeneratedAsset (bytes + mime)"]

Status (current backend support)

• Development status: Alpha (0.x). The public API is stable-by-design, but breaking changes may still happen and will be called out in CHANGELOG.md.
• Built-in backends implement: text_to_image and image_to_image.
• Video (text_to_video, image_to_video) is supported only via the OpenAI-compatible backend when endpoints are configured.
• multi_view_image is part of the public API (VisionManager.generate_angles) but no built-in backend implements it yet.

Details: docs/reference/backends.md.

Installation

pip install abstractvision

Note (CUDA): on Windows/Linux, pip install abstractvision may install a CPU-only PyTorch build. If you want to use an NVIDIA GPU, install a CUDA-enabled PyTorch build first (see https://pytorch.org/get-started/locally/) and verify torch.cuda.is_available() is True.

Install optional integrations:

pip install "abstractvision[abstractcore]"

If you hit “missing pipeline class” errors for newer model families, see docs/getting-started.md. In that case you may need Diffusers from source (main):

pip install -U "abstractvision[huggingface-dev]"
pip install -U "git+https://github.com/huggingface/diffusers@main"

For local dev (from a repo checkout):

pip install -e .

Usage

Start here:

• Getting started: docs/getting-started.md
• FAQ: docs/faq.md
• API reference: docs/api.md
• Architecture: docs/architecture.md
• Docs index: docs/README.md

Recommended default model (local / cross-platform)

The REPL defaults to a cache-only Diffusers setup using runwayml/stable-diffusion-v1-5 on auto device. Pre-download the model outside the REPL, then start generating:

huggingface-cli download runwayml/stable-diffusion-v1-5
export ABSTRACTVISION_BACKEND=diffusers
export ABSTRACTVISION_MODEL_ID=runwayml/stable-diffusion-v1-5
export ABSTRACTVISION_DIFFUSERS_DEVICE=auto
abstractvision repl

For a fresh cache, you can also permit the REPL to download missing files:

ABSTRACTVISION_DIFFUSERS_ALLOW_DOWNLOAD=1 abstractvision repl

More recommendations by VRAM: docs/getting-started.md.

Capability-driven model selection

from abstractvision import VisionModelCapabilitiesRegistry

reg = VisionModelCapabilitiesRegistry()
assert reg.supports("runwayml/stable-diffusion-v1-5", "text_to_image")

print(reg.list_tasks())
print(reg.models_for_task("text_to_image"))

Backend wiring + generation (artifact outputs)

The default install is “batteries included” (Torch + Diffusers + stable-diffusion.cpp python bindings), but heavy modules are imported lazily (see src/abstractvision/backends/__init__.py).

from abstractvision import LocalAssetStore, VisionManager, VisionModelCapabilitiesRegistry, is_artifact_ref
from abstractvision.backends import OpenAICompatibleBackendConfig, OpenAICompatibleVisionBackend

reg = VisionModelCapabilitiesRegistry()

backend = OpenAICompatibleVisionBackend(
    config=OpenAICompatibleBackendConfig(
        base_url="http://localhost:1234/v1",
        api_key="YOUR_KEY",      # optional for local servers
        model_id="REMOTE_MODEL", # optional (server-dependent)
    )
)

vm = VisionManager(
    backend=backend,
    store=LocalAssetStore(),         # enables artifact-ref outputs
    model_id="zai-org/GLM-Image",    # optional: capability gating
    registry=reg,                   # optional: reuse loaded registry
)

out = vm.generate_image("a cinematic photo of a red fox in snow")
assert is_artifact_ref(out)
print(out)  # {"$artifact": "...", "content_type": "...", ...}

png_bytes = vm.store.load_bytes(out["$artifact"])  # type: ignore[union-attr]

When installed next to AbstractCore, AbstractVision is also discovered as a llm.vision capability plugin. The plugin defaults to the same local Diffusers Stable Diffusion 1.5 setup as the REPL; set ABSTRACTVISION_BACKEND=openai and ABSTRACTVISION_BASE_URL when you want the plugin to call an OpenAI-compatible image endpoint instead.

Interactive testing (CLI / REPL)

abstractvision models
abstractvision tasks
abstractvision show-model runwayml/stable-diffusion-v1-5

abstractvision repl

Inside the REPL:

/t2i "a watercolor painting of a lighthouse" --width 512 --height 512 --steps 10 --open

For a newer but still relatively small local model, try black-forest-labs/FLUX.2-klein-4B after installing Diffusers from source (see docs/getting-started.md):

/backend diffusers black-forest-labs/FLUX.2-klein-4B mps float16
/t2i "a product photo of a matte black espresso machine" --steps 4 --guidance-scale 1.0 --open

OpenAI-compatible server example:

/backend openai http://localhost:1234/v1
/t2i "a watercolor painting of a lighthouse" --width 512 --height 512 --steps 10 --open

The CLI/REPL can also be configured via ABSTRACTVISION_* env vars; see docs/reference/configuration.md.

One-shot commands (OpenAI-compatible HTTP backend only):

abstractvision t2i --base-url http://localhost:1234/v1 "a studio photo of an espresso machine"
abstractvision i2i --base-url http://localhost:1234/v1 --image ./input.png "make it watercolor"

Local GGUF via stable-diffusion.cpp

If you want to run GGUF diffusion models locally, use the stable-diffusion.cpp backend (sdcpp). Start with a single-file Stable Diffusion model when possible; Qwen Image and FLUX GGUF component sets are heavier.

Recommended:

• macOS (Apple Silicon / Metal): install sd-cli (stable-diffusion.cpp executable) from releases and use CLI mode for Metal acceleration.
• Otherwise (pip-only convenience): pip install abstractvision already includes the stable-diffusion.cpp python bindings (stable-diffusion-cpp-python), but this may run CPU-only depending on the wheel build.

Alternative (external executable):

• Install sd-cli: https://github.com/leejet/stable-diffusion.cpp/releases

In the REPL:

/backend sdcpp /path/to/sd-v1-5.gguf /path/to/sd-cli
/t2i "a watercolor painting of a lighthouse" --width 512 --height 512 --steps 10 --open

FLUX.2-klein-4B GGUF component example:

/backend sdcpp /path/to/flux-2-klein-4b-Q8_0.gguf /path/to/flux2_ae.safetensors /path/to/Qwen3-4B-Q4_K_M.gguf /path/to/sd-cli
/t2i "a product photo of a matte black espresso machine" --steps 4 --guidance-scale 1.0 --sampling-method euler --diffusion-fa --offload-to-cpu --open

Extra flags are forwarded via request.extra. In CLI mode they are forwarded to sd-cli; in python bindings mode, keys are mapped to python binding kwargs when supported and unsupported keys are ignored.

AbstractCore tool integration (artifact refs)

If you’re using AbstractCore tool calling, AbstractVision can expose vision tasks as tools:

from abstractvision.integrations.abstractcore import make_vision_tools

tools = make_vision_tools(vision_manager=vm, model_id="zai-org/GLM-Image")

AbstractFramework ecosystem

AbstractVision is part of the AbstractFramework ecosystem and is designed to compose with:

• AbstractFramework (project hub): https://github.com/lpalbou/AbstractFramework
• AbstractCore (orchestration + tool calling): https://github.com/lpalbou/abstractcore
• AbstractRuntime (runtime services, including artifact storage): https://github.com/lpalbou/abstractruntime

In practice:

• AbstractVision standardizes generative vision outputs (image/video) behind VisionManager.
• AbstractCore can discover and use AbstractVision via the capability plugin (src/abstractvision/integrations/abstractcore_plugin.py) or you can expose vision tasks as tools (src/abstractvision/integrations/abstractcore.py).
• Artifact refs returned by AbstractVision are designed to travel across processes; RuntimeArtifactStoreAdapter bridges to an AbstractRuntime-style artifact store (src/abstractvision/artifacts.py).

Project

• Release notes: CHANGELOG.md
• Contributing: CONTRIBUTING.md
• Security: SECURITY.md
• Acknowledgments: ACKNOWLEDGMENTS.md
• Agent docs: llms.txt and llms-full.txt

Requirements

• Python >= 3.9

License

MIT License - see LICENSE file for details.

Author

Laurent-Philippe Albou

Contact

[e-mail]