Skip to content
Basevex AI

How it works

From adapter to API in four steps.

Bring a LoRA adapter trained on a supported base model. We validate it, host it on shared GPUs, and give you an OpenAI-compatible endpoint.

Start free in the sandboxRead the quickstart
How requests reach a client's adapter An application sends a chat completion request naming a deployment alias. The Basevex gateway routes it to that client's LoRA adapter. Three client adapters share one base model whose weights are loaded once. POST /v1/chat/completions"model": "contract-review"Basevex gatewayAPI key → client → deployment alias → adapterClient Asupport-agentLoRA adapterClient Bcontract-reviewLoRA adapterClient Cticket-triageLoRA adapterSupported base modelweights loaded once, shared by compatible adaptersIllustration — not live data

  1. Step 1

    Choose a supported base model

    Pick from the base models we serve. Each is pinned to an exact revision, so your adapter always runs against the same weights.

    • Maximum rank and allowed target modules shown per model
    • Token rates and context length published up front

  2. Step 2

    Upload your LoRA adapter

    Upload adapter_config.json and adapter_model.safetensors straight to storage. We read the config and the safetensors header — your tensors are never loaded or executed during validation.

    • Rejected adapters list every reason
    • A SHA-256 checksum is recorded when it passes

  3. Step 3

    Create a deployment

    Give the adapter an alias like contract-review, assign it to a client, and set output-token and rate limits. Switch versions later without changing client code.

    • Pause, resume or archive at any time
    • Limits per deployment and per API key

  4. Step 4

    Call it with any OpenAI SDK

    Point the SDK at Basevex, pass your alias as the model, and you’re done. Streaming works the same way. No GPU servers to provision or patch.

    • OpenAI-compatible chat completions
    • Every response carries an x-request-id

Validation

What we check before it runs.

An adapter that fails any check is rejected with the reason, before a deployment can use it.

Format

LoRA only, as safetensors. No pickle files, archives or DoRA.

Rank

r must be at or below the base model’s maximum rank.

Target modules

Only the projections the base model allows; no retrained embeddings or new tokens.

Tensor shapes

Every lora_A / lora_B shape must match the rank and the base model’s dimensions.

Data types

F16, BF16 or F32 tensors only.

File integrity

Header size and offsets must account for the file exactly.

Every validation rule

On every request

What the gateway checks on every request.

  1. 01

    Key checked

    Revoked keys stop working within a second. Keys can be limited to a client, deployments or IP ranges.

  2. 02

    Client attributed

    The key’s client, or else the deployment’s client, gets the request.

  3. 03

    Limits applied

    Rate limits, concurrency, output tokens and your spend cap — before anything reaches a GPU.

  4. 04

    Usage recorded

    Token counts from the runtime, never the client. Prompts and outputs are not stored.

Try it with your own adapter.

The sandbox is free. Integrate against the real API, then subscribe when you’re ready for real inference.

Start free in the sandbox Read the quickstart