Katalog-API-Referenz

Von Bedeutung

Foundry Local ist in der Vorschau verfügbar. Öffentliche Vorschauversionen bieten frühzeitigen Zugriff auf Features, die sich in der aktiven Bereitstellung befinden.
Features, Ansätze und Prozesse können sich vor der allgemeinen Verfügbarkeit (General Availability, GA) noch ändern oder eine eingeschränkte Funktionalität aufweisen.

Mit Foundry Local können Sie Ihren eigenen Katalogdienst erstellen und integrieren. Dieser Artikel befasst sich mit:

Für die Katalog-API erforderliches Modellformat
Anforderungs- und Antwortformat, das für ihre Katalog-API erforderlich ist, um in Foundry Local zu integrieren

Voraussetzungen

Sie haben Foundry Local installiert.
Sie können einen Webdienst ausführen, der einen POST Endpunkt verfügbar macht.
Ihre Modellartefakte sind im ONNX-Format verfügbar.
Azure role-based access control (RBAC): Nicht zutreffend.

Modellformat

Um mit Foundry Local zu arbeiten, muss Ihr Modellkatalog Modelldateien im Open Neural Network Exchange (ONNX) -Format enthalten. Informationen zum Kompilieren von Hugging Face- und PyTorch-Modellen zu ONNX finden Sie unter Compile Hugging Face models to run on Foundry Local.

API-Format

Anfrage

Implementieren Sie einen POST-Endpunkt in Ihrem Katalogdienst, der einen JSON-Anforderungstext akzeptiert. Das Anforderungsformat für die Katalog-API lautet wie folgt:

Methode: POST
Inhaltstyp: application/json

Beispielanforderung

curl -X POST <your-catalog-api-endpoint> \
-H "Content-Type: application/json" \
-d '{
  "resourceIds": [
    {
      "resourceId": "azureml",
      "entityContainerType": "Registry"
    }
  ],
  "indexEntitiesRequest": {
    "filters": [
      {
        "field": "type",
        "operator": "eq",
        "values": [
          "models"
        ]
      },
      {
        "field": "kind",
        "operator": "eq",
        "values": [
          "Versioned"
        ]
      },
      {
        "field": "properties/variantInfo/variantMetadata/device",
        "operator": "eq",
        "values": [
          "cpu",
          "gpu"
        ]
      },
      {
        "field": "properties/variantInfo/variantMetadata/executionProvider",
        "operator": "eq",
        "values": [
          "cpuexecutionprovider",
          "webgpuexecutionprovider"
        ]
      }
    ],
    "pageSize": 10,
    "skip": null,
    "continuationToken": null
  }
}'

Ersetzen Sie sie <your-catalog-api-endpoint> durch Ihre Katalogdienst-URL.

Was zu erwarten ist

Eine erfolgreiche Antwort enthält ein indexEntitiesResponse Objekt.
Suchergebnisse werden in indexEntitiesResponse.valuezurückgegeben.

Referenz:

Der Anforderungstext muss ein JSON-Objekt mit den folgenden Feldern sein:

resourceIds: Ein Array von Ressourcen-IDs, die die abzufragenden Ressourcen angeben. Jedes Element enthält Folgendes:
- resourceId: Die ID der Ressource.
- entityContainerType: Der Typ des Entitätscontainers, z Registry. B. , Workspaceund andere.
indexEntitiesRequest: Ein Objekt, das die Suchparameter enthält.
- filters: Ein Array von Filterobjekten, die die Kriterien zum Filtern der Suchergebnisse angeben. Jeder Filter enthält Folgendes:
  - field: Das feld, nach dem gefiltert werden soll, z type. B. , kindund andere.
  - operator: Der Für den Filter zu verwendende Operator. Beispiel: eq (gleich), (ungleich), ne (nicht gleich), gt (größer als), lt (kleiner als) und andere.
  - values: Ein Array von Werten, die mit dem Feld übereinstimmen sollen.
- orderBy: Ein Array von Feldern, nach denen die Ergebnisse sortiert werden sollen.
- searchText: Eine Zeichenfolge, nach der in den Ergebnissen gesucht werden soll.
- pageSize: Die maximale Anzahl der zurückzugebenden Ergebnisse (für Paginierung).
- skip: Die Anzahl der zu überspringenden Ergebnisse (für die Paginierung).
- continuationToken: Ein Token für die Paginierung, um von einer vorherigen Anforderung fortzufahren.

Filterbare Felder (optional)

Implementieren Sie die Katalog-API, damit sie das Anforderungsformat akzeptiert. Serverseitige Filterung ist optional. Das Überspringen der serverseitigen Filterung ist schneller zu implementieren, ist aber für suchmodelle weniger effizient.

Wenn Sie die serverseitige Filterung implementieren, verwenden Sie die folgenden Felder:

type: Der Typ des Modells, z models. B. , datasetsund andere.
kind: Die Art des Modells, z Versioned. B. , Unversionedund andere.
properties/variantInfo/variantMetadata/device: Der Gerätetyp, z cpu. B. , gpuund andere.
properties/variantInfo/variantMetadata/executionProvider: Der Ausführungsanbieter, z cpuexecutionprovider. B. , webgpuexecutionproviderund andere.

Antwort

Die Katalog-API gibt ein JSON-Objekt zurück, das die Suchergebnisse enthält.

Beispielantwort

{
  "indexEntitiesResponse": {
    "totalCount": 1,
    "value": [
      {
        "assetId": "example-asset-id",
        "version": "1",
        "properties": {
          "name": "example-model",
          "version": 1,
          "variantInfo": {
            "variantMetadata": {
              "device": "cpu",
              "executionProvider": "cpuexecutionprovider"
            }
          }
        }
      }
    ],
    "nextSkip": null,
    "continuationToken": null
  }
}

Antwortschema

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "indexEntitiesResponse": {
      "type": "object",
      "properties": {
        "totalCount": {
          "type": "integer",
          "description": "The total count of entities."
        },
        "value": {
          "type": "array",
          "description": "An array of LocalModel objects.",
          "items": {
            "$ref": "#/definitions/LocalModel"
          }
        },
        "nextSkip": {
          "type": "integer",
          "description": "The number of items to skip for the next request."
        },
        "continuationToken": {
          "type": "string",
          "description": "A token to continue fetching results."
        }
      }
    }
  },
  "definitions": {
    "LocalModel": {
      "type": "object",
      "properties": {
        "annotations": {
          "type": "object",
          "description": "Annotations associated with the model.",
          "properties": {
            "tags": {
              "type": "object",
              "description": "Tags associated with the annotation.",
              "properties": {
                "author": { "type": "string" },
                "alias": { "type": "string" },
                "directoryPath": { "type": "string" },
                "license": { "type": "string" },
                "licenseDescription": { "type": "string" },
                "promptTemplate": { "type": "string" },
                "task": { "type": "string" }
              }
            },
            "systemCatalogData": {
              "type": "object",
              "properties": {
                "publisher": { "type": "string" },
                "displayName": { "type": "string" }
              }
            },
            "name": { "type": "string" }
          }
        },
        "properties": {
          "type": "object",
          "description": "Properties of the model.",
          "properties": {
            "name": { "type": "string" },
            "version": { "type": "integer" },
            "alphanumericVersion": { "type": "string" },
            "variantInfo": {
              "type": "object",
              "properties": {
                "parents": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "properties": {
                      "assetId": { "type": "string" }
                    }
                  }
                },
                "variantMetadata": {
                  "type": "object",
                  "properties": {
                    "modelType": { "type": "string" },
                    "device": { "type": "string" },
                    "executionProvider": { "type": "string" },
                    "fileSizeBytes": { "type": "integer" }
                  }
                }
              }
            }
          }
        },
        "version": {
          "type": "string",
          "description": "The version of the model."
        },
        "assetId": {
          "type": "string",
          "description": "The asset ID of the model."
        }
      }
    }
  }
}