add colibri inference service

Caddyfile

@@ -41,6 +41,13 @@ handle /odysseus* {
     reverse_proxy 127.0.0.1:{$ODYSSEUS_PORT}
 }
 
+# Colibri serves the OpenAI API at the root (/v1/..., /health) and has no
+# base-path option, so unlike the Claw services above the prefix must be
+# stripped: /colibri/v1/chat/completions -> /v1/chat/completions.
+handle_path /colibri/* {
+    reverse_proxy 127.0.0.1:{$COLIBRI_PORT}
+}
+
 # OpenClaw UI uses absolute runtime paths; proxy them too.
 handle /ws* {
     reverse_proxy 127.0.0.1:18789 {

Dockerfile

@@ -34,6 +34,31 @@ RUN uv sync --no-dev
 # RUN git clone https://github.com/pewdiepie-archdaemon/odysseus.git /app/odysseus \
 #     && pip install --no-cache-dir -r /app/odysseus/requirements.txt
 
+# Colibri (https://github.com/JustVugg/colibri): a pure-C MoE inference engine.
+# `make -C c olmoe` compiles a single self-contained C file into a standalone
+# `olmoe` binary that serves an OpenAI-compatible API — no Python, no runtime
+# deps beyond libgomp. Off by default so the default image is byte-identical to
+# today's; enable with `docker build --build-arg COLIBRI_BUILD=1`.
+# Weights are NOT baked in (~7 GB): see scripts/run_colibri.py and colibri.json.
+ARG COLIBRI_BUILD=0
+RUN if [ "$COLIBRI_BUILD" = "1" ]; then \
+      set -eux; \
+      apt-get update; \
+      apt-get install -y --no-install-recommends gcc make libgomp1; \
+      git clone --depth 1 https://github.com/JustVugg/colibri.git /tmp/colibri; \
+      make -C /tmp/colibri/c olmoe; \
+      install -D -m 0755 /tmp/colibri/c/olmoe /usr/local/bin/coli-olmoe; \
+      cp -r /tmp/colibri/c/tools /opt/colibri-tools; \
+      rm -rf /tmp/colibri; \
+      apt-get purge -y gcc make; \
+      apt-get autoremove -y; \
+      apt-get install -y --no-install-recommends libgomp1; \
+      rm -rf /var/lib/apt/lists/*; \
+      coli-olmoe --help >/dev/null 2>&1 || true; \
+    else \
+      echo "[colibri] build skipped (COLIBRI_BUILD=0)"; \
+    fi
+
 COPY . /app
 
 # Agent OS (https://github.com/buildermethods/agent-os): a project-scaffolding
@@ -148,6 +173,19 @@ ENV ODYSSEUS_APP_DIR=/app/odysseus
 ENV ODYSSEUS_CONFIG_PATH=/app/odysseus.json
 ENV ODYSSEUS_LOG_PATH=/tmp/odysseus.log
 ENV ODYSSEUS_ERR_LOG_PATH=/tmp/odysseus.err.log
+ENV COLIBRI_ENABLED=0
+ENV COLIBRI_PORT=18797
+ENV COLIBRI_CMD="uv run python3"
+ENV COLIBRI_ARGS=/app/scripts/run_colibri.py
+ENV COLIBRI_BASE_PATH=/colibri
+ENV COLIBRI_CONFIG_PATH=/app/colibri.json
+ENV COLIBRI_BIN=coli-olmoe
+ENV COLIBRI_MODEL_DIR=/data/models/olmoe
+ENV COLIBRI_MODEL_REPO=
+ENV COLIBRI_MODEL_ID=olmoe-1b-7b
+ENV COLIBRI_OPENAI_URL=http://127.0.0.1:18797/v1/chat/completions
+ENV COLIBRI_LOG_PATH=/tmp/colibri.log
+ENV COLIBRI_ERR_LOG_PATH=/tmp/colibri.err.log
 
 RUN mkdir -p /app/vault /app/.openclaw/state
 

README.md

@@ -20,6 +20,7 @@ This Space hosts the OpenClaw trading bot (paper-only). The LLM runs in a separa
 **IronClaw**: [https://github.com/nearai/ironclaw](https://github.com/nearai/ironclaw)
 **NemoClaw (OpenShell)**: [https://github.com/NVIDIA/OpenShell](https://github.com/NVIDIA/OpenShell)
 **NVIDIA NeMo Agent Toolkit**: [https://github.com/NVIDIA/NeMo-Agent-Toolkit](https://github.com/NVIDIA/NeMo-Agent-Toolkit)
+**Colibri**: [https://github.com/JustVugg/colibri](https://github.com/JustVugg/colibri)
 
 **Hugging Face Space Build Notes**
 - Keep `README.md`, `Dockerfile`, and `app.py` at the repository root used by the Space.
@@ -32,6 +33,23 @@ This Space hosts the OpenClaw trading bot (paper-only). The LLM runs in a separa
 - Trade logs stored to HF Hub storage (dataset repo).
 - Streamlit control center includes a built-in backtesting lab (backtesting.py + backtrader).
 
+**Colibri (optional local inference)**
+- Colibri is a pure-C MoE engine. Of its six model families, only **OLMoE** (1B active /
+  7B total, ~7 GB, 8 GB RAM) fits a free Space; the rest need 20 GB–1.6 TB of local NVMe.
+- It is a *fast lane*, not a bigger model: OLMoE is weaker than the remote LLM Space but
+  activates 1B params instead of 7B, so it is several times faster per token on 2 vCPU.
+- Off by default. Turning it on takes three steps, in order:
+  1. Build the engine: `docker build --build-arg COLIBRI_BUILD=1 -t agi-assistant .`
+  2. Provision weights. Colibri uses its **own container format** — not GGUF, AWQ, or
+     safetensors — and no pre-converted OLMoE container is published on the Hub. Convert
+     once offline with the repo's `c/tools/convert_olmoe_merged.py`, push the result to a
+     Hub model repo, and set `COLIBRI_MODEL_REPO` to it. Do not convert inside the Space:
+     torch plus the bf16 source checkpoint will not fit alongside the other services.
+  3. Set `COLIBRI_ENABLED=1`, and point the bot at it with `openclaw.colibri.json`.
+- Served at `/colibri/v1/chat/completions` (and `/colibri/health`).
+- Untested on real hardware: RAM headroom on a 16 GB box already running ~10 services is
+  unmeasured, as is OLMoE's actual tok/s on 2 vCPU. Check `free -h` before enabling.
+
 **LLM Space (external)**
 - Expected to expose a simple HTTP inference endpoint.
 - The bot calls `${LLM_SPACE_URL}` (see `config/openclaw.env.example`) and expects a JSON response with an output string.

colibri.json

@@ -0,0 +1,32 @@
+{
+  "service": "colibri",
+  "source": "https://github.com/JustVugg/colibri",
+  "description": "Colibri pure-C MoE inference engine serving OLMoE (1B active / 7B total) as a local OpenAI-compatible fast lane.",
+  "gateway": {
+    "host": "127.0.0.1",
+    "port": 18797,
+    "base_path": "/colibri"
+  },
+  "model": {
+    "family": "olmoe",
+    "model_id": "olmoe-1b-7b",
+    "dir": "/data/models/olmoe",
+    "repo": "",
+    "revision": "main",
+    "notes": [
+      "Colibri needs its OWN container format - not GGUF/AWQ/GPTQ/safetensors.",
+      "No pre-converted OLMoE container is published on the Hub (only GLM-5.2 / Hy3 variants).",
+      "Convert once offline with c/tools/convert_olmoe_merged.py (needs torch), push the",
+      "~7 GB int8 container to a Hub model repo, then set COLIBRI_MODEL_REPO to it.",
+      "Converting inside this Space is not viable: torch + the bf16 source checkpoint do not",
+      "fit alongside the other services on a 16 GB / ~50 GB free-tier box.",
+      "The conversion tools are copied to /opt/colibri-tools in the image when built with COLIBRI_BUILD=1."
+    ]
+  },
+  "runtime": {
+    "threads": 2,
+    "kv_slots": 2,
+    "max_queue": 4,
+    "queue_timeout_sec": 600
+  }
+}

config/openclaw.env.example

@@ -16,3 +16,12 @@ HF_TRADES_REPO=username/trading-logs
 
 # Market data (optional extra source)
 MARKET_DATA_SOURCE=alpaca
+
+# Colibri local inference engine (OLMoE) — see colibri.json
+# Requires: image built with --build-arg COLIBRI_BUILD=1, and a Colibri-format
+# weight container (Colibri does NOT read GGUF/safetensors).
+COLIBRI_ENABLED=0
+COLIBRI_MODEL_REPO=
+COLIBRI_MODEL_DIR=/data/models/olmoe
+COLIBRI_MODEL_ID=olmoe-1b-7b
+COLIBRI_OPENAI_URL=http://127.0.0.1:18797/v1/chat/completions

openclaw.colibri.json

@@ -0,0 +1,73 @@
+{
+  "agent": {
+    "name": "openclaw-trading-bot",
+    "description": "OpenClaw trading bot routed to the in-container Colibri engine serving OLMoE",
+    "timezone": "UTC"
+  },
+  "providers": [
+    {
+      "name": "colibri_olmoe",
+      "type": "custom_http",
+      "base_url": "${COLIBRI_OPENAI_URL}",
+      "method": "POST",
+      "timeout_ms": 300000,
+      "headers": {
+        "Content-Type": "application/json"
+      },
+      "request_schema": {
+        "model": "${COLIBRI_MODEL_ID}",
+        "messages": [
+          {
+            "role": "user",
+            "content": "${prompt}"
+          }
+        ],
+        "temperature": 0.2,
+        "max_tokens": 700
+      },
+      "response_path": "choices.0.message.content"
+    }
+  ],
+  "routing": {
+    "market_analysis": "colibri_olmoe",
+    "signal_generation": "colibri_olmoe",
+    "reporting": "colibri_olmoe"
+  },
+  "tools": {
+    "alpaca_paper": {
+      "type": "python",
+      "module": "tools.alpaca_paper",
+      "env": [
+        "ALPACA_API_KEY",
+        "ALPACA_API_SECRET",
+        "ALPACA_BASE_URL"
+      ]
+    },
+    "hf_storage": {
+      "type": "python",
+      "module": "tools.hf_storage",
+      "env": [
+        "HF_TOKEN",
+        "HF_TRADES_REPO"
+      ]
+    },
+    "market_data": {
+      "type": "python",
+      "module": "tools.market_data",
+      "env": [
+        "MARKET_DATA_SOURCE"
+      ]
+    }
+  },
+  "memory": {
+    "type": "sqlite",
+    "path": "/data/openclaw_memory.sqlite",
+    "max_tokens": 1200
+  },
+  "safety": {
+    "paper_only": true,
+    "max_order_qty": 5,
+    "max_position_usd": 5000,
+    "require_signal": true
+  }
+}

pyproject.toml

@@ -5,6 +5,7 @@ requires-python = ">=3.11"
 dependencies = [
   "backtesting==0.3.3",
   "backtrader==1.9.78.123",
+  "huggingface-hub==0.28.1",
   "pandas==2.2.3",
   "requests==2.32.3",
   "streamlit==1.41.1",

scripts/run_colibri.py

@@ -0,0 +1,130 @@
+"""Launcher for Colibri (https://github.com/JustVugg/colibri) serving OLMoE.
+
+Colibri is a pure-C MoE engine built per model family: `make -C c olmoe` produces
+a standalone `olmoe` binary that exposes an OpenAI-compatible API via `serve`.
+Unlike the npm/pip Claw services, it needs two things this repo cannot bundle:
+
+  1. the binary, compiled at image build time (guarded by `--build-arg COLIBRI_BUILD=1`)
+  2. a Colibri-format weight container, which the user must provision
+
+Colibri uses its own container format, and no pre-converted OLMoE container is
+published on the Hub. If either piece is missing this launcher logs what is
+needed and parks the process instead of exiting: supervisord runs every program
+with `autorestart=true`, and a fast-exiting program turns into a restart loop
+that has taken this Space down before (see the agent-os/odysseus notes in the
+Dockerfile).
+"""
+import json
+import os
+import shutil
+import sys
+import time
+from pathlib import Path
+
+CONFIG_PATH = Path(os.environ.get("COLIBRI_CONFIG_PATH", "/app/colibri.json"))
+
+
+def _load_config() -> dict:
+    try:
+        return json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _log(message: str) -> None:
+    print(f"[colibri] {message}", flush=True)
+
+
+def _park(reason: str) -> None:
+    """Stay alive without work so supervisord does not thrash on restart."""
+    _log(reason)
+    _log("service parked; set the missing piece and restart this program")
+    while True:
+        time.sleep(3600)
+
+
+def _model_ready(model_dir: Path) -> bool:
+    return model_dir.is_dir() and any(model_dir.iterdir())
+
+
+def _download_model(repo: str, revision: str, model_dir: Path) -> bool:
+    try:
+        from huggingface_hub import snapshot_download
+    except ImportError:
+        _log("huggingface_hub is not installed; cannot fetch the model container")
+        return False
+
+    _log(f"downloading Colibri container from {repo}@{revision} -> {model_dir}")
+    try:
+        model_dir.parent.mkdir(parents=True, exist_ok=True)
+        snapshot_download(
+            repo_id=repo,
+            revision=revision,
+            local_dir=str(model_dir),
+            token=os.environ.get("HF_TOKEN") or None,
+        )
+    except Exception as exc:
+        _log(f"download failed: {exc}")
+        return False
+    return _model_ready(model_dir)
+
+
+def main() -> None:
+    config = _load_config()
+    gateway = config.get("gateway", {})
+    model_cfg = config.get("model", {})
+    runtime = config.get("runtime", {})
+
+    host = os.environ.get("COLIBRI_HOST") or gateway.get("host") or "127.0.0.1"
+    port = str(os.environ.get("COLIBRI_PORT") or gateway.get("port") or 18797)
+    model_id = os.environ.get("COLIBRI_MODEL_ID") or model_cfg.get("model_id") or "olmoe"
+    model_dir = Path(os.environ.get("COLIBRI_MODEL_DIR") or model_cfg.get("dir") or "/data/models/olmoe")
+    repo = (os.environ.get("COLIBRI_MODEL_REPO") or model_cfg.get("repo") or "").strip()
+    revision = os.environ.get("COLIBRI_MODEL_REVISION") or model_cfg.get("revision") or "main"
+
+    binary = os.environ.get("COLIBRI_BIN", "coli-olmoe")
+    resolved = shutil.which(binary)
+    if not resolved:
+        _park(
+            f"engine binary {binary!r} not found - rebuild the image with "
+            "`docker build --build-arg COLIBRI_BUILD=1`"
+        )
+
+    if not _model_ready(model_dir):
+        if not repo:
+            _park(
+                f"no weights at {model_dir} and COLIBRI_MODEL_REPO is unset - convert OLMoE "
+                "with c/tools/convert_olmoe_merged.py, push the container to a Hub repo, "
+                "then set COLIBRI_MODEL_REPO"
+            )
+        if not _download_model(repo, revision, model_dir):
+            _park(f"could not provision weights at {model_dir}")
+
+    threads = str(os.environ.get("OMP_NUM_THREADS") or runtime.get("threads") or 2)
+    env = dict(os.environ)
+    env["OMP_NUM_THREADS"] = threads
+    env["COLI_MODEL"] = str(model_dir)
+    env.setdefault("COLI_MAX_QUEUE", str(runtime.get("max_queue", 4)))
+    env.setdefault("COLI_QUEUE_TIMEOUT", str(runtime.get("queue_timeout_sec", 600)))
+    env.setdefault("COLI_KV_SLOTS", str(runtime.get("kv_slots", 2)))
+
+    extra_args = (os.environ.get("COLIBRI_SERVE_ARGS") or "").split()
+    argv = [
+        binary,
+        "serve",
+        "--host", host,
+        "--port", port,
+        "--model", str(model_dir),
+        "--model-id", model_id,
+        *extra_args,
+    ]
+
+    _log(f"starting: {' '.join(argv)} (OMP_NUM_THREADS={threads})")
+    try:
+        os.execvpe(resolved, argv, env)
+    except OSError as exc:
+        _park(f"exec failed: {exc}")
+
+
+if __name__ == "__main__":
+    main()

supervisord.conf

@@ -133,3 +133,14 @@ killasgroup=true
 stdout_logfile=/tmp/odysseus.log
 stderr_logfile=/tmp/odysseus.err.log
 environment=HOME="/root",ODYSSEUS_CONFIG_PATH="/app/odysseus.json",ODYSSEUS_APP_DIR="/app/odysseus",ODYSSEUS_PORT="18796",ODYSSEUS_BASE_PATH="/odysseus"
+
+[program:colibri]
+command=/bin/sh -lc "if [ \"${COLIBRI_ENABLED:-0}\" = \"1\" ]; then cd /app && ${COLIBRI_CMD} ${COLIBRI_ARGS}; else echo '[colibri] disabled'; sleep infinity; fi"
+autorestart=true
+startsecs=5
+startretries=10
+stopasgroup=true
+killasgroup=true
+stdout_logfile=/tmp/colibri.log
+stderr_logfile=/tmp/colibri.err.log
+environment=HOME="/root",COLIBRI_CONFIG_PATH="/app/colibri.json",COLIBRI_PORT="18797",COLIBRI_BASE_PATH="/colibri",OMP_NUM_THREADS="2"