Get API key

Registry

View as Markdown

Your org's own model weights and container images, for workspaces, jobs and model servers.

The registry holds what your org builds itself: models, which are folders of weights kept as versions, and containers, which are images. Both are stored in PrivateMind, in an area only your org can reach. Nothing is fetched from an outside registry or sent to one. You push from a laptop, a CI runner or a workspace, and use what you pushed in workspaces, jobs and model servers.

In the app it is the Registry tab under Compute → Workspaces, with a section for models and one for containers.

Note

PrivateMind switches the registry on per organisation, for models and for containers separately. If there is no Registry tab, or it has no section for models or containers, that part is not on for your org. Ask your account team.

Models and versions

A model is a name, such as credit-ft. Each push adds a version, such as 2026-11-16. A version is every file in the folder you pushed: the config, the tokenizer, the safetensors shards, the README. You refer to one as <name>:<version>.

  • Versions are immutable. Pushing a version that already exists is refused before anything is sent. Push a new version instead.
  • Names are lowercase letters and digits, joined by ., _, - or /. Versions are letters, digits, ., _ and -, up to 128 characters, not starting with . or -. A date works well.
  • Every version is kept until someone deletes it.
  • One model holds at most 500 GiB across all its versions. The limit is checked when a version is written at the end of its push, so an oversize push uploads its files before it is refused.

Push a model

You push with the privatemind command from the Python SDK, version 0.9.0 or later. Outside PrivateMind, give it a personal API key. Inside a workspace or a job the key is already there, but the SDK there is older, so run the same pip install first. A workspace launched before the registry was released has a key without registry access, and the push fails with 403 and Missing required scope: weights:read. Restarting it keeps that key, so launch a new workspace.

shell
pip install -U "privatemind>=0.9"
export PRIVATEMIND_TOKEN="<ACCESS_KEY_ID>:<SECRET_ACCESS_KEY>"
privatemind weights push ./credit-ft credit-ft:2026-11-16
Text
pushed credit-ft:2026-11-16 sha256:8541e8… (13 files, 260 MiB); mount it with weights=["credit-ft:2026-11-16"], at /home/privatemind/models/credit-ft
  • What goes up: every file under the folder, except dotfiles, dot folders, .git and __pycache__. Add --exclude PATTERN to leave out more; repeat it for several patterns.
  • What does not go up again: within a model, each file is stored once. A file the model already holds at the same path, from an earlier version or from a push that stopped halfway, is not sent again. A new version that changes two files uploads two files. Running the same push again within two days finishes one that broke off.
  • What stops a push: a file name with a colon, a backslash or a control character, or anything that is not a regular file or folder, such as a device.
  • Links inside the folder are followed. From SDK 0.10.0, a link that points outside the folder stops the push, so a token or key never goes up by accident. For a folder whose files link elsewhere on purpose, such as a Hugging Face cache snapshot, add --follow-external-links. A link to nothing, or to a device, also stops the push.
  • Pickle files are refused: .bin, .pt, .pth, .pkl and .ckpt can run code when they are loaded, so the push stops and names them. Convert them to safetensors, exclude them, or pass --allow-pickle if you trust where they came from.

What a version shows

The app describes each version from its own files, read when the version is first listed. The description you can type on a model is kept apart from these facts.

Fact Where it comes from
Architecture architectures in the model's config.json.
Task Text generation, embeddings, classification, vision-language, speech or LoRA adapter. An adapter_config.json makes it an adapter, sentence-transformers files make it an embedding model, and otherwise the architecture name decides. An architecture it does not recognise gets no task in the app (other in the API).
Parameters Counted from the tensor shapes in the safetensors headers, so it is what the files hold. Blank for 4-bit weights packed into bytes, whose shapes do not give the count.
Precision The quantization in config.json when there is one, otherwise the data type most tensors use.
Context max_seq_length for sentence-transformers models, otherwise max_position_embeddings or its equivalent.
Experts The expert count of a mixture-of-experts model.
Tokenizer, chat template Whether the tokenizer files and a chat template are in the version.
License, base model The front matter at the top of README.md, which the model's author writes.

The README itself is shown in the model's page. Its HTML is not rendered and its images are not loaded. A version pushed without a config.json still lists, without architecture, context and experts, and usually without a task.

Use a model

Every use names a version, and PrivateMind pins it to its digest at launch. A version pushed later never changes what a running or restarted workload reads.

Where How
Workspace Pick versions under Model weights when you launch it, up to 8.
Job submit_job(..., weights=["credit-ft:2026-11-16"]), up to 8. See Workspace jobs.
Model server launch_model_server(..., weights="credit-ft:2026-11-16", vllm_version=...), or Serve with a model server on the model's page. See Model servers.

In a workspace or a job, each version appears read-only at /home/privatemind/models/<folder>. The folder is the last part of the model's name, lowercased, with anything other than letters, digits and - turned into -: qwen3-0.6b appears at /home/privatemind/models/qwen3-0-6b. To choose the folder, pass a mapping, as in weights=[{"name": "base", "ref": "credit-ft:2026-11-16"}]. Files are readable by the workspace user and cannot be changed.

A mounted version can be up to 100 GiB on a GPU cluster and 25 GiB on the CPU cluster. A bigger version is refused at launch with the limit in the message. For one that size, pull it into a volume and mount the volume, or launch the model server from the volume.

Pull a model

shell
privatemind weights pull credit-ft:2026-11-16 ./credit-ft

The pull checks every file against its digest as it arrives and moves a file into place only once it matches, so a broken pull leaves no half-written file. It writes only regular files and folders inside the folder you name: a link, an absolute path or a .. in a version is refused.

Delete

shell
privatemind weights delete credit-ft:2026-11-16   # one version
privatemind weights delete credit-ft              # the model and every version

A version that a workspace, job or model server uses, running or stopped, cannot be deleted. The refusal names what uses it. Another member's private workload is counted but not named. Deleting frees the version's share of the quota within a minute.

Containers

Containers are pushed with Docker, or any tool that speaks the registry protocol, to your org's path: privatemind.com/customers/<your-org>/<name>:<tag>. The Push a container button in the Registry tab shows the command with your org's path filled in.

shell
docker login privatemind.com
docker tag trainer:v2 privatemind.com/customers/<your-org>/trainer:v2
docker push privatemind.com/customers/<your-org>/trainer:v2

Log in with a personal API key: the part before the colon is the username and the part after it is the password. Workspace and job keys reach models only.

Where How
Model server image= on launch_model_server, or Run your own image in the API. It runs on a GPU host your org alone holds.
GPU job submit_job(..., image="customers/<your-org>/trainer:v2", gpus=1), SDK 0.9.0 or later. A job image runs as an unprivileged user and needs /usr/bin/tini, bash, mkdir and tee.
  • Tags move. Pushing a tag again points it at the new image. A launch pins the digest it resolved, so a running workload keeps the image it started with.
  • Old images are cleared, even in use. Each container keeps its 30 most recently pushed tags and any tag pushed in the last 30 days. Older tags are removed within about two days, along with images no tag points at, such as the one a moved tag left behind. A workload whose image was removed can fail to start again, so relaunch it from a current tag. Models are never cleared this way.

Private and shared

Every model and every container is either private to its owner or shared with everyone in the org who has compute access. The owner is the member who first pushed it. New models and containers start private.

Owner Org admin Other members with compute access
See and use a private one yes yes no
See and use a shared one yes yes yes
Push a new version yes yes no
Delete, or switch private and shared yes yes no
Hand it to another member no yes no
  • Going private is refused while another member's workload uses it.
  • A container pushed before private and shared existed has no owner and is shared. Any member with compute access can push to it and delete from it until an org admin gives it an owner or makes it private.
  • Keys: a workspace or job key acts as its owner, with a member's rights even when the owner is an org admin. It reaches the owner's private models and the shared ones. It can list, push and pull models. Deleting, and switching between private and shared, need your own API key or the app. A read-only key can only read.
  • Sharing a workspace shares its key. Anyone who can open a workspace can read its key, so everyone you share a workspace with can read and push to your private models.
  • Other organisations never see your org's models or containers.

Storage quota

Your org has one quota for models and one for containers, shown at the top of each section of the Registry tab. PrivateMind sets them; ask your account team to change one.

  • When it is checked: each upload of a file is checked as it starts. A push that starts under the quota finishes, even if it ends over.
  • When it is full: new uploads are refused until you delete versions or tags. A push that only adds a tag or a version for files already stored still goes through, and everything already stored can still be used and pulled.
  • A quota of 0 turns new uploads off for your org. Everything stored stays usable.

Audit

Every push, delete, switch between private and shared, and change of owner is recorded in your org's audit log, with who did it. A push with a workspace or job key is recorded as that key, under the owner of the workspace or job, whoever ran it.

Where next