---
updatedAt: 2026-08-21T16:12:58.000Z
agentTools:
  projectIndex: https://docs.rackspace.com/llms.txt
---

# List LoRAAdapters in a namespace

# OpenAPI definition

```json
{
  "openapi": "3.0.3",
  "info": {
    "title": "RackAI API",
    "description": "REST API for RackAI Custom Resources managed by the `rackai.rackspace.com` operator.\n\nMost requests are routed through the Kubernetes API server and authenticated\nwith a bearer token (service-account token or kubeconfig credential).\n\nOrganization management is the exception: tenants have no RBAC to edit the\n`Organization` custom resource directly, so those operations are served by the\norganizer service behind the Front Proxy and authenticated with an Auth0 OIDC\ntoken. See the **Organization** tag.\n\n**Base path:** `/apis/rackai.rackspace.com/v1alpha1`\n",
    "version": "v1alpha1",
    "contact": {
      "name": "Rackspace Spot Platform Engineering"
    }
  },
  "servers": [
    {
      "url": "https://{fqdn}/apis/rackai.rackspace.com/v1alpha1",
      "description": "API Server",
      "variables": {
        "fqdn": {
          "default": "localhost:6443",
          "description": "Fully-qualified domain name (and optional port) of the Front Proxy in front of the Kubernetes API server"
        }
      }
    }
  ],
  "security": [
    {
      "BearerToken": []
    }
  ],
  "tags": [
    {
      "name": "LoRAAdapter",
      "description": "LoRAAdapter represents a LoRA adapter produced by a FineTuningJob.\nAdapters are stored under a per-model layout in SeaweedFS\n(/loraadapters/{namespace}/{model}/{adapter-name}) and can be\ndynamically loaded into a running ModelDeployment via the vLLM\nload/unload endpoints.\n\ntags here and on Model use the Go 1.24 encoding/json \"omitzero\" form. Every\nother v1alpha1 type uses \"omitempty\". Verify generated CRD OpenAPI matches\nexpectations under both; if not, switch to omitempty for consistency."
    }
  ],
  "paths": {
    "/namespaces/{namespace}/loraadapters": {
      "parameters": [
        {
          "$ref": "#/components/parameters/namespace"
        }
      ],
      "get": {
        "tags": [
          "LoRAAdapter"
        ],
        "summary": "List LoRAAdapters in a namespace",
        "operationId": "listNamespacedLoRAAdapter",
        "parameters": [
          {
            "$ref": "#/components/parameters/labelSelector"
          },
          {
            "$ref": "#/components/parameters/fieldSelector"
          },
          {
            "$ref": "#/components/parameters/limit"
          },
          {
            "$ref": "#/components/parameters/continue"
          }
        ],
        "responses": {
          "200": {
            "description": "OK",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LoRAAdapterList"
                }
              }
            }
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          }
        }
      }
    }
  },
  "components": {
    "securitySchemes": {
      "BearerToken": {
        "type": "http",
        "scheme": "bearer",
        "description": "Bearer token for the Kubernetes-extension API surface\n(`/apis/rackai.rackspace.com/v1alpha1/...`). Pass as\n`Authorization: Bearer <token>`.\n\nNote: for paths reached through the Front Proxy, the credential\npresented is an Auth0-issued OIDC bearer that the proxy validates\nand forwards to the upstream apiserver (which validates the same\ntoken via OIDC). A Kubernetes service-account token or kubeconfig\ncredential is what's typically used when hitting the apiserver\ndirectly (e.g. from inside the cluster).\n"
      }
    },
    "parameters": {
      "namespace": {
        "name": "namespace",
        "in": "path",
        "required": true,
        "description": "Kubernetes namespace of the resource.",
        "schema": {
          "type": "string"
        }
      },
      "labelSelector": {
        "name": "labelSelector",
        "in": "query",
        "required": false,
        "description": "Selector to restrict the list of returned objects by their labels.\nDefaults to everything.\n",
        "schema": {
          "type": "string"
        }
      },
      "fieldSelector": {
        "name": "fieldSelector",
        "in": "query",
        "required": false,
        "description": "Selector to restrict the list of returned objects by their fields.\nDefaults to everything.\n",
        "schema": {
          "type": "string"
        }
      },
      "limit": {
        "name": "limit",
        "in": "query",
        "required": false,
        "description": "Maximum number of responses to return for a list call.\nThe server may return fewer results than requested.\n",
        "schema": {
          "type": "integer",
          "minimum": 1
        }
      },
      "continue": {
        "name": "continue",
        "in": "query",
        "required": false,
        "description": "Opaque token returned by a previous list call to continue pagination.\n",
        "schema": {
          "type": "string"
        }
      }
    },
    "responses": {
      "Unauthorized": {
        "description": "Unauthorized — no or invalid bearer token provided."
      },
      "Forbidden": {
        "description": "Forbidden — the authenticated principal lacks permission."
      }
    },
    "schemas": {
      "LoRAAdapter": {
        "description": "LoRAAdapter represents a LoRA adapter produced by a FineTuningJob.\nAdapters are stored under a per-model layout in SeaweedFS\n(/loraadapters/{namespace}/{model}/{adapter-name}) and can be\ndynamically loaded into a running ModelDeployment via the vLLM\nload/unload endpoints.\n\ntags here and on Model use the Go 1.24 encoding/json \"omitzero\" form. Every\nother v1alpha1 type uses \"omitempty\". Verify generated CRD OpenAPI matches\nexpectations under both; if not, switch to omitempty for consistency.",
        "properties": {
          "apiVersion": {
            "description": "APIVersion defines the versioned schema of this representation of an object.\nServers should convert recognized schemas to the latest internal value, and\nmay reject unrecognized values.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources",
            "type": "string",
            "example": "rackai.rackspace.com/v1alpha1"
          },
          "kind": {
            "description": "Kind is a string value representing the REST resource this object represents.\nServers may infer this from the endpoint the client submits requests to.\nCannot be updated.\nIn CamelCase.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
            "type": "string",
            "example": "LoRAAdapter"
          },
          "metadata": {
            "type": "object",
            "description": "metadata is a standard object metadata.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata",
            "example": {
              "name": "llama3-alpaca-lora",
              "namespace": "org-idxxxxxxxxxx"
            }
          },
          "spec": {
            "description": "spec defines the desired state of LoRAAdapter",
            "properties": {
              "dataset": {
                "description": "Dataset is the Dataset name used for this fine-tune.\nInformational only.",
                "example": "alpaca-train",
                "type": "string"
              },
              "description": {
                "description": "Description is a human-readable description of this resource.",
                "example": "Finance Q&A adapter trained on internal Q3 2026 docs.",
                "maxLength": 1024,
                "type": "string"
              },
              "displayName": {
                "description": "DisplayName is a short human-readable label for this resource. Distinct\nfrom metadata.name (which is the DNS-compatible identifier).",
                "example": "Finance Q&A Adapter",
                "maxLength": 128,
                "type": "string"
              },
              "integrity": {
                "description": "Integrity contains user-provided MD5 hashes for file integrity verification.\nIf specified, the controller checks each file's MD5 against the storage backend.",
                "properties": {
                  "md5": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "description": "MD5 contains the expected hex-encoded MD5 hashes of files to be verified.\nKeys MUST be the full storage path as it appears in SeaweedFS, e.g.\n\"/loraadapters/<ns>/<model>/<adapter>/<rel>\". Basenames or relative paths\nare not accepted — the controller looks each key up verbatim in the\nobserved storage layout. The controller sets Ready=false with reason\nIntegrityCheckFailed on any mismatch.",
                    "type": "object"
                  }
                },
                "type": "object",
                "x-kubernetes-validations": [
                  {
                    "message": "Spec.Integrity.MD5 keys must be absolute storage paths starting with '/'",
                    "rule": "!has(self.md5) || self.md5.all(k, k.startsWith('/'))"
                  }
                ]
              },
              "model": {
                "description": "Model is the name of the Model these adapters were fine-tuned from.\nMust be the metadata.name of an existing Model in the same namespace.\nRequired; drives storage path keying and runtime compatibility checks.",
                "example": "llama3-8b-base",
                "minLength": 1,
                "type": "string"
              },
              "sourceFineTuningJob": {
                "description": "SourceFineTuningJob is the FineTuningJob name that produced these adapters.\nInformational only.",
                "type": "string"
              }
            },
            "required": [
              "model"
            ],
            "type": "object"
          },
          "status": {
            "description": "status defines the observed state of LoRAAdapter",
            "properties": {
              "conditions": {
                "description": "conditions represent the current state of the LoRAAdapter resource.\nThe controller currently sets \"Ready\".",
                "items": {
                  "description": "Condition contains details for one aspect of the current state of this API Resource.",
                  "properties": {
                    "lastTransitionTime": {
                      "description": "lastTransitionTime is the last time the condition transitioned from one status to another.\nThis should be when the underlying condition changed.  If that is not known, then using the time when the API field changed is acceptable.",
                      "format": "date-time",
                      "type": "string"
                    },
                    "message": {
                      "description": "message is a human readable message indicating details about the transition.\nThis may be an empty string.",
                      "maxLength": 32768,
                      "type": "string"
                    },
                    "observedGeneration": {
                      "description": "observedGeneration represents the .metadata.generation that the condition was set based upon.\nFor instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date\nwith respect to the current state of the instance.",
                      "format": "int64",
                      "minimum": 0,
                      "type": "integer"
                    },
                    "reason": {
                      "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition.\nProducers of specific condition types may define expected values and meanings for this field,\nand whether the values are considered a guaranteed API.\nThe value should be a CamelCase string.\nThis field may not be empty.",
                      "maxLength": 1024,
                      "minLength": 1,
                      "pattern": "^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$",
                      "type": "string"
                    },
                    "status": {
                      "description": "status of the condition, one of True, False, Unknown.",
                      "enum": [
                        "True",
                        "False",
                        "Unknown"
                      ],
                      "type": "string"
                    },
                    "type": {
                      "description": "type of condition in CamelCase or in foo.example.com/CamelCase.",
                      "maxLength": 316,
                      "pattern": "^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$",
                      "type": "string"
                    }
                  },
                  "required": [
                    "lastTransitionTime",
                    "message",
                    "reason",
                    "status",
                    "type"
                  ],
                  "type": "object"
                },
                "type": "array",
                "x-kubernetes-list-map-keys": [
                  "type"
                ],
                "x-kubernetes-list-type": "map"
              },
              "files": {
                "description": "Files lists files observed in storage.",
                "items": {
                  "description": "LoRAAdapterFileInfo describes a single file observed in storage.",
                  "properties": {
                    "path": {
                      "type": "string"
                    },
                    "size": {
                      "format": "int64",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "path",
                    "size"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "integrity": {
                "description": "Integrity contains the per-file size + MD5 hash observed in storage.\nPopulated whenever StatDir returned at least one file; available even when\nthe integrity check failed, to aid debugging.",
                "properties": {
                  "files": {
                    "additionalProperties": {
                      "description": "LoRAAdapterFileStatus is per-file observed size + MD5 reported by the storage backend.",
                      "properties": {
                        "md5": {
                          "description": "MD5 is the hex-encoded MD5 hash of the file as reported by the backend.\nEmpty if the backend did not report one.",
                          "type": "string"
                        },
                        "size": {
                          "description": "Size is the file size in bytes as reported by the backend.",
                          "format": "int64",
                          "type": "integer"
                        }
                      },
                      "type": "object"
                    },
                    "description": "Files maps each file path to its observed size and MD5 hash.",
                    "type": "object"
                  }
                },
                "type": "object"
              },
              "observedGeneration": {
                "description": "ObservedGeneration is the most recent generation observed by the controller.",
                "format": "int64",
                "type": "integer"
              },
              "phase": {
                "description": "Phase is a high-level summary of the LoRAAdapter lifecycle state.",
                "enum": [
                  "Pending",
                  "Processing",
                  "Ready",
                  "Failed"
                ],
                "type": "string"
              },
              "ready": {
                "description": "Ready indicates whether the LoRAAdapter is ready for consumption.",
                "type": "boolean"
              },
              "size": {
                "anyOf": [
                  {
                    "type": "integer"
                  },
                  {
                    "type": "string"
                  }
                ],
                "description": "Size is the total bytes observed (as a Quantity).",
                "pattern": "^(\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\\+|-)?(([0-9]+(\\.[0-9]*)?)|(\\.[0-9]+))))?$",
                "x-kubernetes-int-or-string": true
              },
              "storageRef": {
                "description": "StorageRef holds the inferred storage path.",
                "properties": {
                  "path": {
                    "description": "Path is the directory path in SeaweedFS where the adapter artifacts reside.",
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "uploadComplete": {
                "description": "UploadComplete is true once every file declared in Spec.Integrity.MD5 has\nbeen observed in storage with a matching MD5 hash. False while the\ncontroller is still waiting for the uploader to populate Spec.Integrity,\nor after an integrity check failure.",
                "type": "boolean"
              },
              "usedBy": {
                "description": "UsedBy is a list of ModelDeployment names that currently reference this adapter in their spec.loraAdapters.",
                "items": {
                  "type": "string"
                },
                "type": "array",
                "x-kubernetes-list-type": "set"
              }
            },
            "type": "object",
            "readOnly": true
          }
        },
        "required": [
          "spec"
        ],
        "type": "object"
      },
      "LoRAAdapterList": {
        "type": "object",
        "description": "LoRAAdapterList contains a list of LoRAAdapter resources.",
        "required": [
          "items"
        ],
        "properties": {
          "apiVersion": {
            "type": "string",
            "example": "rackai.rackspace.com/v1alpha1"
          },
          "kind": {
            "type": "string",
            "example": "LoRAAdapterList"
          },
          "metadata": {
            "type": "object"
          },
          "items": {
            "type": "array",
            "description": "items is the list of LoRAAdapter resources.",
            "items": {
              "$ref": "#/components/schemas/LoRAAdapter"
            }
          }
        }
      }
    }
  }
}
```