Skip to content
TAIP

Products / For AI builders

ModelSphere

Available

Your own Hugging Face Hub. Change one env var — every client just works.

ModelSphere is an on-premises model and dataset registry that speaks the Hugging Face Hub API on the wire. Set HF_ENDPOINT and every standard client — transformers, datasets, diffusers, huggingface-cli, plain git with LFS — works against your registry without patches, including huggingface_hub 1.x, whose Xet transfers are ingested server-side and stored as ordinary LFS objects. Every transfer is proxied, so the object store never needs to be reachable from a client. It doubles as a pull-through cache for the public Hub, fetching upstream models lazily or via scheduled prefetch for air-gapped sites, and adds what an enterprise registry needs: OIDC SSO, scoped personal access tokens, organizations, private repos, audit logging, Prometheus metrics, runtime-editable cache and retention policy, and one-tarball backup and restore.

All products

Specification

Version
v1.8.1 — generally available
Protocol
Hugging Face Hub API · git over HTTPS and SSH · git-LFS (> 5 GiB via HF multipart) · Xet for huggingface_hub 1.x
Modes
Primary registry · pull-through cache · scheduled prefetch
Dataset viewer
Config and split discovery · range-backed paging through Parquet, CSV, JSONL (zstd included)
Operations
OIDC · PAT scopes · audit log · Prometheus · runtime-editable cache, prefetch and retention · one-tarball backup
Assurance
CI drives stock huggingface_hub, git and git-lfs against the stack — weekly against the latest client
Languages
English · 简体中文

Proof, not promises

See it in one block.

No proprietary SDKs, no rewrites — ModelSphere meets your tools where they already are.

one env var, every client 
$ export HF_ENDPOINT=https://models.intra.example

# everything downstream just works — no client patches
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
# served from your registry; cached from upstream or fully air-gapped▌

Wire-compatible with the Hugging Face Hub API — including git clone and multi-gigabyte LFS transfers.

Capabilities

What ModelSphere gives you

01

Wire-compatible with the Hub

Wire-compatible with huggingface_hub — so transformers, datasets, diffusers, and huggingface-cli work by setting HF_ENDPOINT. That includes huggingface_hub 1.x and its Xet transfers, which ModelSphere ingests server-side and materializes as ordinary LFS objects, so nothing about your storage has to change to follow the client. No forks, no client patches, no proprietary SDK to adopt. A compatibility suite drives the real clients in CI, weekly against the latest release, so upstream drift surfaces here and not in your cluster.

02

Real git underneath

git clone, git lfs pull, and git lfs push work natively; objects beyond 5 GiB upload via Hugging Face's multipart transfer. Model versioning is git versioning — branches, tags, and commits you already understand.

03

A browsable Hub, not just an API

Beyond the wire protocol, ModelSphere ships a web UI: searchable browse with tag, pipeline, and library filters; model cards rendered with syntax highlighting and GitHub-style alerts; an in-browser file viewer and commit history; discussions and likes. Datasets get a real viewer — configs and splits discovered as the Hub does it, then paged through Parquet, CSV, or JSONL with ranged reads, images and audio served lazily rather than inlined. A home page that reads as a ledger: what this registry holds, and what is local work versus a cached mirror.

04

Pull-through cache for the public Hub

Point it at huggingface.co and it lazily caches what your team pulls — or prefetch on a schedule for fully air-gapped sites. One registry serves both worlds.

05

Enterprise plumbing included

OIDC SSO, personal access tokens with fine-grained scopes, organizations and teams, public/private repos, an audit log of every change, Prometheus metrics with shipped Grafana dashboards, and backup/restore as a single tarball.

How it works

From public dependency to private registry.

  1. Step 01

    Set HF_ENDPOINT

    One environment variable. Every standard Hugging Face client now talks to your registry instead of the public Hub.

  2. Step 02

    Push, pull, clone

    Upload fine-tunes with huggingface-cli or git-lfs. Pull base models through the built-in cache — lazily, or prefetched for air-gap.

  3. Step 03

    Govern and observe

    OIDC decides who sees what. Tokens are scoped. Every change lands in the audit log; usage lands in Prometheus.

Who it's for

Built for these teams

  • Teams hosting fine-tuned and internal models
  • Air-gapped organizations that still want HF workflows
  • Platform teams centralizing model and dataset storage

Pairs well with

Other builder products

ConsoleX

 Available

Log in, get a governed Kubernetes workspace. No kubectl, no tickets.

On first SSO login every user gets an isolated namespace with quotas, default-deny networking, storage, and a web terminal — provisioned automatically, reconciled continuously. It is also the platform's front door: the token authority every TAIP app trusts, the SSH gateway into every workspace, and the taip CLI the cluster serves itself.

Learn more

DevSpace

 Available

Jupyter or VS Code on a GPU in seconds. Idle environments shut themselves down.

Single-click Jupyter, Marimo, Streamlit, Gradio, and VS Code environments — GPU-ready, isolated per user behind a per-pod auth proxy, shareable with a colleague, and idle-shutdown by default.

Learn more

TrainX

 Available

A template is a shape. Your project fills it. Kubernetes runs the job.

Self-describing templates render straight into UI forms — or your project declares itself in a trainx.yaml and runs on a platform shape. Live quota checks, streaming logs, parsed progress, MLflow-tracked parameters and metrics, resumable runs, and declared outputs you can hand to the next step.

Learn more