Trained adapters published, private to their owners like the knowledge bases they come from

An adapter now has an owner (org, team, project, user or key): only callers
there see it, and to anyone else it is a model that does not exist, absent
from /v1/models too. A training job's owner defaults to the one collection
its pairs come from, must be able to read every collection they come from,
and pairs from a knowledge base are never made public. ctl train publish
keeps the GGUF or PEFT files on the mirror, which accepts uploads now, and
sets the owned adapter after the usual architecture check.

The knowledge bases' cache_salt follows the collections searched rather
than the organization, so two teams of one organization no longer share
cached passages.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ilker ManapandClaude Opus 5.5 committed 2026-10-08 21:30:50 +02:00
1 parent 964b35ae65
commit 85025dfb03
29 files changed
+1049 -84

No files matched your search

+36 -26
View File
@@ -1966,32 +1966,9 @@ func (a *API) setAdapters(w http.ResponseWriter, r *http.Request) {
writeError(w, http.StatusBadRequest, "no model "+name)
return
}
base, baseErr := gguf.KindFromURL(r.Context(), safedial.Client(safedial.ControlPlane, 30*time.Second), m.Source)
have := map[string]bool{}
for _, ad := range m.Adapters {
have[ad.Source] = true
}
// The file is read only where llama.cpp will load it: a vLLM adapter is
// a PEFT directory, which has no header to read, and vLLM itself refuses
// one that does not fit the model when it is loaded.
ggufs := slices.ContainsFunc(m.Profiles, func(p catalog.Profile) bool { return p.Engine == "llamacpp" })
for _, ad := range req.Adapters {
if have[ad.Source] || !ggufs {
continue // already checked when it was attached
}
h, err := gguf.KindFromURL(r.Context(), safedial.Client(safedial.ControlPlane, 30*time.Second), ad.Source)
switch {
case err != nil:
writeError(w, http.StatusBadRequest, fmt.Sprintf("adapter %s: %v", ad.Name, err))
return
case !h.IsAdapter():
writeError(w, http.StatusBadRequest, fmt.Sprintf("adapter %s: %s is a model, not a LoRA adapter", ad.Name, ad.Source))
return
case baseErr == nil && h.Architecture != base.Architecture:
writeError(w, http.StatusBadRequest, fmt.Sprintf("adapter %s is for %s models and %s is %s",
ad.Name, h.Architecture, m.Name, base.Architecture))
return
}
if err := checkAdapters(r.Context(), m, req.Adapters); err != nil {
writeError(w, http.StatusBadRequest, err.Error())
return
}
out, err := a.models.SetAdapters(r.Context(), m.Name, req.Adapters, actorOf(r))
if err != nil {
@@ -2073,3 +2050,36 @@ func multiNodeReadiness(n inventory.Node) string {
}
return "ready"
}
// checkAdapters reads each adapter a model does not have yet, where
// llama.cpp will load it, to refuse one that is not a LoRA adapter for the
// model's architecture: such an adapter is a replica that fails to start,
// found minutes later on a node.
func checkAdapters(ctx context.Context, m catalog.Model, adapters []catalog.Adapter) error {
// A vLLM adapter is a PEFT directory, which has no header to read, and
// vLLM itself refuses one that does not fit the model when it is loaded.
if !slices.ContainsFunc(m.Profiles, func(p catalog.Profile) bool { return p.Engine == "llamacpp" }) {
return nil
}
client := safedial.Client(safedial.ControlPlane, 30*time.Second)
base, baseErr := gguf.KindFromURL(ctx, client, m.Source)
have := map[string]bool{}
for _, ad := range m.Adapters {
have[ad.Source] = true
}
for _, ad := range adapters {
if have[ad.Source] {
continue // checked when it was attached
}
h, err := gguf.KindFromURL(ctx, client, ad.Source)
switch {
case err != nil:
return fmt.Errorf("adapter %s: %v", ad.Name, err)
case !h.IsAdapter():
return fmt.Errorf("adapter %s: %s is a model, not a LoRA adapter", ad.Name, ad.Source)
case baseErr == nil && h.Architecture != base.Architecture:
return fmt.Errorf("adapter %s is for %s models and %s is %s", ad.Name, h.Architecture, m.Name, base.Architecture)
}
}
return nil
}