checking…
CPU
RAM
0
Running
0
Installed
0 GB
Disk Used

Running Models

No models running — deploy one from the Library or Discover tab

💬 Persistent Chat — runs server-side with no timeout; keeps generating even if you close this tab

No active chat — pick a model and send a message. It keeps running on the server (0 timeout) and reports elapsed time + token count even if you close or reload this page — just come back and it'll resume showing you the result.

Model Categories

💬
Chat
General-purpose conversation models. They understand instructions, write text, answer questions, summarise documents and help with everyday tasks.
USE CASES
Chatbots · Writing assistant · Summarisation · Translation · Q&A · Customer support · Content generation
💻
Code
Specialised for programming. Fine-tuned on vast amounts of source code across many languages — far better at coding tasks than general chat models.
USE CASES
Code generation · Debugging · Code review · Refactoring · Documentation · Unit tests · IDE autocomplete
🧠
Reasoning
Trained to think step-by-step before answering ("chain of thought"). Much stronger at math, logic puzzles and multi-step problems than regular chat models.
USE CASES
Mathematics · Logic puzzles · STEM research · Data analysis · Complex planning · Scientific reasoning
🔗
Embedding
Not for conversation — converts text into numerical vectors. These vectors capture semantic meaning, letting you compare, search and cluster documents by meaning rather than keywords.
USE CASES
RAG pipelines · Semantic search · Document retrieval · Similarity scoring · Clustering · Recommendation engines

Rankings

#ModelSizeScoreNote
Loading…

All Models

Installed Models

Name / TagsCategorySizeStatusLiteLLM Name
No models installed

Add Model

🤗 HuggingFace Hub
Search & download any GGUF repo
🔗 Direct URL
Download from any HTTPS link

Active Downloads

No active downloads

Downloaded Models

💬 Chat Test

Select a model and send a message to test it

🦙 Ollama Registry

Pull and deploy models directly from the Ollama registry — no GGUF download needed. Best for vision models and architectures not supported by llama.cpp.

Loading catalog…

🏓 Test All Models

Sends Reply with one word: PONG to every running model via LiteLLM and shows latency + response.

📋 Operation Log

No operations logged yet — try deploying a model

📊 Benchmarks

Memory Bandwidth Config
DDR4 MT/s
ch/socket × sockets
GPU HBM GB/s per card
ModelStrategyGen t/sExp. BWExp. t/sEffic. PP t/sThreadsContextMethodNotesDate
Click Refresh to load
Gen t/s legend: <8 — slow 10 — ok 20 — better 30+ — good 50 — very good 80+ — excellent

🔧 System Diagnostics

Click "Run Checks" to run diagnostics

🧩 NUMA Topology

Shows CPU ↔ memory node layout. Use this to fill in the Memory Node Pin and CPU Pin fields in the deploy form. Low distance = local (fast). High distance = remote (slow, cross-socket).

Click Refresh to read NUMA topology

🎮 P100 GPU Debugger — CUDA Error Playbook

Everything we know about getting (and keeping) the dual Tesla P100-PCIE-16GB GPUs working for llama.cpp inference on this box. Read the symptom → cause → fix table first, then jump to the section that matches your error.

The hardware, in one line: Proxmox host bigjohnny-100 → unprivileged LXC CTID 102 (102-docker-host) → Docker → llama.cpp container. The GPUs are passed through host → LXC → Docker. Every layer can break passthrough independently — that's why these bugs feel random.

① 30-second error decoder

Match the exact error string from the container logs — the wording tells you the cause.

Error in container logsReal causeSection
ggml_cuda_init: failed to initialize CUDA: unknown error
+ no usable GPU found
Dynamic nvidia-uvm major number drifted after a reboot; the LXC cgroup allowlist is stale and blocks the device.
nvidia-smi shows CUDA Version: N/A, or llama.cpp says compiled without GPU support CUDA driver userspace libs (libcuda.so.1) missing inside the LXC.
no kernel image is available for execution on the device Binary genuinely lacks Pascal SASS and PTX. Rare — needs a rebuild/PTX. Usually a red herring.
Loads fine but generates at ~5–11 t/s; device_info shows only CPU Silent CPU fallback — GPU init failed earlier in the log, or model didn't fit VRAM.
The #1 tell: if nvidia-smi works inside the container but CUDA fails, it is almost always the nvidia-uvm cgroup major (§②) — not a driver, image, or arch problem. nvidia-smi only needs /dev/nvidia0/1/ctl (stable major 195); CUDA compute needs the Unified-Memory device /dev/nvidia-uvm, whose major changes on every reboot.

② The "unknown error" — dynamic major numbers explained

This is the one that keeps coming back. Understanding it bit by bit:

What is a "major number"?

Every Linux character device (like a GPU node) has two numbers: a major (which driver owns it) and a minor (which specific device). You can see them with ls -l /dev/nvidia* — they appear where a file's size normally would:

crw-rw-rw- 1 root root 506,   0 /dev/nvidia-uvm        ← major 506, minor 0
crw-rw-rw- 1 root root 195,   0 /dev/nvidia0           ← major 195, minor 0
crw-rw-rw- 1 root root 195, 255 /dev/nvidiactl         ← major 195, minor 255

Why 506 one day and 507 the next?

Some NVIDIA devices get a fixed major, others get a dynamic one the kernel assigns from a free pool at load time:

DeviceMajorNeeded by
/dev/nvidia0, nvidia1, nvidiactl195 — fixednvidia-smi, everything
/dev/nvidia-modeset235 — fixeddisplay (unused here)
/dev/nvidia-uvm, nvidia-uvm-tools506/507/… — DYNAMICCUDA compute
/dev/nvidia-caps/*509/510/… — DYNAMICcapability queries

So nvidia-uvm might be 506 today, 507 after the next reboot, back to 506 after another. The exact number is meaningless — what matters is that it changes.

Why that breaks the container

An unprivileged LXC can't touch device nodes unless its cgroup allowlist explicitly permits that major. The config /etc/pve/lxc/102.conf pins them:

lxc.cgroup2.devices.allow: c 195:* rwm     ← nvidia0/1/ctl  (fixed, always right)
lxc.cgroup2.devices.allow: c 507:* rwm     ← nvidia-uvm     (PINNED to 507)
lxc.cgroup2.devices.allow: c 510:* rwm     ← nvidia-caps    (PINNED to 510)
lxc.mount.entry: /dev/nvidia-uvm dev/nvidia-uvm none bind,optional,create=file

The mount.entry still bind-mounts /dev/nvidia-uvm into the container, so it's visible. But if the real major is now 506 while the cgroup only allows 507, the kernel denies every read/write to it. CUDA tries to open the Unified-Memory device, gets permission denied at the cgroup layer, and reports the generic:

ggml_cuda_init: failed to initialize CUDA: unknown error
warning: no usable GPU found, --gpu-layers option will be ignored

Meanwhile nvidia-smi keeps working because it never touches nvidia-uvm — which is exactly why this masquerades as an app or image bug.

The manual fix (run on bigjohnny-100). First read the current majors, then point the config at them:
# 1. What are the majors RIGHT NOW?
cat /proc/devices | grep nvidia
#   → e.g. "506 nvidia-uvm"  and  "509 nvidia-caps"

# 2. See what the config currently pins (the stale numbers)
grep cgroup2.devices.allow /etc/pve/lxc/102.conf

# 3. Point the config at the real majors (example: uvm 507→506, caps 510→509)
sed -i 's/allow: c 507:\* rwm/allow: c 506:* rwm/' /etc/pve/lxc/102.conf
sed -i 's/allow: c 510:\* rwm/allow: c 509:* rwm/' /etc/pve/lxc/102.conf

# 4. Restart the container so it re-reads the cgroup allowlist
pct restart 102

Then redeploy the model — you should see both cards in device_info:

CUDA0 : Tesla P100-PCIE-16GB (16269 MiB, 16013 MiB free)
CUDA1 : Tesla P100-PCIE-16GB (16269 MiB, 16013 MiB free)

This is tedious and recurring — automate it. See §⑦.

③ Missing libcuda / "no usable GPU" — driver libraries

Different failure: the LXC has the NVIDIA management lib (so nvidia-smi runs) but not the CUDA driver lib (libcuda.so.1). Symptoms:

  • nvidia-smi works but shows CUDA Version: N/A
  • llama.cpp: compiled without GPU support even though the image is the CUDA build

The nvidia-container-runtime can only inject libraries that exist on the LXC host, so the fix is to copy the matching driver libs from the Proxmox host into the LXC. Two libs are required:

LibraryWhy
libcuda.so.<driver>The CUDA driver API itself.
libnvidia-ptxjitcompiler.so.<driver>P100 (Pascal) has no native SASS in the stock image — kernels are JIT-compiled from PTX at first load, which needs this compiler. (This is why the first request after start takes ~60 s.)

This is fully scripted in the repo — run it on bigjohnny-100:

./deploy/ml350/fix-lxc-cuda-driver.sh 102

It detects the host driver version, pct pushes both libs into the LXC, creates the libcuda.so.1 / .so symlinks, and runs ldconfig. The libs live in the container's own rootfs, so they survive reboots — but if you upgrade the NVIDIA driver on the host, the versions mismatch and you must re-run it.

④ "no kernel image available" — the sm_60 / arch myth

You'll see advice like "your ARCHS list shows 610 not 600, rebuild llama.cpp for CMAKE_CUDA_ARCHITECTURES=60." On this box that is almost always wrong. How to tell:

If the error is…Then…
unknown error at ggml_cuda_initIt's the uvm cgroup (§②). NOT an arch problem. The error wording for a missing arch is different.
no kernel image is available for execution on the deviceThis is a genuine arch/PTX problem — the binary has neither sm_60 SASS nor loadable PTX for Pascal.
The empirical disproof: our image (server-cuda with PTX JIT) has loaded both P100s and run inference successfully with the arch list ARCHS = 500,610,700,… (no 600). If the binary truly couldn't target sm_60, it could never have worked — but it did. The P100 kernels are JIT-compiled from PTX at load (that's the ~60 s first-run warmup). So a missing 600 in the SASS list is not the blocker. Don't waste hours rebuilding — check §② first.

P100 = compute capability 6.0 (sm_60), Pascal, no Tensor Cores. Consequence: flash-attention is unsupported — always leave it off for P100 deployments. That's the one arch fact that actually matters here.

⑤ It runs, but it's slow (silent CPU fallback)

If a model deploys "successfully" but generates at ~5–11 t/s, it's probably running on CPU, not the GPUs. Confirm by reading the load log:

docker logs llm-<slug> 2>&1 | grep -iE "device_info|CUDA0|CUDA1|ggml_cuda_init|no usable GPU|offload|buffer size"
  • Only CPU in device_info → GPU init failed earlier — scroll up for ggml_cuda_init, then go to §②/§③.
  • CUDA0/CUDA1 present but few layers offloaded → model + KV cache didn't fit in 32 GB VRAM and it partially spilled. Lower --ctx-size, drop --parallel, or use a smaller quant. (A 27B Q8_0 at 26.6 GB leaves almost no room for KV — expect trouble.)

Rough healthy numbers on both P100s (≈732 GB/s HBM2 each): a ~16 GB MoE around 60–80 t/s, a 27B dense Q8 around 30–40 t/s. Single-digit t/s = CPU. Use the 🧪 Benchmark Suite (Library → model → Suite) with the GPU presets to measure it properly.

⑥ Copy-paste diagnostic commands

Inside the container (on 102-docker-host)

# does GPU passthrough reach the container?
docker exec -it llm-<slug> nvidia-smi
docker exec -it llm-<slug> ls -l /dev/nvidia*
docker exec -it llm-<slug> sh -c 'echo $NVIDIA_VISIBLE_DEVICES; echo $NVIDIA_DRIVER_CAPABILITIES'

# the actual CUDA error (the line that matters)
docker logs --tail=200 llm-<slug> 2>&1 | grep -iE "cuda|gpu|device_info|CUDA0|CUDA1"

On the LXC host (102-docker-host)

ls -l /dev/nvidia*                 # what majors does the container actually see?
cat /proc/driver/nvidia/version    # driver version

On the Proxmox host (bigjohnny-100)

cat /proc/devices | grep nvidia            # the CURRENT dynamic majors
grep -n nvidia /etc/pve/lxc/102.conf       # what the config pins
nvidia-smi | head -5                        # host driver sanity
systemctl status fix-lxc-nvidia-uvm.service # is the auto-fix healthy?

⑦ Making it permanent — the boot service

Because the uvm/caps majors drift on every reboot, the durable fix is a boot-time service on bigjohnny-100 that re-detects them and patches 102.conf before the container starts. Both files are version-controlled in the repo:

  • deploy/ml350/fix-lxc-nvidia-uvm.sh — the patcher
  • deploy/ml350/fix-lxc-nvidia-uvm.service — the systemd unit
The gotcha that bit us: a naive version failed at boot with nvidia-uvm not in /proc/devices — it read the major before the module was loaded, so it found nothing and gave up, leaving the stale major in place. The hardened script force-loads the modules first (nvidia-modprobe -c 0 -u) and patches both uvm and caps.
1
Install the hardened script + unit:
install -m 755 fix-lxc-nvidia-uvm.sh /usr/local/bin/fix-lxc-nvidia-uvm.sh
install -m 644 fix-lxc-nvidia-uvm.service /etc/systemd/system/fix-lxc-nvidia-uvm.service
systemctl daemon-reload
systemctl enable fix-lxc-nvidia-uvm.service
2
Fix the current majors right now and restart the container:
/usr/local/bin/fix-lxc-nvidia-uvm.sh 102   # prints "Updated ... (uvm=506 caps=509)"
pct restart 102
3
Verify it's healthy for future boots (should be active (exited), not failed):
systemctl restart fix-lxc-nvidia-uvm.service
systemctl status  fix-lxc-nvidia-uvm.service --no-pager

The unit is ordered Before=pve-guests.service, so on a normal reboot the majors are corrected before the container starts and no manual step is needed.

⚙ Settings

Changes are saved to the database and take effect immediately — no restart needed. Leave blank to use the default (shown as placeholder).


🦙 Ollama Maintenance

Use Reset Ollama when models fail with format-incompatibility errors after an Ollama upgrade (e.g. "no longer compatible"). This stops the container, wipes the ollama_data volume, and marks all Ollama models as un-deployed — then redeploy with Pull from Ollama registry.