# How to Use ODS for Image Generation: Stable Diffusion and ComfyUI Setup

> Learn to use ODS for image generation with Stable Diffusion and ComfyUI. Set up AI services locally via convenient REST APIs without manual port configuration. Get started with Osmantic/ODS today.

- Repository: [Osmantic/ODS](https://github.com/Osmantic/ODS)
- Tags: how-to-guide
- Published: 2026-09-01

---

**ODS (Open-Source Distributed Stack) provides containerized AI services for local image generation through extensions like Stable Diffusion Forge and ComfyUI, exposing stable REST APIs on localhost without requiring manual port configuration.**

ODS (Open-Source Distributed Stack) simplifies local AI deployment by orchestrating containerized services through Docker Compose. When using ODS for image generation, you can choose between **Stable Diffusion Forge** and **ComfyUI** extensions, both delivering version-agnostic APIs that remain stable across releases. This guide walks through the complete setup process—from installation to API calls—using the actual source implementation in the Osmantic/ODS repository.

## Understanding the ODS Architecture for Image Generation

ODS builds its runtime environment from a base compose file ([`ods/docker-compose.base.yml`](https://github.com/Osmantic/ODS/blob/main/ods/docker-compose.base.yml)) merged with GPU-specific overlays (e.g., [`ods/docker-compose.amd.yml`](https://github.com/Osmantic/ODS/blob/main/ods/docker-compose.amd.yml)). Each image generation extension contributes its own compose fragment, such as [`ods/extensions/services/forge/compose.yaml`](https://github.com/Osmantic/ODS/blob/main/ods/extensions/services/forge/compose.yaml) for Stable Diffusion Forge or [`ods/extensions/services/comfyui/compose.yaml`](https://github.com/Osmantic/ODS/blob/main/ods/extensions/services/comfyui/compose.yaml) for ComfyUI.

The system creates a unified Docker network named `ods` that allows seamless inter-service communication. When enabled, these services expose REST endpoints on localhost without additional port-forwarding, with API contracts defined in their respective manifest files ([`manifest.yaml`](https://github.com/Osmantic/ODS/blob/main/manifest.yaml)).

## Installing and Enabling Image Generation Services

### Installing ODS

Begin by running the platform-specific installer script ([`install.sh`](https://github.com/Osmantic/ODS/blob/main/install.sh) for Linux/macOS or `install.ps1` for Windows). The installer automatically detects your GPU tier and selects the appropriate Docker overlay to ensure proper CUDA or ROCm support. This phase establishes the base infrastructure in [`ods/docker-compose.base.yml`](https://github.com/Osmantic/ODS/blob/main/ods/docker-compose.base.yml) before any image generation capabilities are added.

### Enabling Extensions

Activate your preferred image generation backend using the CLI or Dashboard UI:

- **Stable Diffusion Forge**: Run `ods enable forge` or select *Stable Diffusion Forge* in Extensions → Dashboard UI
- **ComfyUI**: Run `ods enable comfyui` via CLI

Enabling an extension copies its compose fragment into the active stack. The manifest files at [`ods/extensions/services/forge/manifest.yaml`](https://github.com/Osmantic/ODS/blob/main/ods/extensions/services/forge/manifest.yaml) and [`ods/extensions/services/comfyui/manifest.yaml`](https://github.com/Osmantic/ODS/blob/main/ods/extensions/services/comfyui/manifest.yaml) define the service metadata, default ports, and health check endpoints.

## Starting the Stack and Verifying Health

Launch the containers with:

```bash
ods up

```

Alternatively, use the standard Docker Compose command:

```bash
docker compose up -d

```

The installer executes a health-check phase defined in [`ods/installers/phases/12-health.sh`](https://github.com/Osmantic/ODS/blob/main/ods/installers/phases/12-health.sh) to verify that image generation services are reachable before completing installation. This ensures the containers are fully initialized before accepting API requests.

## Generating Images via the REST API

ODS exposes stable, version-agnostic endpoints that follow the de-facto standard stable-diffusion API specification. Because services run inside the `ods` Docker network with published ports, you can reach them directly on `localhost`.

### Using Stable Diffusion Forge

The Forge service runs on port **7860** and provides the standard `/sdapi/v1/txt2img` endpoint. The container uses the image `ghcr.io/ai-dock/stable-diffusion-webui-forge` with GPU acceleration configured through the compose overlay.

Send a text-to-image request to:

```

http://localhost:7860/sdapi/v1/txt2img

```

Additional endpoints include `/sdapi/v1/img2img` for image-to-image generation and `/sdapi/v1/options` for configuration management, as documented in the upstream project.

### Using ComfyUI

ComfyUI operates on port **8188** using the image `ghcr.io/comfyanonymous/ComfyUI:latest`. Unlike Forge, ComfyUI accepts prompt graphs via the `/prompt` endpoint:

```

http://localhost:8188/prompt

```

This endpoint expects JSON payloads containing node-based workflow definitions rather than simple parameter objects.

## Complete Code Examples

### cURL Examples

Generate an image with Stable Diffusion Forge:

```bash
curl -X POST http://localhost:7860/sdapi/v1/txt2img \
  -H "Content-Type: application/json" \
  -d '{
        "prompt":"a futuristic city at sunrise, ultra-realistic",
        "steps":30,
        "cfg_scale":7,
        "width":512,
        "height":512,
        "sampler_name":"Euler a"
      }' \
  --output output.png

```

For ComfyUI, send a prompt graph:

```bash
curl -X POST http://localhost:8188/prompt \
  -H "Content-Type: application/json" \
  -d '{
        "prompt": [
          {"type":"KSampler","inputs":{"seed":12345,"steps":30,"cfg":7,"sampler_name":"euler_a"}},
          {"type":"CLIPTextEncode","inputs":{"text":"a dreamy forest with mist"}}
        ]
      }' \
  --output comfy_output.png

```

### Python Examples

Generate images programmatically with Forge:

```python
import requests

payload = {
    "prompt": "a cyberpunk street, neon lights, detailed",
    "steps": 25,
    "cfg_scale": 8,
    "width": 512,
    "height": 512,
    "sampler_name": "Euler a"
}

resp = requests.post(
    "http://localhost:7860/sdapi/v1/txt2img",
    json=payload,
    timeout=120
)
resp.raise_for_status()

with open("generated.png", "wb") as f:
    f.write(resp.content)

```

## Summary

- ODS for image generation relies on **Docker Compose** fragments defined in [`ods/extensions/services/forge/compose.yaml`](https://github.com/Osmantic/ODS/blob/main/ods/extensions/services/forge/compose.yaml) and [`ods/extensions/services/comfyui/compose.yaml`](https://github.com/Osmantic/ODS/blob/main/ods/extensions/services/comfyui/compose.yaml)
- Enable services via `ods enable forge` or `ods enable comfyui`, then start with `ods up`
- The installer validates health through [`ods/installers/phases/12-health.sh`](https://github.com/Osmantic/ODS/blob/main/ods/installers/phases/12-health.sh) before completing
- **Stable Diffusion Forge** exposes `/sdapi/v1/txt2img` on port 7860, while **ComfyUI** uses `/prompt` on port 8188
- Both services maintain **stable API contracts** across releases, ensuring scripts remain compatible with future model updates

## Frequently Asked Questions

### What GPU support does ODS provide for image generation?

ODS automatically detects your hardware tier during installation and applies the appropriate Docker overlay, such as [`ods/docker-compose.amd.yml`](https://github.com/Osmantic/ODS/blob/main/ods/docker-compose.amd.yml) for AMD GPUs or NVIDIA CUDA configurations. The compose fragments in [`ods/extensions/services/forge/compose.yaml`](https://github.com/Osmantic/ODS/blob/main/ods/extensions/services/forge/compose.yaml) mount the correct drivers and runtime libraries for your specific GPU architecture.

### How do I switch between Stable Diffusion Forge and ComfyUI?

You can enable both services simultaneously since they operate on different ports (7860 and 8188 respectively). Use `ods enable forge` and `ods enable comfyui` to activate each extension, then run `ods up` to rebuild the stack. The unified `ods` network allows both services to coexist without port conflicts.

### Does ODS modify the upstream API endpoints?

No, ODS does not modify the upstream API contracts. The services expose endpoints exactly as implemented in their respective projects (e.g., `/sdapi/v1/txt2img` for Forge). ODS only guarantees network stability and container orchestration, ensuring endpoints remain reachable on `localhost` without manual port-forwarding configuration.

### Where are the manifest files located for image generation services?

Each extension stores its metadata in a [`manifest.yaml`](https://github.com/Osmantic/ODS/blob/main/manifest.yaml) file. For Stable Diffusion Forge, this is [`ods/extensions/services/forge/manifest.yaml`](https://github.com/Osmantic/ODS/blob/main/ods/extensions/services/forge/manifest.yaml). For ComfyUI, it is [`ods/extensions/services/comfyui/manifest.yaml`](https://github.com/Osmantic/ODS/blob/main/ods/extensions/services/comfyui/manifest.yaml). These files define service IDs, exposed ports, GPU overlay requirements, and health check endpoints used by the installer.