port verified llama.cpp CPU proxy: LFM2.5-VL-1.6B vision via mmproj, native OpenAI multimodal API, prebuilt binary

Dockerfile

@@ -1,19 +1,50 @@
-FROM python:3.9-slim
+# Ubuntu 24.04 base to match the glibc of the official llama.cpp release binary.
+FROM ubuntu:24.04
 
-WORKDIR /app
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y \
+    curl \
+    ca-certificates \
+    libgomp1 \
+    libcurl4 \
+    python3 \
+    python3-pip \
+    && rm -rf /var/lib/apt/lists/*
 
-# Install dependencies
-COPY requirements.txt requirements.txt
-RUN pip install --no-cache-dir --default-timeout=100 --retries=5 -r requirements.txt
+RUN pip install --no-cache-dir --break-system-packages \
+    fastapi \
+    uvicorn \
+    httpx \
+    huggingface_hub
 
-ENV HF_HOME=/app/.cache
-RUN mkdir -p $HF_HOME && chown -R 1000:1000 $HF_HOME
+# ---------------------------------------------------------------------------
+# Prebuilt llama.cpp CPU server (includes libmtmd -> vision support). No source
+# compile: avoids the multimodal OOM that hangs a from-source build on 2 vCPUs.
+# Ships per-microarch CPU variants selected at runtime -> portable & safe.
+# ---------------------------------------------------------------------------
+ARG LLAMA_TAG=b9895
+RUN mkdir -p /llama.cpp/build/bin \
+    && curl -fsSL -o /tmp/llama.tar.gz \
+       "https://github.com/ggml-org/llama.cpp/releases/download/${LLAMA_TAG}/llama-${LLAMA_TAG}-bin-ubuntu-x64.tar.gz" \
+    && tar -xzf /tmp/llama.tar.gz -C /llama.cpp/build/bin --strip-components=1 \
+    && rm /tmp/llama.tar.gz \
+    && chmod +x /llama.cpp/build/bin/llama-server \
+    && /llama.cpp/build/bin/llama-server --version 2>&1 | head -5
+
+ENV LD_LIBRARY_PATH=/llama.cpp/build/bin
+
+WORKDIR /app
+
+# Models (text GGUF + mmproj projector) are pulled at container startup by app.py.
+RUN mkdir -p /models && chmod -R 777 /models
 
-# Copy the app files
 COPY . .
 
-# Expose the port
-EXPOSE 7860
+EXPOSE 7860 8081
+
+# Vision model + projector are small (~1.5GB total); start-period covers download.
+HEALTHCHECK --interval=30s --timeout=10s --start-period=300s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
 
-# START THE SERVER (This line is critical!)
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["python3", "app.py"]

README.md

@@ -1,13 +1,74 @@
 ---
-title: Phi 3.5 & Chatbot & Vision App
-emoji: 🦋🦋🦋
+title: LFM2.5-VL 1.6B Vision Inference (CPU)
+emoji: 🦋
 colorFrom: purple
 colorTo: indigo
-sdk: gradio
-sdk_version: 4.42.0
-app_file: app.py
+sdk: docker
+app_port: 7860
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LFM2.5-VL 1.6B Vision Inference API (CPU)
+
+CPU-only **vision-language** inference using `llama.cpp` behind a thin FastAPI
+reverse proxy that speaks the **native OpenAI API** — including multimodal
+`image_url` inputs, streaming, and the model's real chat template.
+
+**Model**: [`LiquidAI/LFM2.5-VL-1.6B-GGUF`](https://huggingface.co/LiquidAI/LFM2.5-VL-1.6B-GGUF)
+(Q4_0 text model + Q8_0 `mmproj` vision projector).
+
+## Why this design
+
+Ported from the verified `gemma-inference` pattern:
+- **Prebuilt llama.cpp CPU binary** (no source compile → no multimodal-build OOM);
+  the release ships `libmtmd` so **vision works out of the box** via `--mmproj`.
+- **One instance, all cores**, concurrency via continuous-batching slots.
+- **Native OpenAI passthrough** — send images as `image_url` data-URIs; llama.cpp
+  handles the CLIP encode + chat template. Streaming supported.
+- Runtime CPU-variant dispatch → portable and safe on `cpu-basic`.
+
+## Usage
+
+### Describe an image (OpenAI multimodal format)
+```bash
+IMG_B64=$(base64 -w0 photo.jpg)
+curl -X POST https://Leon4gr45-phi-inference.hf.space/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"model\": \"lfm2.5-vl-1.6b\",
+    \"messages\": [{\"role\":\"user\",\"content\":[
+      {\"type\":\"text\",\"text\":\"Describe this image.\"},
+      {\"type\":\"image_url\",\"image_url\":{\"url\":\"data:image/jpeg;base64,${IMG_B64}\"}}
+    ]}],
+    \"max_tokens\": 256
+  }"
+```
+
+### Text-only chat also works
+```bash
+curl -X POST https://Leon4gr45-phi-inference.hf.space/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{"model":"lfm2.5-vl-1.6b","messages":[{"role":"user","content":"Hello"}],"max_tokens":64}'
+```
+
+### Health / config
+```bash
+curl https://Leon4gr45-phi-inference.hf.space/health     # "vision": true when mmproj loaded
+curl https://Leon4gr45-phi-inference.hf.space/v1/config
+```
+
+## Configuration (env vars)
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MODEL_FILENAME` | `LFM2.5-VL-1.6B-Q4_0.gguf` | text GGUF in the repo |
+| `MMPROJ_FILENAME` | `mmproj-LFM2.5-VL-1.6b-Q8_0.gguf` | vision projector |
+| `CPU_THREADS` | all vCPUs | generation threads |
+| `PARALLEL` | `2` | continuous-batching slots |
+| `CONTEXT_SIZE` | `8192` | total context (includes image tokens) |
+| `KV_CACHE_QUANT` | `q8_0` | KV cache type |
+| `FLASH_ATTN` | `true` | flash attention |
+
+## License
+MIT

app.py

@@ -1,73 +1,343 @@
 import os
-import torch
-from fastapi import FastAPI, UploadFile, File, Depends
-from pydantic import BaseModel
-from transformers import AutoTokenizer, AutoModel
-from PIL import Image
-from typing import Optional
-import io
-
-app = FastAPI()
-
-model_id = "OpenGVLab/InternVL2_5-2B"
-device = "cpu"
-
-# Global variables for the model, initially empty
-model = None
-tokenizer = None
-
-def load_model_if_needed():
-    global model, tokenizer
-    if model is None:
-        print("Loading model... this may take a moment.")
-        
-        # Load Tokenizer
-        tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
-        
-        # Load Model
-        # We use bfloat16 to save memory (5GB vs 10GB)
-        # We use low_cpu_mem_usage to load efficiently
-        model = AutoModel.from_pretrained(
-            model_id, 
-            trust_remote_code=True, 
-            torch_dtype=torch.bfloat16, 
-            low_cpu_mem_usage=True
-        ).to(device).eval()
-        
-        print("Model loaded successfully!")
-
-class GenerateRequest(BaseModel):
-    text_input: Optional[str] = None
-    max_new_tokens: int = 1024
-    do_sample: bool = False
-
-@app.post("/generate")
-async def generate(image: UploadFile = File(...), request: GenerateRequest = Depends()):
-    # 1. Trigger the load on the first request
-    load_model_if_needed()
-
-    # Read image
-    image_bytes = await image.read()
-    pil_image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-
-    if request.text_input:
-        prompt = f"<s><image>\n{request.text_input}</s>"
+import subprocess
+import asyncio
+import time
+import threading
+import httpx
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.openapi.docs import get_swagger_ui_html
+from fastapi.responses import JSONResponse, StreamingResponse
+
+app = FastAPI(title="LFM2.5-VL 1.6B Vision Inference API (CPU)", version="2.0.0")
+
+# ---------------------------------------------------------------------------
+# Configuration — LFM2.5-VL-1.6B (vision) via llama.cpp + mmproj projector
+# ---------------------------------------------------------------------------
+MODEL_PATH = os.getenv("MODEL_PATH", "/models/LFM2.5-VL-1.6B-Q4_0.gguf")
+MMPROJ_PATH = os.getenv("MMPROJ_PATH", "/models/mmproj-LFM2.5-VL-1.6b-Q8_0.gguf")
+MODEL_REPO = os.getenv("MODEL_REPO", "LiquidAI/LFM2.5-VL-1.6B-GGUF")
+MODEL_FILENAME = os.getenv("MODEL_FILENAME", "LFM2.5-VL-1.6B-Q4_0.gguf")
+MMPROJ_FILENAME = os.getenv("MMPROJ_FILENAME", "mmproj-LFM2.5-VL-1.6b-Q8_0.gguf")
+MODEL_ALIAS = os.getenv("MODEL_ALIAS", "lfm2.5-vl-1.6b")
+MAIN_PORT = int(os.getenv("MAIN_PORT", "7860"))
+
+NUM_INSTANCES = int(os.getenv("NUM_INSTANCES", "1"))
+BASE_PORT = int(os.getenv("BASE_PORT", "8081"))
+INSTANCE_PORTS = [BASE_PORT + i for i in range(NUM_INSTANCES)]
+INSTANCE_URLS = [f"http://127.0.0.1:{p}" for p in INSTANCE_PORTS]
+MODEL_LOADED = [False] * NUM_INSTANCES
+LLAMA_PROCESSES = [None] * NUM_INSTANCES
+
+_CPU = os.cpu_count() or 4
+CPU_THREADS = int(os.getenv("CPU_THREADS", str(_CPU)))
+CPU_THREADS_BATCH = int(os.getenv("CPU_THREADS_BATCH", str(_CPU)))
+CONTEXT_SIZE = int(os.getenv("CONTEXT_SIZE", "8192"))   # incl. image tokens; per-slot = ctx/parallel
+PARALLEL = int(os.getenv("PARALLEL", "2"))
+BATCH_SIZE = int(os.getenv("BATCH_SIZE", "512"))
+UBATCH_SIZE = int(os.getenv("UBATCH_SIZE", "512"))
+KV_CACHE_QUANT = os.getenv("KV_CACHE_QUANT", "q8_0")    # q8_0 default: safer for VL quality
+_KV_ALIASES = {"2bit": "q4_0", "4bit": "q4_0", "8bit": "q8_0",
+               "16bit": "f16", "fp16": "f16", "q4": "q4_0", "q8": "q8_0"}
+_VALID_KV = {"f16", "q8_0", "q4_0", "q4_1", "q5_0", "q5_1", "iq4_nl"}
+KV_CACHE_QUANT = _KV_ALIASES.get(KV_CACHE_QUANT.lower(), KV_CACHE_QUANT)
+if KV_CACHE_QUANT not in _VALID_KV:
+    KV_CACHE_QUANT = "q8_0"
+FLASH_ATTN = os.getenv("FLASH_ATTN", "true").lower() == "true"
+MMAP_ENABLED = os.getenv("MMAP_ENABLED", "true").lower() == "true"
+MLOCK_ENABLED = os.getenv("MLOCK_ENABLED", "false").lower() == "true"
+
+HTTP: httpx.AsyncClient | None = None
+_rr_counter = 0
+_rr_lock = asyncio.Lock()
+
+print("=" * 60)
+print("LFM2.5-VL 1.6B Vision Inference API (v2.0.0)")
+print(f"  detected vCPUs   : {_CPU}")
+print(f"  model            : {MODEL_PATH}")
+print(f"  mmproj (vision)  : {MMPROJ_PATH}")
+print(f"  threads          : {CPU_THREADS} (batch {CPU_THREADS_BATCH})")
+print(f"  context (total)  : {CONTEXT_SIZE}  parallel slots: {PARALLEL}")
+print(f"  kv-cache quant   : {KV_CACHE_QUANT}   flash-attn: {FLASH_ATTN}")
+print("=" * 60)
+
+
+def _find_binary():
+    for p in ("/llama.cpp/build/bin/llama-server",
+              "/llama.cpp/build/bin/server",
+              "/usr/local/bin/llama-server"):
+        if os.path.exists(p):
+            return p
+    try:
+        found = subprocess.run(["find", "/llama.cpp", "-name", "llama-server"],
+                               capture_output=True, text=True).stdout.strip().split("\n")
+        if found and found[0]:
+            return found[0]
+    except Exception:
+        pass
+    return None
+
+
+def _help_text(binary):
+    try:
+        r = subprocess.run([binary, "--help"], capture_output=True, text=True, timeout=30)
+        return (r.stdout or "") + (r.stderr or "")
+    except Exception:
+        return ""
+
+
+def _download_one(dest_path, filename):
+    if os.path.exists(dest_path):
+        return True
+    print(f"Downloading {filename} from {MODEL_REPO} -> {dest_path} ...")
+    try:
+        from huggingface_hub import hf_hub_download
+        import shutil
+        dl = hf_hub_download(repo_id=MODEL_REPO, filename=filename,
+                             repo_type="model", token=os.getenv("HF_TOKEN"))
+        if dl != dest_path:
+            os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+            shutil.copy2(dl, dest_path)
+        print(f"✅ ready: {dest_path}")
+        return True
+    except Exception as e:
+        print(f"❌ download failed for {filename}: {e}")
+        return False
+
+
+def _download_model():
+    ok = _download_one(MODEL_PATH, MODEL_FILENAME)
+    # mmproj is what enables vision; without it the model is text-only.
+    _download_one(MMPROJ_PATH, MMPROJ_FILENAME)
+    return ok
+
+
+def build_cmd(binary, port, help_text):
+    def has(flag):
+        return flag in help_text
+
+    cmd = [binary,
+           "--model", MODEL_PATH,
+           "--host", "127.0.0.1",
+           "--port", str(port),
+           "--ctx-size", str(CONTEXT_SIZE),
+           "--threads", str(CPU_THREADS),
+           "--batch-size", str(BATCH_SIZE)]
+
+    # Vision projector — enables multimodal (image_url) input.
+    if os.path.exists(MMPROJ_PATH) and has("--mmproj"):
+        cmd += ["--mmproj", MMPROJ_PATH]
+
+    if has("--threads-batch"):
+        cmd += ["--threads-batch", str(CPU_THREADS_BATCH)]
+    if has("--ubatch-size"):
+        cmd += ["--ubatch-size", str(UBATCH_SIZE)]
+    if has("--parallel"):
+        cmd += ["--parallel", str(PARALLEL)]
+    if has("--cont-batching"):
+        cmd += ["--cont-batching"]
+    if has("--alias"):
+        cmd += ["--alias", MODEL_ALIAS]
+
+    if FLASH_ATTN and has("--flash-attn"):
+        fa_line = next((l for l in help_text.splitlines() if "--flash-attn" in l), "")
+        if any(t in fa_line for t in ("{on", "[on", "on|off", "on,off")):
+            cmd += ["--flash-attn", "on"]
+        else:
+            cmd += ["--flash-attn"]
+
+    if KV_CACHE_QUANT and KV_CACHE_QUANT != "f16":
+        if has("--cache-type-k"):
+            cmd += ["--cache-type-k", KV_CACHE_QUANT]
+        if FLASH_ATTN and has("--cache-type-v"):
+            cmd += ["--cache-type-v", KV_CACHE_QUANT]
+
+    if has("--jinja"):
+        cmd += ["--jinja"]
+
+    if MLOCK_ENABLED and has("--mlock"):
+        cmd += ["--mlock"]
+    if has("--mmap") or has("--no-mmap"):
+        cmd += ["--mmap"] if MMAP_ENABLED else ["--no-mmap"]
+
+    return cmd
+
+
+def start_llama_server(idx):
+    port = INSTANCE_PORTS[idx]
+    if not _download_model():
+        MODEL_LOADED[idx] = False
+        return False
+
+    binary = _find_binary()
+    if not binary:
+        print(f"Instance {idx}: ❌ llama-server binary not found")
+        return False
+
+    cmd = build_cmd(binary, port, _help_text(binary))
+    print(f"Instance {idx}: launching -> {' '.join(cmd)}")
+
+    try:
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        LLAMA_PROCESSES[idx] = proc
+
+        def log_output(p, i):
+            for line in p.stdout:
+                print(f"Instance {i} LOG: {line.rstrip()}")
+        threading.Thread(target=log_output, args=(proc, idx), daemon=True).start()
+
+        # Sleep on every non-200 (llama-server returns 503 while loading), not
+        # only on connection exceptions, or the loop would exit instantly.
+        for _ in range(900):
+            if proc.poll() is not None:
+                print(f"Instance {idx}: ❌ exited with code {proc.returncode}")
+                return False
+            try:
+                r = httpx.get(f"{INSTANCE_URLS[idx]}/health", timeout=3.0)
+                if r.status_code == 200:
+                    MODEL_LOADED[idx] = True
+                    print(f"Instance {idx}: ✅ ready on port {port}")
+                    return True
+            except Exception:
+                pass
+            time.sleep(1)
+        print(f"Instance {idx}: ❌ startup timeout")
+        return False
+    except Exception as e:
+        print(f"Instance {idx}: error: {e}")
+        return False
+
+
+async def pick_instance():
+    global _rr_counter
+    async with _rr_lock:
+        for k in range(NUM_INSTANCES):
+            idx = (_rr_counter + k) % NUM_INSTANCES
+            if MODEL_LOADED[idx]:
+                _rr_counter = (idx + 1) % NUM_INSTANCES
+                return idx
+    return None
+
+
+@app.on_event("startup")
+async def startup_event():
+    global HTTP
+    HTTP = httpx.AsyncClient(timeout=httpx.Timeout(connect=10.0, read=600.0, write=30.0, pool=600.0),
+                             limits=httpx.Limits(max_connections=64, max_keepalive_connections=32))
+    print(f"Starting {NUM_INSTANCES} llama.cpp instance(s)...")
+    results = await asyncio.gather(
+        *[asyncio.to_thread(start_llama_server, i) for i in range(NUM_INSTANCES)],
+        return_exceptions=True)
+    loaded = sum(1 for r in results if r is True)
+    print(f"✅ {loaded}/{NUM_INSTANCES} instance(s) loaded")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    if HTTP:
+        await HTTP.aclose()
+    for p in LLAMA_PROCESSES:
+        if p and p.poll() is None:
+            p.terminate()
+
+
+async def proxy(request: Request, path: str):
+    idx = await pick_instance()
+    if idx is None:
+        raise HTTPException(status_code=503, detail="No healthy instances available")
+    url = f"{INSTANCE_URLS[idx]}{path}"
+    body = await request.body()
+    try:
+        payload = await request.json()
+    except Exception:
+        payload = {}
+    stream = bool(payload.get("stream", False))
+    headers = {"Content-Type": "application/json"}
+
+    if stream:
+        req = HTTP.build_request("POST", url, content=body, headers=headers)
+        r = await HTTP.send(req, stream=True)
+
+        async def gen():
+            try:
+                async for chunk in r.aiter_raw():
+                    yield chunk
+            finally:
+                await r.aclose()
+
+        return StreamingResponse(gen(), status_code=r.status_code,
+                                 media_type=r.headers.get("content-type", "text/event-stream"),
+                                 headers={"X-Backend-Instance": str(idx)})
     else:
-        prompt = f"<s><image>\nDescribe the image.</s>"
+        r = await HTTP.post(url, content=body, headers=headers)
+        return JSONResponse(status_code=r.status_code,
+                            content=r.json() if r.content else {},
+                            headers={"X-Backend-Instance": str(idx)})
+
 
-    inputs = tokenizer(prompt, pil_image, return_tensors="pt").to(device)
+@app.get("/", include_in_schema=False)
+async def swagger():
+    return get_swagger_ui_html(openapi_url=app.openapi_url, title=app.title + " - Swagger UI")
 
-    generation_args = {
-        "max_new_tokens": request.max_new_tokens,
-        "do_sample": request.do_sample,
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "ok" if any(MODEL_LOADED) else "degraded",
+        "instances": [
+            {"id": i, "port": INSTANCE_PORTS[i], "loaded": MODEL_LOADED[i], "url": INSTANCE_URLS[i]}
+            for i in range(NUM_INSTANCES)
+        ],
+        "active_instances": sum(MODEL_LOADED),
+        "total_instances": NUM_INSTANCES,
+        "vision": os.path.exists(MMPROJ_PATH),
+        "cpu_threads": CPU_THREADS,
+        "context_size": CONTEXT_SIZE,
+        "parallel_slots": PARALLEL,
+        "kv_cache_quant": KV_CACHE_QUANT,
+        "flash_attn": FLASH_ATTN,
     }
 
-    with torch.no_grad():
-        output_ids = model.generate(**inputs, **generation_args)
 
-    response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
-    return {"generated_text": response}
+@app.get("/v1/config")
+async def config():
+    return {
+        "model_path": MODEL_PATH, "mmproj_path": MMPROJ_PATH,
+        "vision_enabled": os.path.exists(MMPROJ_PATH),
+        "model_alias": MODEL_ALIAS, "detected_vcpus": _CPU,
+        "instances": NUM_INSTANCES, "ports": INSTANCE_PORTS,
+        "cpu_threads": CPU_THREADS, "threads_batch": CPU_THREADS_BATCH,
+        "context_size": CONTEXT_SIZE, "parallel_slots": PARALLEL,
+        "batch_size": BATCH_SIZE, "ubatch_size": UBATCH_SIZE,
+        "kv_cache_quant": KV_CACHE_QUANT, "flash_attn": FLASH_ATTN,
+        "mmap_enabled": MMAP_ENABLED, "mlock_enabled": MLOCK_ENABLED,
+        "instances_status": [{"id": i, "loaded": MODEL_LOADED[i]} for i in range(NUM_INSTANCES)],
+    }
+
+
+@app.get("/v1/models")
+async def models():
+    idx = await pick_instance()
+    if idx is not None:
+        try:
+            r = await HTTP.get(f"{INSTANCE_URLS[idx]}/v1/models", timeout=10.0)
+            if r.status_code == 200:
+                return JSONResponse(content=r.json())
+        except Exception:
+            pass
+    return {"object": "list", "data": [{"id": MODEL_ALIAS, "object": "model", "owned_by": "Leon4gr45"}]}
+
+
+# OpenAI-compatible; vision works via image_url content parts (mmproj loaded).
+@app.post("/v1/chat/completions")
+async def chat_completions(request: Request):
+    return await proxy(request, "/v1/chat/completions")
+
+
+@app.post("/v1/completions")
+async def completions(request: Request):
+    return await proxy(request, "/v1/completions")
+
 
-@app.get("/")
-async def read_root():
-    return {"message": "InternVL2_5-2B API. Go to /docs for API documentation."}
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=MAIN_PORT)

requirements.txt

@@ -1,13 +1,4 @@
-fastapi==0.112.4
-uvicorn==0.40.0
-torch
-transformers==4.43.0
-accelerate==0.30.0
-sentencepiece
-python-dotenv
-pydantic==2.12.5
-einops
-numpy==1.24.4
-Pillow==10.3.0
-Requests==2.31.0
-timm
+fastapi
+uvicorn
+httpx
+huggingface_hub

test_vision.py

@@ -0,0 +1,31 @@
+"""Smoke test: text chat + vision (image_url) against the phi_inference Space."""
+import base64
+import json
+import sys
+import requests
+
+BASE = "https://Leon4gr45-phi-inference.hf.space"
+
+# 1) text-only
+r = requests.post(f"{BASE}/v1/chat/completions", json={
+    "model": "lfm2.5-vl-1.6b",
+    "messages": [{"role": "user", "content": "Say hello in one sentence."}],
+    "max_tokens": 48,
+}, timeout=180)
+print("TEXT:", json.dumps(r.json(), indent=2)[:500])
+
+# 2) vision — pass an image path as argv[1], else skip
+if len(sys.argv) > 1:
+    with open(sys.argv[1], "rb") as f:
+        b64 = base64.b64encode(f.read()).decode()
+    r = requests.post(f"{BASE}/v1/chat/completions", json={
+        "model": "lfm2.5-vl-1.6b",
+        "messages": [{"role": "user", "content": [
+            {"type": "text", "text": "Describe this image in detail."},
+            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
+        ]}],
+        "max_tokens": 256,
+    }, timeout=300)
+    print("VISION:", r.json()["choices"][0]["message"]["content"])
+else:
+    print("(pass an image path as argv[1] to test vision)")