A large language model you can point your tools at tokens.velella.ca

Continue VS Code · JetBrains

An open-source assistant that lives inside your editor: a chat panel beside your code, select-and-ask edits, and autocomplete. You stay the driver — it suggests, you apply.

Best for everyday work in a file you are already looking at: explain this function, write this test, tidy this block.

Get it: continue.dev · VS Code Marketplace

#  ~/.continue/config.yaml   (then reload VS Code)
models:
  - name: Qwen3.6-35B (tokens)
    provider: openai
    model: qwen3.6-35b-a3b
    apiBase: https://tokens.velella.ca/v1
    apiKey: 6f3c...   # the 64-character contents of ~/.config/spigot/key
    roles: [chat, edit]

Cline VS Code

An agent rather than an assistant: give it a task and it plans, reads and edits several files, and runs commands — asking your approval at each step. Formerly "Claude Dev".

Best for multi-file jobs you want to supervise rather than type: a refactor, a bug hunt across modules, wiring something new in. It reads a lot, so it is the heaviest user of your key's context.

Get it: cline.bot · VS Code Marketplace

Extension settings -> API Provider: OpenAI Compatible

Base URL:  https://tokens.velella.ca/v1
API Key:   (paste ~/.config/spigot/key -- the key itself, not the fingerprint)
Model ID:  qwen3.6-35b-a3b

OpenCode terminal · agent

An open-source terminal coding agent. Like Cline it plans and edits across files, but it runs in the shell rather than in an editor — so it works over ssh, on a cluster login node, or anywhere you would use a terminal.

Best for agentic work without an editor, and for anyone who wants the key kept in a file rather than pasted into settings — it is the only client here that reads the key from disk instead of storing a copy of it.

Get it: opencode.ai · provider docs — npm i -g opencode-ai (needs Node)

# ~/.config/opencode/opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "velella": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "tokens.velella.ca",
      "options": {
        "baseURL": "https://tokens.velella.ca/v1",
        "apiKey": "{file:~/.config/spigot/key}"
      },
      "models": {
        "qwen3.6-35b-a3b": {
          "name": "Qwen3.6-35B",
          "reasoning": true,
          "interleaved": { "field": "reasoning_content" },
          "limit": { "context": 32768, "output": 8192 }
        }
      }
    }
  }
}

Run a task with opencode for the interactive interface, or headless:

opencode run --auto -m velella/qwen3.6-35b-a3b "write primes.py, run it, show the output"

Two lines in that config are doing real work. "reasoning" with reasoning_content shows the model's thinking before the answer, so a long turn reads as work rather than as a hang — this model thinks for a while before it writes, and OpenCode is the client here that shows you that. "limit": {"output": 8192} sets the max_tokens cap from the box above once, in config, instead of per request.

Leave "output" at 8192 or higher. Lowering it is the one change that looks like a sensible economy and is not: the thinking phase draws on the same budget, so a small cap is spent before the answer starts and you get an empty reply. Tested — 8192 is safe.

The model id must match what /v1/models returns — qwen3.6-35b-a3b, exactly as above. The interactive interface is OpenCode's solid path; the headless run command has hung on long tasks in our testing, so check on it if you script against it.

Aider terminal

A pair-programmer in the shell. It knows your git repo, edits files in place, and commits each change, so every step is reviewable and revertible with the tools you already use.

Best for repo-scale changes from the command line, and for working over ssh on a cluster or server where an editor is not practical.

Get it: aider.chat — pip install aider-install

export OPENAI_API_BASE=https://tokens.velella.ca/v1
export OPENAI_API_KEY=$(cat ~/.config/spigot/key)
aider --model openai/qwen3.6-35b-a3b

Open WebUI browser · self-hosted

A ChatGPT-style web interface you run yourself. No coding involved once it is up: open a browser, type, get answers, keep conversations.

Best for people who do not want a terminal or an editor at all — and for putting one shared chat window in front of a group.

Get it: openwebui.com · source (needs Docker)

docker run -d -p 3000:8080 \
  -e OPENAI_API_BASE_URL=https://tokens.velella.ca/v1 \
  -e OPENAI_API_KEY=$(cat ~/.config/spigot/key) \
  -v open-webui:/app/backend/data \
  --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Then open http://localhost:3000. The model appears in the model list.

It will ask you to create an account with a name, an email and a password. That is not a sign-up. Open WebUI is a multi-user application that you are running yourself, so it has its own login; the account is written to the container's database in your open-webui volume and goes nowhere else. The email is only an identifier — nothing is sent to it and nothing verifies it. By their design the first account created becomes the administrator, and any later sign-up on that instance stays pending until the administrator approves it.

Web search is the client's job, not the model's. No language model browses on its own; searching works only when your client offers a search tool and runs it. In Open WebUI: Admin Panel → Settings → Web Search, choose a provider (DuckDuckGo needs no key), then switch Web Search on in the chat. The endpoint supports tool-calling; it does not supply the tools.

Give the password real thought, though. Whoever can open that page can spend your key — it is stored in the container, not typed per message. If you are the only user, bind it to your own machine only, which is one edit to the command: -p 127.0.0.1:3000:8080. Without the 127.0.0.1, Docker publishes the port on every interface.

The mismatched numbers are not a typo. 3000:8080 means "port 3000 on your machine maps to 8080 inside the container", and the container serves on 8080 — so 3000:3000 gives you a browser pointed at nothing. If the page does not load: docker ps (is it running?) and docker logs open-webui (did it start?). One honest caveat: $(cat …) keeps the key out of your shell history, but it is still readable in the container's environment via docker inspect — inherent to giving a container a credential, so run this on a machine you control.

The OpenAI SDKs python · node

The official client libraries, pointed at this endpoint instead of OpenAI's. Everything built on them — LangChain, LlamaIndex, your own scripts — works the same way.

Best for building something: batch jobs, analysis pipelines, notebooks, a tool of your own.

Get it: pip install openai · openai-python · npm i openai

import os
from openai import OpenAI

client = OpenAI(base_url="https://tokens.velella.ca/v1",
                api_key=open(os.path.expanduser("~/.config/spigot/key")).read().strip())
r = client.chat.completions.create(
        model="qwen3.6-35b-a3b",
        messages=[{"role": "user", "content": "hello"}],
        max_tokens=1024)
print(r.choices[0].message.content)

import OpenAI from "openai";
import { readFileSync } from "fs";
import { homedir } from "os";

const client = new OpenAI({
  baseURL: "https://tokens.velella.ca/v1",
  apiKey: readFileSync(`${homedir()}/.config/spigot/key`, "utf8").trim(),
});
const r = await client.chat.completions.create({
  model: "qwen3.6-35b-a3b",
  messages: [{ role: "user", content: "hello" }],
  max_tokens: 1024,
});