amber-ai

A local, offline AI co-pilot for Amber. It reads your live tables before it answers — their names, column types, attributes and row counts — so its suggestions are about your session, not about a generic K tutorial.

amber> trades:gentq 1000000

amber> \ai average price per symbol in the last hour
select avg px by sym from trades where time>.z.p-01:00

amber> select last px by sym from trads
error[E0101]: Undefined variable `trads`

amber> \ai why
The name `trads` does not exist. This workspace has `trades`
(table: time:P sym:S`g px:F size:I, 1,000,000 rows) — you are one
character off. `sym` already carries the `g attribute, so the
grouped select will use the index.

Four things that make it different from a chat window

Install

git clone https://github.com/BonucciAndrea/amber-ai.git
cd amber-ai
./install.sh /path/to/amber

The path is optional — ./install.sh finds a sibling ../amber, $AMBER_HOME, ~/amber, or an amber on your PATH. It then checks your toolchain, checks the target's version and extension ABI (and refuses politely if they do not match), copies src/net.c, src/net.h and src/ai_ext.c into ext/ plus lib/ai.k into lib/, runs the engine's own build.sh, verifies the `ai / `aio verbs and \ai against Amber's own suite, and probes 127.0.0.1:11434 — distinguishing nothing listening, a live Ollama, a live Ollama with no models pulled, and something else squatting on the port, each with its own fix.

Then start a model

Any local backend that speaks Ollama, llama.cpp or an OpenAI-compatible /v1 endpoint will do:

curl -fsSL https://ollama.com/install.sh | sh    # linux / wsl2  (macOS: brew install ollama)
ollama serve &
ollama pull qwen2.5-coder:0.5b                   # ~400 MB, runs on a laptop CPU

Or run ./setup-ollama.sh, which walks through the same thing and asks before every system change. Without a backend the agent is a no-op: it says so once, and the REPL is exactly Amber.

Shell alias

alias amber-ai='AMBER_NATIVE=1 AMBER_AI=1 \
  AMBER_AI_URL="http://127.0.0.1:11434/api/generate" \
  AMBER_AI_TIMEOUT_MS=10000 "$AMBER_HOME/a"'

alias amber-noai='AMBER_AI=0 "$AMBER_HOME/a"'    # agent off for one session

\ai commands

\ai profile and \ai why read your actual workspace first — the row counts, types and attributes in their output are measured, not generated.

Vector execution: Tab is layered so the network is last

And usually never reached at all.

A model suggestion is rendered as dim ghost text after the cursor and is never inserted until you accept it with a second Tab (or →, or Ctrl-F). Any other keystroke discards it. Accepted suggestions are recorded as feedback.

amber> select avg px by sym from tr█ades where sym=`AAPL      <- dim = suggested, not typed

Persistent memory

A local model cannot be fine-tuned while you type, so "learning" here means persistent few-shot context. Every line that ran cleanly, every schema this workspace has held and every accepted Tab suggestion is appended to ~/.amber_ai_memory.k, one self-describing Amber expression per line:

ai.rec["q";1755512345;3;"select sym,px from trades";"trades quotes"]
/       kind  epoch-s  hits  text                    context

Loading it is simply evaluating it, so it stays human-readable and hand-editable. \ai memory shows it, \ai forget erases it, AMBER_AI_MEMORY=/path moves it (per-project memories work), and deleting the file is always safe.

Tuning the budget

A 7B on CPU generates a few tokens a second, so a 128-token answer can take 30 s while a 0.5B does it in 4 — and Ollama unloads an idle model after five minutes, so the load is paid again and again inside the same deadline.

amber> \ai warm            # load the model now, on its own budget, and measure

\ai warm asks for a single token, so it returns as soon as the weights are resident rather than when an answer is finished. It then times a short generation and, if your measured tokens/sec cannot produce a full answer inside the current budget, raises the budget and says so. It measures your machine rather than guessing from the model's name. Every request also carries keep_alive, so the backend holds the model for 30 minutes after each call.

Each command scales off AMBER_AI_NUM_PREDICT rather than using it directly, because a one-line answer and a table profile do not need the same room:

Setting AMBER_AI_NUM_PREDICT=48 scales all three down together and roughly halves the wait. \ai warm sizes the answer budget from the longest of them, so raising the caps cannot move the timeout to \ai profile.