Modelle mit dem Python-SDK und der REST-API ermitteln

Erkunden Sie den OCI Generative AI-Modellkatalog, filtern Sie Modelle für Ihre Anwendung, und prüfen Sie Modellmetadaten mit signierten Python-SDK- und REST-Anforderungen.

Überblick

Die Modell-Discovery-API vereint Modell-IDs, Funktionen, API-Kompatibilität, Konfigurationsparameter und regionale Verfügbarkeit. Verwenden Sie diese Metadaten, um Modelle für einen Chatassistenten, eine Suchanwendung oder einen multimodalen Workflow auszuwählen, bevor Sie eine Inferenzanforderung schreiben.

Anwendungen können den Katalog abfragen, um Modellauswahlschnittstellen zu erstellen und die verfügbaren Auswahlmöglichkeiten zu aktualisieren. Anhand regionaler Lebenszyklusinformationen können Sie Upgrades planen und gemeldete Ersetzungen bewerten.

MetadatenWas es berichtetVerwendung
Identität und ProviderModell-IDs und Lieferanteninformationen.Suchen Sie einen Provider, und kopieren Sie eine genaue Modell-ID.
Aufgaben und ModalitätenModellfunktionen und unterstützte Input/Output-Typen.Identifizieren Sie Kandidaten für Chat-, Einbettungs-, Rangier- oder multimodale Workflows.
API-KompatibilitätFür das Modell gemeldete Inferenz-API-Funktionen.Wählen Sie eine API aus, die vom Modell unterstützt wird.
regionale VerfügbarkeitRealms, Regionen und On-Demand- oder dedizierte Bereitstellungsmodi.Finden Sie Kandidaten für Ihren Bereitstellungsort und Bereitstellungsmodus.
Gehosteter oder Proxy-ZugriffDie Zugriffsklassifizierung des Modells.Prüfen Sie die entsprechende Dokumentation zum Deployment und zur Datenverarbeitung.
ParameterGemeldete Namen, Typen, Bereiche, Standardwerte und BeschreibungenErstellen Sie Konfigurationsformulare, und prüfen Sie Einstellungen anhand der zurückgegebenen Metadaten.
LebenszyklusAbschreibungs- und Abgangsdaten nach Region und Service-Modus sowie gegebenenfalls Ersetzungen.Identifizieren Sie betroffene Deployments, und bewerten Sie Migrationskandidaten.
FilterModell-ID, Realm, Region, Funktion, API-Funktion, Bereitstellungsmodus, Zugriffstyp und Lebenszyklusstatus.Erstellen Sie eine fokussierte Modellauswahl, oder automatisieren Sie Katalogsuchen.

Einzelne Modelle füllen möglicherweise nicht alle Felder aus. Mit der Discovery können Sie Modelle auswählen und konfigurieren. Es ruft keine Inferenz, Zugriffsberechtigung oder Benchmarkmodellqualität auf. Validieren Sie ein ausgewähltes Modell und einen vorgeschlagenen Ersatz für die Workload Ihrer Anwendung.

In diesem Tutorial authentifizieren Sie sich bei einer OCI-IAM-Session, fragen die Discovery mit dem Python-SDK ab, senden dieselbe Anforderung über REST, und führen Sie zehn praktische Beispiele aus. Außerdem lernen Sie, wie Sie Modelle auflisten, die bereits in Ihr Compartment importiert wurden.

Hinweis

Der Vorgang lautet ListModelDiscovery. Sie unterscheidet sich von list_models(), list_imported_models() und dem OpenAI-kompatiblen /models-Endpunkt. Das Senden einer Discovery-Anforderung an Chicago schränkt die Katalogergebnisse nicht auf Chicago ein. Verwenden Sie einen region-Filter, um die Katalogregion auszuwählen.

Bevor Sie beginnen

Um dieses Tutorial abzuschließen, benötigen Sie:

  • Ein OCI-Account und ein Compartment, in dem Sie Modelle prüfen können. Für ListModelDiscovery ist GENERATIVE_AI_MODEL_INSPECT erforderlich. Siehe Modellberechtigungen.
  • Für die Beispiele für importierte Modelle können Sie importierte Modelle im ausgewählten Compartment prüfen und eine vorhandene importierte Ressource suchen. Siehe Importierte Modellberechtigungen.
  • Python 3.11 oder höher, uv und eine installierte OCI-CLI. Die Befehle verwenden eine Bash-kompatible Shell auf macOS, Linux oder Windows Subsystem für Linux.
  • Ein Browser für die OCI-CLI-Sessionauthentifizierung und den Zugriff auf den Serviceendpunkt. In diesen Beispielen wird US Midwest (Chicago) in der kommerziellen Realm OC1 verwendet.

In den Beispielen wird die OCI-IAM-Anforderungssignatur mit einem Sessiontoken und dessen Private Key verwendet. Ein OCI Generative AI-API-Schlüssel ist ein separater Zugangsdaten und ersetzt nicht den hier verwendeten Signaturgeber.

1. Umgebung vorbereiten und anmelden

  1. Erstellen und aktivieren Sie eine virtuelle Python-Umgebung, und installieren Sie dann die Packages:
    uv venv --python 3.11 .venv
    source .venv/bin/activate
    uv pip install --upgrade oci requests

    Wenn die Umgebung bereits vorhanden ist, aktivieren Sie sie, bevor Sie die Packages installieren oder aktualisieren.

  2. Prüfen Sie, ob das installierte SDK die Discovery-Methode bereitstellt und die OCI-CLI verfügbar ist:
    python -c 'import oci; print(oci.__version__); print(hasattr(oci.generative_ai.GenerativeAiClient, "list_model_discovery"))'
    oci --version

    Bei der Methodenprüfung muss True ausgegeben werden. Wenn False ausgegeben wird, installieren Sie eine SDK-Version, die list_model_discovery enthält.

  3. Legen Sie das Beispielprofil, die Endpunktregion und das Compartment für diese Shell fest:
    export OCI_DISCOVERY_PROFILE=GENAI_DISCOVERY
    export OCI_DISCOVERY_REGION=us-chicago-1
    export OCI_COMPARTMENT_ID='<your-compartment-ocid>'

    Ersetzen Sie den Compartment-Platzhalter durch ein Compartment, auf das Sie zugreifen können. GENAI_DISCOVERY ist der Beispielprofilname. Die Skripte lesen diese Umgebungsvariablen, ohne ein Standard-Compartment zu verwenden.

  4. Erstellen Sie eine CLI-Sitzung, und schließen Sie die Anmeldung des Browsers ab:
    oci session authenticate \
      --profile-name "$OCI_DISCOVERY_PROFILE" \
      --region "$OCI_DISCOVERY_REGION"

    Die CLI speichert das Profil in ~/.oci/config. In den Python-Beispielen werden das Sessiontoken und der Private Key des Profils mit SecurityTokenSigner geladen. Wenn die Session abläuft, authentifizieren Sie sich erneut, und starten Sie das Skript oder die interaktive Python-Session neu. Siehe Tokenbasierte Authentifizierung für die CLI.

2. Abfrageerkennung mit dem Python-SDK

In diesem Beispiel werden aktuelle On-Demand-Chatmodelle in der ausgewählten Region gesucht. Es folgt der Paginierung und druckt Modell-IDs, Anbieter und Funktionen. Die Helperfunktionen werden in späteren Beispielen wiederverwendet.

  1. Speichern Sie den folgenden Code als model_discovery.py in Ihrem Arbeitsverzeichnis:
    """Query OCI Generative AI model metadata with an IAM session."""
    
    import os
    import re
    import unicodedata
    from pathlib import Path
    
    import oci
    
    
    def load_session():
        config = oci.config.from_file(
            profile_name=os.environ["OCI_DISCOVERY_PROFILE"]
        )
        config["region"] = os.environ["OCI_DISCOVERY_REGION"]
        token = Path(config["security_token_file"]).expanduser().read_text(
            encoding="utf-8"
        ).strip()
        private_key = oci.signer.load_private_key_from_file(
            str(Path(config["key_file"]).expanduser()),
            config.get("pass_phrase"),
        )
        signer = oci.auth.signers.SecurityTokenSigner(token, private_key)
        return config, signer
    
    
    def make_client():
        config, signer = load_session()
        return oci.generative_ai.GenerativeAiClient(config, signer=signer)
    
    
    def fetch_models(client, compartment_id, source="discovery", **filters):
        if source not in {"discovery", "imported"}:
            raise ValueError("source must be discovery or imported")
        operation = (
            client.list_model_discovery
            if source == "discovery"
            else client.list_imported_models
        )
        items = []
        while True:
            response = operation(compartment_id=compartment_id, **filters)
            items.extend(oci.util.to_dict(response.data)["items"])
            next_page = response.headers.get("opc-next-page")
            if not next_page:
                return items
            filters["page"] = next_page
    
    
    def normalized(value):
        value = unicodedata.normalize("NFKC", str(value)).casefold()
        return " ".join(re.findall(r"[^\W\d_]+|\d+", value))
    
    
    def search_models(models, query):
        terms = [normalized(term) for term in query.split()]
        terms = [term for term in terms if term]
    
        def matches(model):
            values = [
                model.get(field)
                for field in ("model_id", "id", "display_name", "vendor", "version")
            ]
            values.extend(
                value for value in (model.get("data_source") or {}).values()
                if isinstance(value, str)
            )
            candidates = [normalized(value) for value in values if value]
            return all(
                any(
                    re.search(
                        (r"(?<!\d)" if term[0].isdigit() else "")
                        + re.escape(term),
                        value,
                    )
                    for value in candidates
                )
                for term in terms
            )
    
        return [model for model in models if matches(model)]
    
    
    def show(models):
        print(f"{len(models)} matching model(s)")
        for model in models:
            name = (
                model.get("model_id")
                or model.get("display_name")
                or model.get("id")
            )
            capabilities = ", ".join(model.get("capabilities") or [])
            vendor = model.get("vendor") or "not reported"
            print(f"{name} | vendor={vendor} | capabilities={capabilities}")
    
    
    if __name__ == "__main__":
        client = make_client()
        models = fetch_models(
            client,
            os.environ["OCI_COMPARTMENT_ID"],
            region=[os.environ["OCI_DISCOVERY_REGION"]],
            capability=["CHAT"],
            serving_mode=["ON_DEMAND"],
            is_deprecated=False,
            is_on_demand_retired=False,
        )
        show(models)
  2. Führen Sie das Skript in der aktivierten Umgebung aus:
    python model_discovery.py
  3. Prüfen Sie die übereinstimmenden Modelle, und kopieren Sie eine ID, die Sie prüfen möchten.

    Die Ergebnisse hängen vom aktuellen Katalog und Ihren Filtern ab. Ein leeres Ergebnis ist kein Authentifizierungstest oder kein Nachweis, dass ein Modell nicht importiert werden kann.

    Das SDK leitet seinen Managementendpunkt aus config["region"] ab. Das separate Argument region=[...] filtert die Katalogverfügbarkeit. Kein Wert konfiguriert einen Inferenzendpunkt.

    Methodendetails finden Sie unter GenerativeAiClient.list_model_discovery.

Sie haben eine paginierte Discovery-Abfrage und wiederverwendbare Funktionen für lokale Suche und importierten Modellbestand.

3. Discovery-REST-API direkt aufrufen

Eine direkte Anforderung stellt die HTTP-Methode, den Pfad, die Abfrageparameter und die Antwortheader bereit. Er ruft denselben Discovery-Vorgang auf wie das SDK. Für die Anforderung ist weiterhin eine OCI IAM-Autorisierung erforderlich.

GET /20231130/modelDiscovery?compartmentId=<your-compartment-ocid>
  1. Legen Sie den öffentlichen Chicago Management-Endpunkt fest:
    export OCI_DISCOVERY_ENDPOINT=https://generativeai.us-chicago-1.oci.oraclecloud.com

    In diesem Beispiel wird der Chicago-Endpunkt OC1 verwendet. Verwenden Sie für eine andere Region oder Realm den entsprechenden Managementendpunkt in der API-Referenz, und aktualisieren Sie OCI_DISCOVERY_REGION für den Katalogfilter. Discovery verwendet die Management-API und keine Chatinferenz-URL.

  2. Senden Sie eine signierte Anforderung mit der OCI-CLI:
    oci raw-request \
      --profile "$OCI_DISCOVERY_PROFILE" \
      --auth security_token \
      --http-method GET \
      --target-uri "${OCI_DISCOVERY_ENDPOINT}/20231130/modelDiscovery?compartmentId=${OCI_COMPARTMENT_ID}&region=${OCI_DISCOVERY_REGION}&capability=CHAT&servingMode=ON_DEMAND&isDeprecated=false&isOnDemandRetired=false"

    Die CLI signiert die Anforderung und zeigt die Antwort an. Um eine andere Seite abzurufen, übergeben Sie den zurückgegebenen opc-next-page-Wert als URL-codierten Abfrageparameter page. Das folgende Python-Beispiel folgt automatisch der Paginierung.

  3. Speichern Sie den folgenden Code neben model_discovery.py unter model_discovery_rest.py:

    Das Skript importiert den Session Signing Helper aus dem SDK-Beispiel. Es sendet HTTP-Anforderungen über requests und gibt Status- und Anforderungs-IDs an den Standardfehler aus.

    """Call Model Discovery over HTTP with OCI request signing."""
    
    import os
    import sys
    
    import requests
    
    from model_discovery import load_session
    
    
    def fetch_rest_models(signer, endpoint, compartment_id, region):
        url = endpoint.rstrip("/") + "/20231130/modelDiscovery"
        params = {
            "compartmentId": compartment_id,
            "region": [region],
            "capability": ["CHAT"],
            "servingMode": ["ON_DEMAND"],
            "isDeprecated": "false",
            "isOnDemandRetired": "false",
        }
        items = []
        while True:
            response = requests.get(
                url,
                params=params,
                headers={"Accept": "application/json"},
                auth=signer,
                timeout=(10, 30),
                allow_redirects=False,
            )
            request_id = response.headers.get("opc-request-id", "not reported")
            print(
                f"HTTP {response.status_code} | request ID: {request_id}",
                file=sys.stderr,
            )
            if 300 <= response.status_code < 400:
                raise RuntimeError("Check the service endpoint. Redirect not followed.")
            response.raise_for_status()
            items.extend(response.json()["items"])
            next_page = response.headers.get("opc-next-page")
            if not next_page:
                return items
            params["page"] = next_page
    
    
    if __name__ == "__main__":
        _, signer = load_session()
        models = fetch_rest_models(
            signer,
            os.environ["OCI_DISCOVERY_ENDPOINT"],
            os.environ["OCI_COMPARTMENT_ID"],
            os.environ["OCI_DISCOVERY_REGION"],
        )
        print(f"{len(models)} matching model(s)")
        for model in models:
            print(f"{model['modelId']} | vendor={model.get('vendor') or 'not reported'}")
  4. Führen Sie das REST-Beispiel aus:
    python model_discovery_rest.py
  5. Vergleichen Sie die Modell-IDs mit den SDK-Ergebnissen.

    Verwenden Sie dasselbe Profil, Compartment, dieselbe Endpunktregion und dieselben Filter für den Vergleich. Die Ergebnisse können sich ändern, wenn sich der Katalog ändert.

    REST-Antwortfelder verwenden camelCase, wie modelId. Die oci.util.to_dict()-Ausgabe des SDK verwendet snake_case, wie model_id. Wiederholen Sie für REST-Filter mit Listenwerten den Abfrageschlüssel, z.B. region=us-chicago-1&region=us-ashburn-1. Das Package requests codiert Listen auf diese Weise in params.

4. Praktische Beispiele vorbereiten

  1. Speichern Sie dieses Setup unter model_discovery_recipes.py neben model_discovery.py:
    import json
    import os
    from collections import Counter
    from pathlib import Path
    
    from model_discovery import fetch_models, make_client, search_models, show
    
    client = make_client()
    compartment_id = os.environ["OCI_COMPARTMENT_ID"]
    region = os.environ["OCI_DISCOVERY_REGION"]
    
    
    def fetch(source="discovery", **filters):
        return fetch_models(client, compartment_id, source=source, **filters)
  2. Starten Sie Python mit dem geladenen Setup:
    python -i model_discovery_recipes.py

    Mit der Option -i bleibt Python geöffnet. Führen Sie ein beliebiges Beispiel in den folgenden Abschnitten dieser Session aus. Alternativ können Sie ein Beispiel an die Setupdatei anhängen und ohne -i ausführen.

Filter aus dem zurückgegebenen Katalog auswählen

Bevor Sie Filter auswählen, prüfen Sie die für die Modelle in Ihrer Region gemeldeten Werte:

catalog = fetch(region=[region])
for field in ("capabilities", "api_capability", "model_access", "vendor"):
    counts = Counter()
    for model in catalog:
        values = model.get(field) or []
        if isinstance(values, str):
            values = [values]
        counts.update(set(values))
    print(field, dict(sorted(counts.items())))

for field in ("realm", "region", "serving_modes"):
    counts = Counter()
    for model in catalog:
        values = set()
        for availability in model.get("availability") or []:
            value = availability.get(field)
            if isinstance(value, list):
                values.update(value)
            elif value:
                values.add(value)
        counts.update(values)
    print(field, dict(sorted(counts.items())))

Jede Anzahl ist die Anzahl der zurückgegebenen Modelleinträge, die einem Wert zugeordnet sind. Ein Modell kann zu mehreren Funktions- oder Verfügbarkeitswerten beitragen. Die Anzahl entspricht den Abfragefiltern.

SDK- ArgumentBeispiel oder Zweck
region, realmListen der Regions-IDs oder Realm-Werte. Vom Katalog gemeldete Werte verwenden
model_idEine genaue Modell-ID.
capabilityEine Liste wie ["CHAT"], ["TEXT_EMBEDDINGS"] oder ["TEXT_RERANK"].
api_capabilityEine Liste der API-IDs, die vom Katalog gemeldet werden.
serving_mode["ON_DEMAND"] oder ["DEDICATED"].
model_access["HOSTED"] oder ["PROXY"].
is_deprecatedFalse schließt veraltete Modelle aus.
is_on_demand_retired, is_dedicated_retiredVerwenden Sie False für den Bereitstellungsmodus, dessen stillgelegte Modelle Sie ausschließen möchten.
page, limitPaginierungstoken und angeforderte Seitengröße. Das Beispiel folgt auf opc-next-page, bis alle Seiten abgerufen werden.

Verwenden Sie search_models(), um nach dem Abrufen aller Seiten eine Übereinstimmung mit lokalen Teilzeichenfolgen zu erhalten. Die Suche ist kein Parameter von ListModelDiscovery. Prüfen Sie die Arbeitsvorgangsreferenz für das vollständige Filtervokabular.

Zehn praktische Python-Beispiele

1. Modelle über beide Serviermodi hinweg durchsuchen

Filtern Sie nach der gewünschten Deployment-Region. Wenn Sie serving_mode auslassen, sind sowohl On-Demand- als auch dedizierte Modelle zulässig.

catalog = fetch(region=[region])
show(catalog)

2. Modelle nach Teilname oder Lieferant suchen

Suchen Sie die zurückgegebenen Metadaten lokal. Jeder durch Leerzeichen getrennte Begriff muss mit einem durchsuchbaren Feld übereinstimmen. Beim Abgleich werden Groß-/Kleinschreibung und Satzzeichen ignoriert. Der model_id-Filter des Service erfordert eine genaue ID.

catalog = fetch(region=[region])
show(search_models(catalog, "grok"))

Ändern Sie den Suchbegriff in den Ergebnissen in einen Mitarbeiter oder eine Modellfamilie.

3. Aktuelle On-Demand-Chatmodelle suchen

Schließen Sie veraltete Modelle und Modelle aus, die für On-Demand-Service eingestellt wurden.

show(fetch(
    region=[region],
    capability=["CHAT"],
    serving_mode=["ON_DEMAND"],
    is_deprecated=False,
    is_on_demand_retired=False,
))

4. Modelle für Dedicated Serving suchen

Wenden Sie den Ruhestandsfilter auf dedizierte Dienste an. Diese Abfrage durchsucht den Discovery-Katalog. Um die importierten Ressourcen aufzulisten, verwenden Sie Beispiel 8.

show(fetch(
    region=[region],
    serving_mode=["DEDICATED"],
    is_deprecated=False,
    is_dedicated_retired=False,
))

5. Einbettungs- und Rangiermodelle suchen

Fragen Sie jede Funktion separat ab. Discovery verwendet TEXT_EMBEDDINGS und TEXT_RERANK. Importierte Modellressourcen verwenden ein anderes Funktionsvokabular, einschließlich EMBEDDING und RERANK.

for capability in ("TEXT_EMBEDDINGS", "TEXT_RERANK"):
    print("\nCapability:", capability)
    show(fetch(region=[region], capability=[capability]))

6. Proxymodelle mit einer gemeldeten API-Funktion suchen

Lesen Sie die vom Katalog zurückgegebenen API-IDs, und kopieren Sie dann einen Wert, um die Proxymodelle zu filtern. Prüfen Sie die Hinweise zu externen Anrufen und die Datenverarbeitung für ein ausgewähltes Modell.

catalog = fetch(region=[region], model_access=["PROXY"])
api_values = sorted({
    api for model in catalog for api in model.get("api_capability") or []
})
print(api_values)
if api_values:
    api = input("Enter an API capability from the list: ").strip()
    if api in api_values:
        show(fetch(
            region=[region],
            model_access=["PROXY"],
            api_capability=[api],
        ))
    else:
        print("Enter an exact value from the returned list.")
else:
    print("No API capabilities were reported for these results.")

7. Modellparameter und Lebenszyklusdetails prüfen

Kopieren Sie eine exakte Modellkennung aus Ihren Ergebnissen. Prüfen Sie die vollständigen Verfügbarkeitseinträge, um jede Region mit ihren Bereitstellungsmodi, Lebenszyklusdaten und gemeldeten Ersetzungen zu verknüpfen.

model_id = input("Enter an exact model ID from your results: ").strip()
for model in fetch(model_id=model_id):
    print(model["model_id"])
    for field in (
        "api_capability", "modality_support", "parameters", "availability"
    ):
        print(field)
        print(json.dumps(model.get(field), indent=2, default=str))

Ein Feld kann leer sein oder nicht gemeldet werden. Bewerten Sie alle vorgeschlagenen Ersetzungen mit Ihrer Anwendung, bevor Sie migrieren.

8. Importiertes Qwen-Modell suchen

Verwenden Sie source="imported", um vorhandene Importe in Ihrem Compartment und Ihrer Clientregion abzufragen. In diesem Beispiel wird nach einem Qwen 3.6 35B-Modell gesucht. Es gibt nur dann eine Übereinstimmung zurück, wenn Sie ein übereinstimmendes Modell importiert haben und diese Ressource prüfen können. Informationen zur Importkompatibilität finden Sie unter Kompatible Qwen 3.6-Modelle.

imports = fetch(source="imported")
selected = search_models(imports, "qwen 3.6 35B")
show(selected)
for model in selected:
    print("Imported resource OCID:", model["id"])
    print("Resource state:", model.get("lifecycle_state"))

Die zurückgegebene OCID identifiziert die importierte Modellressource. Ein Ressourcenstatus ACTIVE stellt nicht fest, dass ein Inferenzendpunkt bereitgestellt wurde. Die Deployment-Schritte finden Sie unter Importierte Modelle verwalten.

9. Discovery mit importierten Ressourcen vergleichen

Vergleichen Sie die beiden Quellen, wenn ein Modell im importierten Bestand, aber nicht in der Erkennung angezeigt wird. Die Discovery-Ergebnisse und die in Ihr Compartment importierten Ressourcen beantworten verschiedene Fragen.

print("Discovery catalog for the selected region:")
show(search_models(fetch(region=[region]), "qwen"))
print("\nImported resources in this compartment and client region:")
show(search_models(fetch(source="imported"), "qwen"))

Wenn importierte Ergebnisse leer sind, prüfen Sie das Compartment, die Clientregion und die Berechtigungen. Die Abfrage des importierten Modells scannt keine anderen Compartments oder Regionen.

10. Übereinstimmende importierte Modelle exportieren

Schreiben Sie die vollständigen Metadaten für ausgewählte importierte Ressourcen in eine lokale JSON-Datei.

selected = search_models(fetch(source="imported"), "qwen 3.6 35B")
Path("qwen-imports.json").write_text(
    json.dumps({"items": selected}, indent=2, default=str),
    encoding="utf-8",
)
print(f"Saved {len(selected)} matching resource(s) to qwen-imports.json")

Ergebnis prüfen und Fehler beheben

Eine erfolgreiche Anforderung gibt Modellmetadaten oder eine leere Liste zurück, wenn keine Einträge übereinstimmen. Prüfen Sie IDs, Funktionen, Parameter und Verfügbarkeit, bevor Sie eine Inferenzanforderung erstellen.

SymptomWas zu überprüfen ist
Das SDK enthält keine list_model_discovery-Methode.Führen Sie ein Upgrade von oci in der aktiven virtuellen Umgebung durch, und wiederholen Sie die Methodenprüfung.
Eine signierte Anforderung gibt HTTP 401 zurück.Validieren oder erstellen Sie die CLI-Session neu, prüfen Sie das ausgewählte Profil, und starten Sie Python neu, damit das neue Token gelesen wird.
Der Service meldet einen Autorisierungsfehler.Prüfen Sie IAM-Berechtigungen und die Compartment-OCID. Importierter Bestand erfordert die Berechtigung zum Prüfen importierter Modellressourcen.
Ein exakter Modell-ID-Filter gibt keine Ergebnisse zurück.Suchen oder suchen Sie zuerst lokal, und kopieren Sie dann eine ID aus der Antwort. Prüfen Sie die Regions- und Lebenszyklusfilter.
Die Antwort umfasst die Verfügbarkeit außerhalb der Endpunktregion.Legen Sie den Discovery-Filter region explizit fest, und prüfen Sie jeden Verfügbarkeitseintrag. Die Endpunktregion allein schränkt keine Katalogergebnisse ein.
Es wurde kein importiertes Modell zurückgegeben.Prüfen Sie die Region, das Compartment, die Berechtigungen und den Ressourcenanzeigenamen des Clients. Verwenden Sie list_imported_models() für importierten Bestand.
Es wird nur ein Teil des Katalogs zurückgegeben.Folgen Sie opc-next-page. Die Python-Beispiele auf dieser Seite rufen alle Seiten ab.
Die REST-Anforderung ist nicht erfolgreich, während das SDK erfolgreich ist.Verwenden Sie dasselbe Profil und Compartment. Prüfen Sie den Managementendpunkt, den Pfad und die Abfragenamen camelCase, und prüfen Sie dann den Status und die Anforderungs-ID.

Der generierte CLI-Befehl finden Sie unter list-model-discovery. Informationen zu importierten Ressourcen finden Sie unter ListImportedModels. Die von der Discovery zurückgegebenen Metadatenfelder finden Sie unter ModelDiscovery.