AfriLink gives you one-line access to a dedicated NVIDIA A100 80 GB hosted by OpenToken for training (any framework — YOLOv8, custom PyTorch, etc.) and finetuning (LoRA/QLoRA for LLMs). The SDK handles authentication, dataset upload, GPU-aware docker run, status polling, model download, and per-job billing. Install with pip install 'afrilink-sdk[build]'.

pip install 'afrilink-sdk[build]'

The [build] extras pull cryptography + requests, needed for the custom-container path. Without them only the curated client.train() and client.finetune() paths work.

The core package has zero required dependencies — heavy libraries are only loaded at the point you use them and are pre-installed in most notebook environments.

As of v0.8.x the SDK uses stateless API-key auth — no email/password prompts, no 12-hour certificate refreshes.

Get an API key

1. Sign up at dataspires.com.
2. Open Profile → AfriLink SDK keys, click Create new key, copy the afk_live_… value (shown once).
3. Add it to your notebook environment under the name AFRILINK_API_KEY.

Where to set the key

What happens at auth time

Both phases together take ~1–2 seconds. The session keeps the JWT in memory for the kernel lifetime — no on-disk state. To rotate the key, revoke it on the dashboard and mint a new one.

The dedicated GPU node the SDK runs on, hosted by opentoken.global:

Per-job memory guide for 1× A100 80 GB:

Billing: $2.00 / GPU-hour, charged per completed GPU-minute (minimum 1 minute). Credits deducted automatically from your DataSpires balance — invoice appears on the Billing Dashboard in real time.

Use client.list_available_models() to browse, or filter with size="tiny". For anything outside this registry, use client.build_image() with a custom model_source.

The A100 backend has a single GPU; gpus>1 silently clamps to 1 with a console note.

DataFrame should have a text column with the full prompt + response (Alpaca-style or chat template). Inside the container the dataset is at /workspace/job/input/.

Use client.train() to run any training script in a curated container. For LoRA/QLoRA LLM fine-tuning, use client.finetune() instead.

job = client.train(    script="train_yolo.py",        # your training script    container="afrilink-yolo",      # curated container (Ultralytics + PyTorch)    data="./dataset/",              # uploaded automatically over SSH    data_config="dataset.yaml",     # YOLO config file    gpus=1,                         # A100 backend has 1 GPU; clamps automatically    time_limit="02:00:00",)result = job.run(wait=True)print(job.get_logs(tail=50))client.download_model(result["job_id"], "./yolo-out")

Available curated containers:

Need a different stack? Use client.build_image() / client.build_and_train() below.

If the curated containers don't have the framework, version, or model you need, define it yourself. Cloud Build builds the image, Artifact Registry hosts it, the OpenToken A100 runs it ephemerally.

# Define exactly the environment your training needs.spec = dict(    base_image="pytorch",                                # preset    pip_packages=["transformers>=4.45", "accelerate>=0.34"],    apt_packages=["git"],    model_source={        "kind": "huggingface",        "id": "Qwen/Qwen2.5-0.5B-Instruct",    },)# Check the cache first - skip the build if a matching image already exists.hit = client.find_existing_image(**spec)if hit:    print("cache hit:", hit["image"])# Build (or skip if cached) + run + cleanup, in one call.result = client.build_and_train(    **spec,    script="my_train.py",    gpus=1,    time_limit_hours=1.0,    reuse_existing_image=True,   # default; False forces a fresh build)client.download_model(result["run"]["job_id"], "./output")

Presets for base_image:

You can also pass any full image:tag string.

Model sources for model_source=:

Models are fetched at container runtime, not baked at build time — keeps your images thin (~2 GB instead of 7+ GB) and means you can iterate on deps without re-shipping weights. The downloaded model lands at /workspace/models/<sanitised_id>/ and the path is exposed via the MODELS_DIR env var to your script.

For gated HF models (Llama, Gemma, etc.): add HUGGINGFACE_TOKEN as a notebook secret and the SDK forwards it to the container automatically.

Cache: the SDK hashes your spec (base_image + pip/apt packages + model source) and bakes the hash into the image as a Docker label. Re-running the same spec hits the cache instantly — first build takes ~5 min, subsequent runs go straight to the A100.

AfriLinkClient

TrainJob / FinetuneJob (returned by client.train() / client.finetune())

run() returns a dict with job_id, container_id, status, output_dir, and a billing sub-dict with the GPU-minutes and cost charged. Always check result["status"] before downloading.

Pay-as-you-go at $2.00 per GPU-hour, billed by wall-clock with a 1-minute minimum. Build-time on Cloud Build is absorbed by the platform — you only pay GPU-time. Add credits via card payment or redeem voucher codes on your Billing Dashboard.

Query the inline reference manual from any notebook cell — no internet required:

import afrilinkafrilink/help          # index of all topicsafrilink/quickstart    # getting startedafrilink/auth          # authenticationafrilink/finetune      # finetune parameters & modesafrilink/training      # general training jobsafrilink/specs         # A100 hardware spec sheetafrilink/datasets      # dataset formatsafrilink/billing       # rates, credits, invoices

Once downloaded, adapter weights work directly with standard HuggingFace tooling.

Export to GGUF & run with Ollama

from transformers import AutoModelForCausalLM, AutoTokenizerfrom peft import PeftModel# Merge adapter into base modelbase = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B")merged = PeftModel.from_pretrained(base, "./my-model").merge_and_unload()merged.save_pretrained("./my-model-merged")AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B").save_pretrained("./my-model-merged")# python convert_hf_to_gguf.py ./my-model-merged --outfile my-model.gguf# ./llama-quantize my-model.gguf my-model-q4.gguf Q4_K_M# ollama create my-model -f Modelfile  &&  ollama run my-model

Publish to HuggingFace Hub

from huggingface_hub import HfApiapi = HfApi(token="hf_...")repo_id = "your-username/my-finetuned-model"api.create_repo(repo_id, exist_ok=True)api.upload_folder(folder_path="./my-model", repo_id=repo_id)          # adapter onlyapi.upload_folder(folder_path="./my-model-merged", repo_id=repo_id)   # full merged modelapi.upload_file(path_or_fileobj="./my-model-q4.gguf",                path_in_repo="my-model-q4.gguf", repo_id=repo_id)       # GGUF