Check your email for a password reset link.
One last step to join the waitlist! We've sent a verification link to your inbox. Please check your email and click the link to confirm your spot on the waitlist.
Don't see it? Check your spam folder or contact support if you need assistance.
Finetune LLMs on high-performance GPU clusters directly from Google Colab, Jupyter, or any Python notebook — no cloud provisioning required.
AfriLink is a Python SDK that gives you one-line access to A100 GPUs on distributed HPC backends. Authenticate with your DataSpires account, pick a model, pass your dataset, and the SDK handles everything: secure tunnelling, dataset upload, SLURM job submission, status polling, model download, and per-job billing. Install with pip install afrilink-sdk and start finetuning in minutes.
Go from raw dataset to trained LoRA adapter in a single client.finetune().run() call — no SLURM scripts, no SSH, no container setup.
Two-phase auth: DataSpires credentials for billing, plus automated SSH certificate provisioning for HPC access. All handled headlessly inside your notebook.
Jobs run on NVIDIA A100 nodes via SLURM scheduling. Support for additional distributed backends is coming soon.
Works identically from Google Colab, AfriColab, local Jupyter, or any Python environment — no platform lock-in.
pip install afrilink-sdk
from afrilink import AfriLinkClient
client = AfriLinkClient()
client.authenticate() # DataSpires + HPC credentials
job = client.finetune(
model="qwen2.5-0.5b",
training_mode="low", # QLoRA, 4-bit, rank 8
data=your_dataframe,
gpus=1,
time_limit="01:00:00",
backend="cineca", # HPC backend (default: "cineca")
)
result = job.run(wait=True)
# Download & run inference (only if job succeeded)
if result["status"] == "completed":
client.download_model(result["job_id"], "./my-model")
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
base = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B")
model = PeftModel.from_pretrained(base, "./my-model")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B")
out = model.generate(**tokenizer("Hello!", return_tensors="pt"), max_new_tokens=64)
print(tokenizer.decode(out[0], skip_special_tokens=True))
Install from PyPI:
pip install afrilink-sdk
The package has zero required dependencies — heavy libraries like PyTorch, Transformers, and PEFT are only needed at the point you use them and are pre-installed in most notebook environments.
AfriLink uses a two-phase auth flow, both handled inside a single client.authenticate() call:
| Phase | What Happens | User Action |
|---|---|---|
| 1. DataSpires | Validates your account for billing and telemetry | Enter email + password when prompted |
| 2. HPC | Automated SSH certificate provisioning for cluster access | Fully automatic |
You can also pass credentials explicitly: client.authenticate(dataspires_email="...", dataspires_password="...")
After authentication you get an SSH certificate valid for ~16 hours, a SLURM job manager, SCP transfer manager, and telemetry tracker — all ready to go.
The SDK supports multiple HPC backends. Specify the backend parameter in client.finetune() to choose your cluster:
| Backend | Provider | Region | Status |
|---|---|---|---|
cineca | CINECA Leonardo (EuroHPC) | Bologna, Italy | Available (default) |
eversetech | EverseTech | — | Coming soon |
agh | AGH | — | Coming soon |
acf | ACF | — | Coming soon |
The SDK ships with a curated registry of pre-configured models ready for finetuning. Use client.list_available_models() to browse, or filter by size with client.list_available_models(size="tiny").
| Model | Type | Parameters | Min VRAM |
|---|---|---|---|
| Qwen 2.5 0.5B | Text | 0.50B | 4 GB |
| Gemma 3 270M | Text | 0.27B | 2 GB |
| Llama 3.2 1B | Text | 1.00B | 4 GB |
| DeepSeek R1 1.5B | Text | 1.50B | 6 GB |
| Ministral 3B | Text | 3.30B | 8 GB |
| SmolVLM 256M | Vision | 0.26B | 2 GB |
| InternVL2 1B | Vision | 1.00B | 4 GB |
| Moondream 2 | Vision | 1.90B | 8 GB |
| Florence 2 Base | Vision | 0.23B | 4 GB |
| LLaVA 1.5 7B | Vision | 7.00B | 16 GB |
Choose a training intensity that matches your dataset size and quality requirements:
| Mode | Strategy | Quantization | GPUs | Best For |
|---|---|---|---|---|
low | QLoRA (rank 8) | 4-bit | 1 | Quick experiments, small datasets |
medium | LoRA (rank 16) | 8-bit / none | 1-2 | Balanced quality and cost |
high | LoRA (rank 64) + DDP/FSDP | None | 2-4+ | Production-grade training runs |
The data parameter in client.finetune() accepts whichever format is most convenient:
| Type | How It's Handled |
|---|---|
pandas.DataFrame | Serialised to JSONL and uploaded via SCP |
datasets.Dataset | Saved to disk and uploaded via SCP |
| File path (local) | JSONL or CSV file uploaded via SCP |
File path (remote, starts with $) | Treated as existing HPC path — no upload needed |
Your DataFrame should have a text column with the full prompt + response formatted as a single string (Alpaca-style or chat template).
AfriLinkClient
| Method | Description |
|---|---|
authenticate() | Full auth flow (DataSpires + HPC). Optionally pass dataspires_email and dataspires_password. |
finetune(model, data, training_mode, gpus, time_limit, backend) | Create a FinetuneJob. Call .run(wait=True) to submit and block until completion. |
download_model(job_id, local_dir) | Download trained LoRA adapter weights via SCP. Ready for PeftModel.from_pretrained(). |
upload_dataset(local_path, dataset_name) | Upload a local dataset file to HPC storage. |
list_available_models(size=None) | Browse models in the registry. Filter by size: "tiny", "small", "medium", "large". |
list_available_datasets() | Browse pre-configured dataset options. |
get_model_requirements(model, training_mode) | GPU and memory recommendations for a given model + mode combination. |
list_jobs() | View your submitted SLURM jobs and their statuses. |
cancel_job(job_id) | Cancel a running SLURM job. |
get_queue_status() | View SLURM partition and queue information. |
run_command(cmd) | Execute an arbitrary shell command on the HPC login node. |
FinetuneJob (returned by client.finetune())
| Method / Property | Description |
|---|---|
run(wait=True) | Submit job to SLURM. wait=True polls until done; wait=False returns immediately after submission. |
cancel() | Cancel the SLURM job. |
get_logs(tail=100) | Fetch recent log lines from a running or completed job. |
status | Current job status string. |
job_id | AfriLink job ID (8-character UUID prefix). |
run() returns a dict with job_id, status ("completed" or "failed"), output_dir, and model_path. Always check result["status"] before downloading.
AfriLink uses pay-as-you-go billing at $2.00 per GPU-hour. You are only charged for actual compute time used. Add credits via card payment on your dashboard, or redeem voucher codes for AfriLink-specific credits. Your balance and usage history are visible on the Billing Dashboard.
Browser-based JupyterLab sessions backed by high-performance GPU compute. No setup — just launch and start coding.
AfriColab is a cloud notebook platform that gives you a full JupyterLab environment backed by GPU compute. Launch a session from your dashboard, and within minutes you have a ready-to-use notebook with PyTorch, TensorFlow, and popular data science libraries pre-installed. Sessions run on the same HPC infrastructure as AfriLink, with your work persisted across sessions.
One-click launch from your dashboard. Full-featured Jupyter environment with terminal access, file browser, and GPU support.
Sessions run on the same A100 GPU cluster infrastructure used by AfriLink, scheduled via SLURM for reliable performance.
PyTorch, TensorFlow, Hugging Face Transformers, and popular data science libraries come pre-installed. Start coding immediately.
Sessions are accessed via encrypted tunnels with per-user authentication. Your data stays private and your session stays connected.
1. Launch: Click "Launch Session" on your dashboard. The platform provisions a GPU node and starts your JupyterLab instance.
2. Code: Use the returned URL to open your notebook. Upload data, install packages, and run GPU workloads as you would locally.
3. Billing: Sessions are billed at $1.80 per GPU-hour from your general credit balance, tracked in real time on your dashboard.
| AfriColab | AfriLink SDK | |
|---|---|---|
| Interface | Browser (JupyterLab) | Python SDK (pip install) |
| Best for | Interactive exploration, prototyping | Automated finetuning pipelines |
| Rate | $1.80/GPU-hr | $2.00/GPU-hr |
| Credits | General only | General + Voucher |
| Run from | Dashboard | Any notebook (Colab, Jupyter, local) |
Find answers to common questions about our platform and services.
Both AfriLink and AfriColab run on NVIDIA A100 GPU nodes managed via SLURM scheduling. You can request 1 to 4+ GPUs per job depending on your training mode. Additional HPC backends with different GPU configurations are planned for the near future.
Billing is pay-as-you-go based on actual GPU time used. AfriColab sessions cost $1.80/GPU-hour and AfriLink jobs cost $2.00/GPU-hour. Add credits via Stripe card payment on your dashboard, or redeem voucher codes for AfriLink-specific credits. Your balance, usage breakdown, and invoice history are all visible on the Billing tab.
Voucher codes are pre-loaded credit codes in the format XXXX-XXXX-XXXX-XXXX. Redeem them on your dashboard under Payment Methods to receive AfriLink-specific credits. These credits can only be used for AfriLink SDK jobs and are deducted before your general credit balance.
Yes — this is the primary use case. Run !pip install afrilink-sdk in a Colab cell, authenticate with your DataSpires email and password, and submit finetune jobs directly. The SDK handles HPC certificate provisioning automatically inside Colab. See our live demo notebook for a full walkthrough.
The SDK accepts pandas DataFrames (with a text column in Alpaca format), HuggingFace Dataset objects, or file paths to local JSONL/CSV files. The registry also includes pre-configured datasets like Stanford Alpaca (52K examples) and Databricks Dolly (15K examples) that you can reference by name.
After your job completes, call client.download_model(job_id, "./my-model") to pull the LoRA adapter weights to your notebook. Then load the base model and attach the adapter with PeftModel.from_pretrained(base_model, "./my-model") from the PEFT library. The downloaded directory contains the adapter, tokenizer, and training config — everything needed for immediate inference.
Yes — set the backend parameter when creating a job: client.finetune(backend="cineca", ...). CINECA Leonardo is the default and currently available backend. Additional backends (EverseTech, AGH, ACF) are being onboarded and will appear in the HPC Backends table on this page as they go live. Your code stays the same — just change the backend string.
Sign up for a free account at dataspires.com. For AfriLink, run pip install afrilink-sdk and authenticate with your DataSpires credentials. For AfriColab, log in to your dashboard and click Launch Session. Both products share the same account and credit balance.