gla-api

The official library for GLA models — Graph-Language Assistant, by ATEC (Advancement Through Engineering & Creation).

gla-api runs a trained GLA model on your own computer or server and manages everything around it: an OpenAI-compatible API server for your websites and apps, API keys with limits, a background service you can start and stop, a chat in the terminal, speed tests, backups and a full system check. Windows and Linux, one or many NVIDIA GPUs.

pip install gla-api

Library page: https://pypi.org/project/gla-api/

Version	1.2.6
Runs	GLA 2.0 and GLA 3.0 (the version is detected from the model folder)
Code	compiled to native code (Windows .pyd, Linux .so)
Operating systems	Windows 10/11 (64-bit), Linux (x86-64)
Python	3.11, 3.12, 3.13 or 3.14 (also the free-threaded 3.14t)
GPU	NVIDIA, any number; a 3.x model can be split over 2 or 3 GPUs per copy (a CPU works for testing)
Precision	FP32, BF16, FP16, FP8, FP4 — tested on your GPU, with automatic fallback
License	Proprietary (ATEC). Not open source — see License

---

Contents

1. Install
2. Start in one minute
3. Every command
4. Run the API server
5. API keys
6. Settings
7. Use it from Python
8. Call the server from any language
9. GPUs, splitting and precision
10. Security
11. Troubleshooting
12. About this release

---

1. Install

pip install gla-api

That one command installs the model runtime and the API server. Check it:

gla-api --version
gla-api doctor --quick

NVIDIA GPU on Windows: pip installs the CPU build of PyTorch by default. For your GPU, install the CUDA build first (once), then the library:

pip install torch --index-url https://download.pytorch.org/whl/cu128
pip install gla-api

Update later with pip install --upgrade gla-api (gla-api check-update tells you when there is a new version).

pip not found on Windows? Use py -m pip install gla-api and py -m gla_api <command> — they work the same everywhere. To get the short commands, reinstall Python with "Add python.exe to PATH" ticked.

Several servers sharing one database (optional): pip install "gla-api[server]" adds Redis and PostgreSQL support. A single server needs nothing extra.

---

2. Start in one minute

mkdir my-gla && cd my-gla
gla-api setup --owner my-website

setup does everything a new folder needs, in one step:

1. creates .env with a secret admin token and the model folder Model_GLA/;
2. checks the model folder;
3. creates your first API key and prints it (once — copy it).

Then copy the exported GLA model's files into Model_GLA/ and:

gla-api start        # API server in the background:  http://127.0.0.1:8000/v1
gla-api status       # running? model loaded? how busy?
gla-api chat "Write a Python function that reverses a string"
gla-api stop

A model folder holds only data — weights (safetensors), configuration, tokenizer and documents. No code is ever run from it. A folder named Model_CodeMind/ is found too.

---

3. Every command

Every command has its own help: gla-api <command> --help. All of them also work as py -m gla_api <command> (or python -m gla_api <command>).

Set up and check

command	what it does
gla-api setup [--owner NAME] [--start]	everything for a new folder: .env, Model_GLA/, first API key, next steps
gla-api init	only .env (admin token) and Model_GLA/
gla-api doctor [--quick]	full check: Python packages, PyTorch, every GPU, FP8 self-test, model files (SHA-256), tokenizer, disks, key database → READY or the exact problem
gla-api info	model version, size, runtime, PyTorch, GPUs (does not load the model)
gla-api verify	checks every model file against its SHA-256
gla-api prefetch	downloads the code-parser grammars once (run before taking a machine offline)

Run the server

command	what it does
gla-api start [options]	starts the API server in the background (keeps running after you close the window)
gla-api stop [--timeout 60] [--force]	stops it — answers that are running finish first
gla-api restart [options]	stop + start (same options as before unless you give new ones)
gla-api status [--json]	running or not, model ready or loading, uptime, workers, queue, served, errors
gla-api logs [-n 50] [-f]	the background server's log (-f keeps following it)
gla-api serve [options]	runs the server in this window (Ctrl+C stops it); --supervise restarts it after a crash

start, restart and serve take the same options: --host, --port, --gpus, --split, --precision, --fp8, --workers-per-gpu, --min-workers-per-gpu, --max-queue, --max-connections, --max-output-tokens, --default-rpm, --default-concurrency, --request-timeout, --hooks, --ssl-certfile/--ssl-keyfile, --docs (gla-api serve --help). start --wait-ready waits until the model is loaded.

Use the model

command	what it does
gla-api chat "question"	one answer
gla-api chat	a conversation in the terminal (/mode code, /lang rust, /clear, /exit)
gla-api chat --code --language rust "..."	a code answer in a chosen language
gla-api chat --url http://HOST:8000 --key gla_live_...	ask a running server (streams the answer)
gla-api chat --json "..."	the full answer as JSON (confidence, reason, questions, ...)
gla-api bench [-n 5] [--url ...]	answer speed: seconds per answer, tokens per second

API keys and data

command	what it does
gla-api key create --owner NAME [limits]	a new key, printed once
gla-api key list [--owner NAME] [--all] [--json]	every key (never the secrets)
gla-api key show ID	one key's settings
gla-api key update ID [limits]	change limits, name, allowed IPs/websites, expiry (--expires-days 0 = never)
gla-api key rotate ID [--grace 3600]	a new secret with the same settings (the old one can keep working for a while)
gla-api key revoke ID	disable a key at once
gla-api key usage ID / --owner NAME	requests and tokens per day
gla-api audit	recent admin actions (created, updated, rotated, revoked ...)
gla-api gen-token	a strong random token
gla-api backup [--out DIR]	a safe copy of the key database, its secret and .env (also while the server runs)

Settings and updates

command	what it does
gla-api config show	every setting of this folder (secrets masked) and the main values in use
gla-api config set NAME VALUE	save one, e.g. config set port 9000
gla-api config unset NAME	remove one
gla-api config path	where the .env file is
gla-api check-update	is a newer gla-api on PyPI?
gla-api service show | install | remove	keep the server running: a systemd service (Linux) or a task at log-on (Windows)

--dir FOLDER before any command works in that folder instead of the current one: gla-api --dir D:\gla status.

---

4. Run the API server

gla-api start                       # this computer only: http://127.0.0.1:8000/v1
gla-api start --host 0.0.0.0        # reachable from other computers in your network
gla-api start --split 3             # GLA 3.x: each copy of the model spread over 3 GPUs

The server uses every GPU of the machine, loads as many copies of the model per GPU as fit, adds copies under load and releases them when idle, and spreads the requests over all of them. A crashed or frozen copy is restarted on its own; a GPU that cannot run the chosen precision steps down safely (fp4 → fp8, fp8 kernels → bf16). It is OpenAI-compatible:

endpoint	for
POST /v1/chat/completions	answers (with "stream": true the answer arrives piece by piece)
POST /v1/completions	plain text completion
POST /v1/code/validate	checks code: valid, score, issues
POST /v1/ground	exact math and physics with units
GET /v1/models, /v1/me, /v1/usage	the model, this key's limits, this key's usage
GET /health, /ready	is the process up / is the model loaded
/admin/keys ..., /admin/stats, /admin/workers, /admin/audit, POST /admin/model/reload	management with the admin token (reload = new model without stopping)
GET /metrics	Prometheus metrics

API description: gla-api config set docs 1, gla-api restart, then open http://127.0.0.1:8000/docs (or /openapi.json). Off by default, so a public server does not show them. The model folder also contains API_REFERENCE.md.

Extra options per request go in a gla object: {"gla": {"mode": "code", "language": "rust"}} (mode: auto, text or code). Answers carry the same object back with confidence, uncertain, reason and questions.

Streaming behind a proxy. While the model writes, a streaming answer sends a keep-alive line every 15 seconds (stream_keepalive), so proxies such as Cloudflare or nginx do not close a long answer.

Safe retries. Send Idempotency-Key: <unique id>: a retry with the same key and body returns the first answer instead of generating again (kept 24 h). gla_api.Client does this for you.

Your own code around every answer: gla-api start --hooks my_hooks.py, where my_hooks.py defines before_request(ctx) (change or refuse a request) and/or after_response(ctx, result) (change the answer). Both may be async def.

Always on: gla-api service install — on Linux it writes a systemd service (serve --supervise, restarted after a crash and at boot), on Windows a task that starts the server when you log on. gla-api service show prints it first.

Public internet: put HTTPS in front (a reverse proxy such as Cloudflare, Caddy or nginx, or --ssl-certfile/--ssl-keyfile) and keep trusted_proxies set to the proxy's address.

---

5. API keys

Apps and websites call the server with an API key: Authorization: Bearer gla_live_....

gla-api key create --owner my-website --rpm 120 --daily-tokens 2000000 --allowed-origins https://example.com
gla-api key list
gla-api key update KEY_ID --rpm 0            # 0 = unlimited
gla-api key rotate KEY_ID --grace 3600       # new secret; the old one works one more hour
gla-api key usage --owner my-website
gla-api key revoke KEY_ID

Limits per key — each can be 0 for unlimited: requests per minute (--rpm), tokens per day (--daily-tokens), parallel requests (--concurrency), tokens per answer (--max-tokens), priority 0–9 (--priority), allowed IP addresses (--allowed-ips), allowed websites (--allowed-origins), expiry (--expires-days), scopes (--scopes: chat, code, validate, ground, usage) and test keys (--env test).

Keys are stored only as HMAC-SHA256 hashes: even a stolen database contains no usable keys. Keys made by earlier versions (cm_...) keep working. A key that appears in an answer is redacted.

---

6. Settings

Settings live in the .env file of the folder you run the server from (made by setup/init). Change them with gla-api config set NAME VALUE (then gla-api restart), or set the same names as environment variables with the GLA_ prefix (GLA_PORT=9000). The earlier prefix CODEMIND_ still works.

name	default	meaning
model	./Model_GLA	model folder
host	127.0.0.1	0.0.0.0 = reachable from the network
port	8000
gpus	auto	auto, 0,1, or cpu
split	off	GLA 3.x: 2 or 3 GPUs per copy, auto = 3 when the GPUs divide into threes, else 2
precision	auto	auto, fp32, bf16, fp16, fp8, fp4
fp8	auto	FP8 kernel: rowwise, tensor, dequant, off
max_workers_per_gpu / min_workers_per_gpu	3 / 1	model copies per GPU (fitted to memory and load)
admin_token	made by init	controls /admin and keys — keep it secret
admin_ips	local	where /admin may be called from: local (this computer and private networks), a list of IPs / networks, or * (anywhere — the token is still needed)
ip_rpm	0	requests per minute per client address on /v1 (0 = off; behind a proxy set trusted_proxies)
verify_model	first	model files' SHA-256 before the server loads them: first (once, remembered until a file changes), always, size (sizes only)
default_rpm	60	requests per minute for new keys (0 = unlimited)
default_concurrency	16	parallel requests per key
max_output_tokens	8192	per answer (0 = unlimited)
max_queue	1024	waiting requests before "busy" (0 = unlimited)
max_connections	8192	open connections (0 = unlimited)
request_timeout	300	seconds per request
stream_keepalive	15	seconds between keep-alive lines of a streaming answer
cache_ttl	600	seconds a deterministic answer (temperature 0) is reused
cors_origins	—	websites allowed to call from a browser
trusted_proxies	127.0.0.1	your HTTPS proxy's address
data_dir	./gla_api_data	keys, usage, audit log, server log, backups
database_url / redis_url	SQLite / none	PostgreSQL and Redis for several servers (GLA_KEY_PEPPER must then be the same on all)
hooks	—	your before_request / after_response module
safety / redact_output	1 / 1	content screening / secret redaction
docs	0	/docs and /openapi.json
log_level / log_json	INFO / 0

gla-api config show lists what is set and what is in use. A JSON file with the same names can be given with gla-api --config settings.json serve.

---

7. Use it from Python

The model in your own program

import gla_api

model = gla_api.load("./Model_GLA")              # first GPU (CPU if none); FP8 where it pays off

print(model.chat("What is the difference between a process and a thread?"))

ans = model.code("A thread-safe LRU cache", language="python")
print(ans.text, ans.confidence, ans.uncertain)

for piece in model.stream("Explain this regex: ^\\d{3}-\\d{4}$"):
    print(piece, end="", flush=True)

print(model.validate("SELECT * FROM users WHERE id = ' + user_id", language="sql")["issues"])
print(model.ground("speed of a 2 kg object after falling 10 m"))

big = gla_api.load("./Model_GLA", precision="fp8", devices="all")      # one copy on every GPU
answers = big.chat_many([f"Explain error code E{i}" for i in range(100)])     # spread over all of them
big.close()

huge = gla_api.load("./Model_GLA", devices="all", split=3)   # GLA 3.x: each copy over 3 GPUs (split=2: over 2)

load(path, precision="auto", device="auto", devices=None, split=False, fp8="auto", safety=True, verify=False, warmup=True, threads=0, web_search=False, before=None, after=None) — gla_api.load("echo") gives a tiny test model (no GPU, no files) for trying out your code.

chat(prompt | messages=[...], system="", mode="auto"|"text"|"code", language=None, temperature=0.8, top_p=0.92, max_tokens=0, stop=None) returns an Answer: text, mode, uncertain, confidence, reason, questions, sources, language, language_supported, score, finish_reason, usage, raw. str(answer) is the text.

Also: code(), stream(), chat_many(), achat() / acode() (asyncio), validate(), ground(), count_tokens(), add_hook(), info, devices, runtime, close(); with gla_api.load(...) as model: closes it for you.

A running server (no GPU or model files on this machine)

import gla_api

gla = gla_api.Client("http://127.0.0.1:8000", api_key="gla_live_...")   # or GLA_URL / GLA_API_KEY
print(gla.chat("Explain what a mutex is"))
print(gla.code("Binary search", language="rust").text)
for piece in gla.stream("Write a haiku about graphs"):
    print(piece, end="", flush=True)
print(gla.ready(), gla.models(), gla.me(), gla.usage(days=7))

admin = gla_api.Client("http://127.0.0.1:8000", admin_token="...")      # or GLA_ADMIN_TOKEN
new = admin.create_key("my-website", rpm=120)
print(new["key"])                                                        # shown only here
admin.rotate_key(new["id"], grace_seconds=3600)
print(admin.stats())

async with gla_api.AsyncClient("http://127.0.0.1:8000", api_key="gla_live_...") as gla:    # asyncio programs
    print(await gla.chat("Hello"))
    async for piece in gla.stream("Tell me about graphs"):
        print(piece, end="")

The client needs nothing but Python — use it on your web server while the model runs on a GPU machine. A busy or rate-limited answer (503 / 429) is retried after the server's Retry-After (retries=2), always with an Idempotency-Key, so a retry never produces a second answer. Errors raise gla_api.APIError with status, code, message, retry_after and request_id.

---

8. Call the server from any language

Any OpenAI SDK works — point it at your server:

from openai import OpenAI
client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="gla_live_...")
r = client.chat.completions.create(model="gla-3.0", messages=[{"role": "user", "content": "Hello"}])
print(r.choices[0].message.content)

const r = await fetch("http://127.0.0.1:8000/v1/chat/completions", {
  method: "POST",
  headers: { "Authorization": "Bearer gla_live_...", "Content-Type": "application/json" },
  body: JSON.stringify({ messages: [{ role: "user", content: "Hello" }], gla: { mode: "auto" } }),
});
console.log((await r.json()).choices[0].message.content);

curl http://127.0.0.1:8000/v1/chat/completions -H "Authorization: Bearer gla_live_..." \
     -H "Content-Type: application/json" -d '{"messages":[{"role":"user","content":"Hello"}]}'

The model ID is gla-<version> (see GET /v1/models); any ID is accepted.

---

9. GPUs, splitting and precision

precision	weights	use it for
fp32	4 bytes	exact reference
bf16	2 bytes	the same quality, half the memory (RTX 30xx and newer)
fp16	2 bytes	older GPUs without BF16
fp8	1 byte	FP8 tensor cores on RTX 40xx/50xx, Hopper, Blackwell (elsewhere FP8 storage, BF16 compute)
fp4	~5 bits	the smallest
auto		FP8 when the GPU passes a numeric self-test, else BF16; FP32 on CPU

Every choice is tested on the real GPU and falls back safely instead of failing. The router, the writer's output layer and small layers stay at the compute precision. Approximate memory for one copy of GLA 3.0 (≈ 21.2 B parameters): ≈ 45 GB in BF16, ≈ 24 GB in FP8, ≈ 14 GB in FP4; GLA 2.0 (≈ 6.1 B): ≈ 12 GB, 6 GB, 4 GB.

Splitting (GLA 3.x). When one GPU is too small for a whole copy, spread each copy over several GPUs:

	GPU 1	GPU 2	GPU 3
split=3	encoder + Brain A + router	Brain B + Brain C	writer
split=2	encoder + Brain A + Brain B	Brain C + writer

gla_api.load(path, devices="all", split=3) in Python; gla-api start --split 3 (or config set split 3) for the server, which then runs one copy per group of GPUs (6 GPUs → 2 copies). split=True / auto picks 3 when the GPUs divide into threes, else 2.

---

10. Security

• Model folders are data only (safetensors, no pickle): loading a model never runs code from it. The server checks every file's SHA-256 before its first load (verify_model); gla-api verify checks them by hand.
• Native code. The library and the model runtime are compiled to native machine code, carry no source, comments or docstrings, and refuse to run when an installed runtime file was changed (reinstall to repair).
• This machine only by default: the server listens on 127.0.0.1 unless you pass --host 0.0.0.0.
• API keys are stored as HMAC-SHA256 hashes; per-key limits, IP and website allow-lists, expiry, rotation with a grace period and an audit log of every admin action; repeated wrong keys lock the address out for a while (logged as auth.lockout). Keys never appear in full in logs or answers.
• The admin token controls /admin, which by default answers only this computer and private networks (admin_ips); keep .env private (gla-api backup copies it — keep backups private too).
• gla-api doctor also reports risky settings: plain HTTP on a public address, a short admin token, an open admin API, screening switched off, readable secret files.
• Request size limits (checked before a body is read), content screening of requests and answers, and redaction of secrets (including API keys) in answers.
• No internet needed to answer. Only the code-parser grammars are downloaded once (gla-api prefetch).
• For the public internet: HTTPS in front, --host 0.0.0.0 only behind it.

---

11. Troubleshooting

you see	do this
pip / gla-api is not recognized (Windows)	use py -m pip ... and py -m gla_api ..., or reinstall Python with "Add python.exe to PATH"
doctor: no trained model found	normal before you have a model: copy the exported model files into Model_GLA/
doctor: GPUs - 0 found	install the CUDA build of PyTorch (Install) and a current NVIDIA driver
FP8 self-test - selected 'dequant'	normal on GPUs without FP8 tensor cores — FP8 storage with BF16 compute is used
status: model: loading	the model is still loading — wait, or gla-api start --wait-ready
cannot reach http://...	the server is not running: gla-api start, then gla-api logs
out of GPU memory	--precision fp8 or fp4, fewer --workers-per-gpu, or --split 2 / 3 for GLA 3.x
split needs a 3.x model	GLA 2.0 runs on one GPU per copy — drop split
model folder is incomplete	copy the whole folder again; gla-api verify names the bad file
this process already runs the v2 runtime	GLA 2.x and 3.x models need separate processes
a long streaming answer is cut by a proxy	lower stream_keepalive (e.g. 10) or raise the proxy's read timeout
Admin API not allowed from this address	call it from the server itself or your private network, or set admin_ips
model files failed the check	a file is damaged or incomplete: copy the model folder again, then gla-api restart
the model runtime of this installation was changed	pip install --force-reinstall gla-api

---

12. About this release

1.2.6 is the current version. The first public release was 1.2.5; 1.2.6 has the same code with this corrected library page. Later versions will follow; this page always describes the version shown at the top.

pip install gla-api

What 1.2.6 includes:

• Both model generations: runs GLA 2.0 and GLA 3.0 (connected graphs, global attention, 24 / 18 / 34-layer brains, 40-layer writer); the generation is detected from the model folder (Model_GLA, Model-GLA or Models/Model-GLA) or from a training checkpoint's metadata.
• Fast answers (GLA 3.0): the answer is written with a preallocated memory of the text so far, and each new word is one recorded GPU program (CUDA graph) instead of hundreds of separate launches - about 10x more words per second than a plain loop on the same GPU, with temperature, top-p, top-k, repetition penalty and minimum length all applied on the GPU.
• Fast understanding (GLA 3.0): the graph layers compute every node type and relation in one pass, and each batch goes to the GPU in one transfer.
• Accurate code graphs: assignments count as definitions, C / C++ parameters and declarations take part in data flow, and the parser is safe to use from many threads at once.
• Honest answers: an answer the model is not sure of comes back marked (uncertain, reason, questions); an unreadable answer comes back as "not sure" with reason="unreadable".
• Many GPUs: one copy per GPU, or each 3.x copy split over 2 or 3 GPUs (split=3, --split 3).
• An OpenAI-compatible server (Starlette + uvicorn) with streaming keep-alive behind proxies, idempotent retries, per-key limits, IP and website allow-lists, an audit log, and gla-api service install to keep it running.
• Python client: Client, AsyncClient, Model.achat() / acode(), wait_ready(), async hooks, stop sequences, validate(language="auto").
• Protection: native code for Windows and Linux; the model runtime is checked against its SHA-256 before it runs; model files are checked before the first load (verify="first"); /admin answers only this computer and private networks by default.
• Python 3.11 - 3.14, including the free-threaded 3.14t (GIL off). On 3.14 install the code grammars with pip install "gla-api[grammars]"; 3.11 - 3.13 get them automatically.

---

License

GLA models and gla-api are proprietary software of ATEC (Advancement Through Engineering & Creation). They are licensed, not sold, and are not open source. Each GLA model version comes with its own license, which governs how you may use it; in short, you may use GLA 2.0 and 3.0 commercially to power your own websites, apps and API services, but you may never sell the model, and you must always credit ATEC:

Built with GLA <version> by ATEC

The library is licensed only to run GLA models and may not be decompiled or reverse-engineered. Licenses and technical documentation: https://github.com/ATECTechnologies/Graph-Language-Assistant