> ## Documentation Index
> Fetch the complete documentation index at: https://docs.primeintellect.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Available Fft Models

> Models pre-cached on the caller's eligible PrimeClusters for FFT dispatch.

Same principal collapse as the dispatch picker (team wins when
present, otherwise personal) and the same cluster filter (uncordoned
+ heartbeat fresh + non-zero ClusterAllocation) so what surfaces
here is what dispatch would actually land on. Only PRESENT-cache
clusters contribute — ABSENT / ERROR would 400 the dispatch and
NULL (unprobed) hasn't reported a manifest yet.

Each model carries the list of clusters it's warm on with `gpu_type`
+ `cache_synced_at` so callers can pin the follow-up dispatch to a
specific GPU family without hitting the "picker landed on a cluster
that has the GPU but not this model" reject path.



## OpenAPI

````yaml https://api.primeintellect.ai/openapi.json get /api/v1/training/available-fft-models
openapi: 3.1.0
info:
  title: PI API
  version: 0.1.0
servers:
  - url: https://api.primeintellect.ai
security: []
paths:
  /api/v1/training/available-fft-models:
    get:
      tags:
        - training
      summary: Get Available Fft Models
      description: >-
        Models pre-cached on the caller's eligible PrimeClusters for FFT
        dispatch.


        Same principal collapse as the dispatch picker (team wins when

        present, otherwise personal) and the same cluster filter (uncordoned

        + heartbeat fresh + non-zero ClusterAllocation) so what surfaces

        here is what dispatch would actually land on. Only PRESENT-cache

        clusters contribute — ABSENT / ERROR would 400 the dispatch and

        NULL (unprobed) hasn't reported a manifest yet.


        Each model carries the list of clusters it's warm on with `gpu_type`

        + `cache_synced_at` so callers can pin the follow-up dispatch to a

        specific GPU family without hitting the "picker landed on a cluster

        that has the GPU but not this model" reject path.
      operationId: get_available_fft_models_api_v1_training_available_fft_models_get
      parameters:
        - name: team_id
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Optional team ID. When set, returns FFT models cached on the
              team's eligible PrimeClusters. When omitted, uses the caller's
              personal allocations.
            title: Team Id
          description: >-
            Optional team ID. When set, returns FFT models cached on the team's
            eligible PrimeClusters. When omitted, uses the caller's personal
            allocations.
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AvailableFFTModelsResponse'
        '401':
          description: Authorization failed
        '422':
          description: Invalid request data
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
      security:
        - HTTPBearer: []
components:
  schemas:
    AvailableFFTModelsResponse:
      properties:
        models:
          items:
            $ref: '#/components/schemas/AvailableFFTModel'
          type: array
          title: Models
      type: object
      title: AvailableFFTModelsResponse
      description: |-
        Models pre-cached on the caller's eligible PrimeClusters, sorted by
        model name. Powers `prime train models` (or equivalent) so users
        dispatching FFT runs don't have to guess which repos are warm.

        Same principal collapse as the dispatch picker (team wins when
        present, otherwise personal) so what shows up here is what dispatch
        would land on. Only PRESENT-cache clusters contribute — ABSENT /
        ERROR clusters would 400 the dispatch, and NULL (unprobed) clusters
        haven't reported a manifest yet.
    ErrorResponse:
      properties:
        errors:
          items:
            $ref: '#/components/schemas/ErrorDetail'
          type: array
          title: Errors
      type: object
      required:
        - errors
      title: ErrorResponse
    AvailableFFTModel:
      properties:
        name:
          type: string
          title: Name
        clusters:
          items:
            $ref: '#/components/schemas/FFTModelClusterInfo'
          type: array
          title: Clusters
      type: object
      required:
        - name
        - clusters
      title: AvailableFFTModel
      description: |-
        A model that's cached-and-ready on at least one cluster the caller
        could dispatch to. `clusters` is the per-cluster fan-out so callers
        can pin a run to a specific `gpu_type` and know the cache is warm
        there — avoids the "picker landed on a cluster that has the GPU but
        not this model" reject path.
    ErrorDetail:
      properties:
        param:
          type: string
          title: Param
        details:
          type: string
          title: Details
      type: object
      required:
        - param
        - details
      title: ErrorDetail
    FFTModelClusterInfo:
      properties:
        clusterId:
          type: string
          title: Clusterid
        clusterName:
          type: string
          title: Clustername
        gpuType:
          anyOf:
            - type: string
            - type: 'null'
          title: Gputype
        cacheSyncedAt:
          anyOf:
            - type: string
              format: date-time
            - type: 'null'
          title: Cachesyncedat
      type: object
      required:
        - clusterId
        - clusterName
      title: FFTModelClusterInfo
      description: |-
        One entry in `AvailableFFTModel.clusters` — a cluster the caller
        can dispatch to that already has the model warm on its cache PVC.
  securitySchemes:
    HTTPBearer:
      type: http
      scheme: bearer

````