Külső modellek a modellkiszolgálóban

Note

Ez a lap a közvetlenül a Modellkiszolgáló végponton konfigurált külső modelleket ismerteti. Ha külső modellszolgáltatókat szeretne regisztrálni szabályozott Unity Catalog-objektumokként, amelyeket lekérdezhet a munkaterületeken, és nyomon követheti a költéseket, tekintse meg a Unity Catalog modellszolgáltatói szolgáltatásait.

Important

A cikkben szereplő kód példák a nyilvános előzetes verziójú MLflow deployments CRUD API használatát mutatják be.

Ez a cikk a modellkiszolgáló külső modelljeit ismerteti, beleértve a támogatott modellszolgáltatókat és korlátozásokat.

Mik azok a külső modellek?

Important

Mostantól konfigurálhatja az AI Gatewayt azokon a modellkiszolgálási végpontokon, amelyek külső modelleket szolgálnak ki. Az AI Gateway irányítást, felügyeletet és üzemkész állapotot biztosít ezeknek a modellkiszolgáló végpontoknak. Lásd : AI-szabályozás a Unity AI Gateway használatával.

A külső modellek a Databricksen kívül üzemeltetett külső modellek. A Model Serving által támogatott külső modellek lehetővé teszik a különböző nagy nyelvi modellek (LLM) szolgáltatók, például az OpenAI és az antropikus használatának és felügyeletének egyszerűsítését egy szervezeten belül. A Modellszolgáltatás szolgáltatóként is használható egyéni modellek kiszolgálására, amelyek sebességkorlátokat kínálnak ezekre a végpontokra. Ennek a támogatásnak a részeként a Modellszolgáltatás egy magas szintű felületet kínál, amely leegyszerűsíti a szolgáltatásokkal való interakciót azáltal, hogy egységes végpontot biztosít az adott LLM-hez kapcsolódó kérések kezeléséhez.

Emellett a külső modellek Azure Databricks-támogatása központosított hitelesítő adatok kezelését is biztosítja. Az API-kulcsok biztonságos helyen való tárolásával a szervezetek növelhetik a biztonsági helyzetüket azáltal, hogy minimalizálják a rendszer bizalmas API-kulcsainak kitettségét. Emellett segít megelőzni ezeknek a kulcsoknak a kódban való felfedését, vagy azt, hogy a végfelhasználók biztonságosan kezeljék a kulcsokat.

Tekintse meg az oktatóanyagot: Külső modellvégpontok létrehozása OpenAI-modellek lekérdezéséhez részletes útmutatást nyújt a külső modellvégpontok létrehozásához és a végpontok által az MLflow Deployments SDK használatával kiszolgált támogatott modellek lekérdezéséhez. A kiszolgáló felhasználói felület és a REST API használatára vonatkozó útmutatásért tekintse meg az alábbi útmutatókat:

Követelmények

modellszolgáltatók

A Modellkiszolgáló külső modelljei számos modellszolgáltatót támogatnak. A szolgáltató képviseli a gépi tanulási modellek forrását, például az OpenAI-t, az antropikust stb. Minden szolgáltató rendelkezik a külső modell végpontkonfigurációjának external_modelmezőjébe ágyazott sajátos tulajdonságokkal és konfigurációkkal.

A következő szolgáltatók támogatottak:

  • openai: Az OpenAI által kínált modellekhez, valamint az Azure OpenAI integrációkhoz és az Azure OpenAI-hez AAD-vel.
  • antropikus: Az antropikus által kínált modellekhez.
  • cohere: A Cohere által kínált modellekhez.
  • amazon-bedrock: Az Amazon Bedrock által kínált modellekhez.
  • google-cloud-vertex-ai: A modellekhez, amelyeket a Google Cloud Vertex AI kínál.
  • databricks-model-serving: Kompatibilis sémákkal rendelkező modellkiszolgáló végpontok esetén. Lásd: Végpontkonfiguráció.
  • egyéni: Az OpenAI API-kompatibilis, de a Databricks által közvetlenül nem támogatott egyéni proxyk mögötti alternatív szolgáltatók vagy modellek esetében.

Ha az itt nem szereplő szolgáltatóhoz szeretne támogatást kérni, próbálkozzon az egyéni szolgáltatói lehetőséggel, vagy forduljon a Databricks-fiók csapatához.

Támogatott modellek

A választott modell közvetlenül befolyásolja az API-hívásokból kapott válaszok eredményeit. Ezért válasszon egy olyan modellt, amely megfelel a használati eset követelményeinek. A beszélgetési válaszok létrehozásához például kiválaszthatja a csevegési modellt. Ezzel szemben a szövegbeágyazások létrehozásához kiválaszthatja a beágyazási modellt.

Lásd a támogatott modelleket.

Modellkiszolgáló végpontokon kiszolgált modellek használata

A végpontokat szolgáltatóként kiszolgáló modell támogatott a , llm/v1/completionsés llm/v1/chat a llm/v1/embeddingsvégponttípusok esetében. Ezeknek a végpontoknak el kell fogadniuk a kötelezőként megjelölt szabványos lekérdezési paramétereket, míg más paraméterek figyelmen kívül hagyhatók attól függően, hogy a modellszolgáltatás végpontja támogatja-e őket.

Lásd POST /serving-endpoints/{name}/invocations a szabványos lekérdezési paraméterek API-referenciajában.

Ezeknek a végpontoknak a következő OpenAI formátumban kell válaszokat előállítaniuk.

Befejezési feladatok esetén:

{
"id": "123", # Not Required
"model": "test_databricks_model",
"choices": [
  {
    "text": "Hello World!",
    "index": 0,
    "logprobs": null, # Not Required
    "finish_reason": "length" # Not Required
  }
],
"usage": {
  "prompt_tokens": 8,
  "total_tokens": 8
  }
}

Csevegési feladatok esetén:

{
  "id": "123", # Not Required
  "model": "test_chat_model",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "\n\nHello there, how may I assist you today?",
    },
    "finish_reason": "stop"
  },
  {
    "index": 1,
    "message": {
      "role": "human",
      "content": "\n\nWhat is the weather in San Francisco?",
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 8,
    "total_tokens": 8
  }
}

Beágyazási feladatok esetén:

{
  "data": [
    {
      "embedding": [
        0.0023064255,
        -0.009327292,
        .... # (1536 floats total for ada-002)
        -0.0028842222,
      ],
      "index": 0
    },
    {
      "embedding": [
        0.0023064255,
        -0.009327292,
        .... #(1536 floats total for ada-002)
        -0.0028842222,
      ],
      "index": 0
    }
  ],
  "model": "test_embedding_model",
  "usage": {
    "prompt_tokens": 8,
    "total_tokens": 8
  }
}

Végpontkonfiguráció

Külső modellek kiszolgálásához és lekérdezéséhez konfigurálnia kell egy kiszolgálóvégpontot. Lásd: Végpontot kiszolgáló külső modell létrehozása

Végpontot kiszolgáló külső modell esetében a végpontkonfiguráció external_model szakaszában meg kell adnia a served_entities mezőt és annak paramétereit. Ha több külső modellt konfigurál egy kiszolgálóvégponton, meg kell adnia az traffic_config egyes külső modellek forgalomirányítási százalékos arányát.

A external_model mező határozza meg azt a modellt, amelyre a végpont továbbítja a kéréseket. A modell megadásakor kritikus fontosságú, hogy a szolgáltató támogatja a kért modellt. Például openai szolgáltatóként támogatja az olyan modelleket, mint a text-embedding-ada-002, más szolgáltatók azonban nem. Ha a modellt a szolgáltató nem támogatja, a Databricks HTTP 4xx-es hibát ad vissza a kérések adott modellhez való átirányításakor.

Az alábbi táblázat a external_model mezőparamétereket foglalja össze. A végpontkonfigurációs paraméterekről lásd POST /api/2.0/serving-endpoints.

Paraméter Leírások
name A használni kívánt modell neve. Például az gpt-3.5-turbo OpenAI GPT-3.5-Turbo modelljéhez. Ezt a kérés törzsének részeként adja át a megfelelő kulccsal: "model".
provider Megadja a modell szolgáltatójának nevét. Ennek a karakterlánc értéknek meg kell, hogy feleljen egy támogatott külső modellszolgáltató . Például az OpenAI openai modelljeihez GPT-3.5.
task A feladat megfelel a kívánt nyelvmodell-interakció típusának. A támogatott tevékenységek a következők: "llm/v1/completions", "llm/v1/chat", "llm/v1/embeddings".
<provider>_config A modellhez szükséges további konfigurációs adatokat tartalmazza. Ez magában foglalja az API-alap URL-címének és az API-kulcsnak a megadását. Lásd: A szolgáltató konfigurálása végponthoz.
Ha custom szolgáltatót használ, adja meg ezt a paramétert custom_provider_config.

Az alábbi példa egy külső modellvégpont API-val történő létrehozására create_endpoint() mutat be példát. Ebben a példában a rendszer a befejezési végpontnak küldött kérést továbbítja a claude-2 megadott modellnek anthropic.

import mlflow.deployments

client = mlflow.deployments.get_deploy_client("databricks")

client.create_endpoint(
    name="anthropic-completions-endpoint",
    config={
        "served_entities": [
            {
                "name": "test",
                "external_model": {
                    "name": "claude-2",
                    "provider": "anthropic",
                    "task": "llm/v1/completions",
                    "anthropic_config": {
                        "anthropic_api_key": "{{secrets/my_anthropic_secret_scope/anthropic_api_key}}"
                    }
                }
            }
        ]
    }
)

Végpont szolgáltatójának konfigurálása

Végpont létrehozásakor meg kell adnia a megadott modellszolgáltatóhoz szükséges konfigurációkat. Az alábbi szakaszok összefoglalják az egyes modellszolgáltatókhoz elérhető végpontkonfigurációs paramétereket.

Note

A Databricks titkosítja és biztonságosan tárolja az egyes modellszolgáltatókhoz megadott hitelesítő adatokat. Ezek a hitelesítő adatok automatikusan törlődnek a társított végpontok törlésekor.

OpenAI

Konfigurációs paraméter Leírás Kötelező Alapértelmezett
openai_api_key Az OpenAI szolgáltatás használatával az OpenAI API kulcs Azure Databricks titkos kulcs hivatkozása. Ha közvetlenül szeretné beilleszteni az API-kulcsot, tekintse meg a következőt openai_api_key_plaintext: Az alábbi mezők egyikével kell megadnia egy API-kulcsot: openai_api_key vagy openai_api_key_plaintext.
openai_api_key_plaintext Az OpenAI API-kulcsot egyszerű szöveges karaktersorozat formájában használják az OpenAI szolgáltatáshoz. Ha a kulcs hivatkozásához az Azure Databricks Secrets használatát részesíti előnyben, tekintse meg a következőt: openai_api_key. Meg kell adnia egy API-kulcsot a következő mezők egyikével: openai_api_key vagy openai_api_key_plaintext meg kell adnia.
openai_api_type Nem kötelező mező a használni kívánt OpenAI API típusának megadásához. No openai
openai_api_base Az OpenAI API alap URL-címe. No https://api.openai.com/v1
openai_api_version Nem kötelező mező az OpenAI API-verzió megadásához. No
openai_organization Nem kötelező mező a szervezet OpenAI-ban való megadásához. No

Cohere

Konfigurációs paraméter Leírás Kötelező Alapértelmezett
cohere_api_key Az Azure Databricks titkos kulcsának hivatkozása a Cohere API-kulcshoz. Ha közvetlenül szeretné beilleszteni az API-kulcsot, tekintse meg a következőt cohere_api_key_plaintext: Az alábbi mezők egyikével kell megadnia egy API-kulcsot: cohere_api_key vagy cohere_api_key_plaintext.
cohere_api_key_plaintext A Cohere API-kulcs egyszerű szöveges sztringként van megadva. Ha a kulcs hivatkozásához az Azure Databricks Secrets használatát részesíti előnyben, tekintse meg a következőt: cohere_api_key. Az alábbi mezők egyikével kell megadnia egy API-kulcsot: cohere_api_key vagy cohere_api_key_plaintext.
cohere_api_base A Cohere szolgáltatás alap URL-címe. No

Anthropic

Konfigurációs paraméter Leírás Kötelező Alapértelmezett
anthropic_api_key Az Azure Databricks titkos kulcsának referenciája egy antropikus API-kulcshoz. Ha közvetlenül szeretné beilleszteni az API-kulcsot, tekintse meg a következőt anthropic_api_key_plaintext: Az alábbi mezők egyikével kell megadnia egy API-kulcsot: anthropic_api_key vagy anthropic_api_key_plaintext.
anthropic_api_key_plaintext Az antropikus API-kulcs egyszerű szöveges sztringként van megadva. Ha a kulcs hivatkozásához az Azure Databricks Secrets használatát részesíti előnyben, tekintse meg a következőt: anthropic_api_key. Az alábbi mezők egyikével kell megadnia egy API-kulcsot: anthropic_api_key vagy anthropic_api_key_plaintext.

Azure OpenAI

Az Azure OpenAI a közvetlen OpenAI szolgáltatáshoz képest eltérő funkciókkal rendelkezik. Áttekintésért tekintse meg az összehasonlító dokumentációt.

Konfigurációs paraméter Leírás Kötelező Alapértelmezett
openai_api_key Az Azure Databricks titkos kulcsának referenciája egy OpenAI API-kulcshoz az Azure szolgáltatás használatával. Ha közvetlenül szeretné beilleszteni az API-kulcsot, tekintse meg a következőt openai_api_key_plaintext: Az alábbi mezők egyikével kell megadnia egy API-kulcsot: openai_api_key vagy openai_api_key_plaintext.
openai_api_key_plaintext Az OpenAI API-kulcs egyszerű szöveges karaktersorként megadva az Azure-szolgáltatásban. Ha a kulcs hivatkozásához az Azure Databricks Secrets használatát részesíti előnyben, tekintse meg a következőt: openai_api_key. Az alábbi mezők egyikével kell megadnia egy API-kulcsot: openai_api_key vagy openai_api_key_plaintext.
openai_api_type Hozzáférési jogkivonat érvényesítéséhez használható azure . Igen
openai_api_base Az Azure által biztosított Azure OpenAI API szolgáltatás alap URL-címe. Igen
openai_api_version Az Azure OpenAI szolgáltatás kihasználandó verziója, dátum szerint megadva. Igen
openai_deployment_name Az Azure OpenAI szolgáltatás üzembehelyezési erőforrásának neve. Igen
openai_organization Nem kötelező mező a szervezet OpenAI-ban való megadásához. No

Ha az Azure OpenAI-t Microsoft Entra-azonosítóval használja, használja az alábbi paramétereket a végpontkonfigurációban. A Databricks a Microsoft Entra azonosító token alapértelmezett hatóköreként adja át https://cognitiveservices.azure.com/.

Konfigurációs paraméter Leírás Kötelező Alapértelmezett
microsoft_entra_tenant_id A bérlői azonosító a Microsoft Entra ID-hitelesítéshez. Igen
microsoft_entra_client_id A Microsoft Entra ID-hitelesítés ügyfélazonosítója. Igen
microsoft_entra_client_secret Az Azure Databricks titkos kulcs hivatkozása a Microsoft Entra ID-hitelesítéshez használt ügyféltitokhoz. Ha inkább közvetlenül szeretné beilleszteni az ügyfél titkos kódját, olvassa el a következőt microsoft_entra_client_secret_plaintext: . Az alábbi mezők egyikével kell megadnia egy API-kulcsot: microsoft_entra_client_secret vagy microsoft_entra_client_secret_plaintext.
microsoft_entra_client_secret_plaintext A Microsoft Entra ID-hitelesítéshez használt ügyfélkód egyszerű szöveges sztringként van megadva. Ha a kulcs hivatkozásához az Azure Databricks Secrets használatát részesíti előnyben, tekintse meg a következőt: microsoft_entra_client_secret. Az alábbi mezők egyikével kell megadnia egy API-kulcsot: microsoft_entra_client_secret vagy microsoft_entra_client_secret_plaintext.
openai_api_type A azuread segítségével történik azonosítás a Microsoft Entra ID használatával. Igen
openai_api_base Az Azure által biztosított Azure OpenAI API szolgáltatás alap URL-címe. Igen
openai_api_version Az Azure OpenAI szolgáltatás kihasználandó verziója, dátum szerint megadva. Igen
openai_deployment_name Az Azure OpenAI szolgáltatás üzembehelyezési erőforrásának neve. Igen
openai_organization Nem kötelező mező a szervezet OpenAI-ban való megadásához. No

Az alábbi példa bemutatja, hogyan hozhat létre végpontot az Azure OpenAI-val:

client.create_endpoint(
    name="openai-chat-endpoint",
    config={
        "served_entities": [{
            "external_model": {
                "name": "gpt-3.5-turbo",
                "provider": "openai",
                "task": "llm/v1/chat",
                "openai_config": {
                    "openai_api_type": "azure",
                    "openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}",
                    "openai_api_base": "https://my-azure-openai-endpoint.openai.azure.com",
                    "openai_deployment_name": "my-gpt-35-turbo-deployment",
                    "openai_api_version": "2023-05-15"
                }
            }
        }]
    }
)

Google Cloud Vertex AI

Konfigurációs paraméter Leírás Kötelező Alapértelmezett
private_key A Azure Databricks titkos kulcsra vonatkozó hivatkozás a Google Cloud Vertex AI szolgáltatáshoz hozzáféréssel rendelkező szolgáltatásfiók JSON-fájljához. Ez a Google Cloudból letöltött JSON-kulcsfájl teljes tartalma, nem csak a private_key mező. Tekintse meg a szolgáltatásfiókkulcsok kezelésének ajánlott eljárásait. Ha inkább közvetlenül szeretné beilleszteni a kulcsot, tekintse meg a következőt private_key_plaintext: A kulcsot a következő mezők egyikével kell megadnia: private_key vagy private_key_plaintext.
private_key_plaintext A Google Cloud Vertex AI szolgáltatáshoz hozzáféréssel rendelkező szolgáltatásfiók JSON-kulcsának teljes JSON-kulcsa, amely egyszerű szöveges titkos kódként van megadva. Ez a Google Cloudból letöltött JSON-kulcsfájl teljes tartalma, nem csak a private_key mező. Tekintse meg a szolgáltatásfiókkulcsok kezelésének ajánlott eljárásait. Ha a kulcs hivatkozásához az Azure Databricks Secrets használatát részesíti előnyben, tekintse meg a következőt: private_key. A kulcsot a következő mezők egyikével kell megadnia: private_key vagy private_key_plaintext.
region Ez a Google Cloud Vertex AI szolgáltatás régiója. További részletekért tekintse meg a támogatott régiókat . Egyes modellek csak bizonyos régiókban érhetők el. Igen
project_id Ez a Google Cloud-projektazonosító, amelyhez a szolgáltatásfiók társítva van. Igen

Amazon Bedrock

Az Amazon Bedrock külső modellszolgáltatóként való használatához az ügyfeleknek meg kell győződni arról, hogy a Bedrock engedélyezve van a megadott AWS-régióban, és a megadott AWS-kulcspár megfelelő engedélyekkel rendelkezik a Bedrock-szolgáltatások használatához. További információ: AWS Identity and Access Management.

Konfigurációs paraméter Leírás Kötelező Alapértelmezett
aws_region A használni kívánt AWS-régió. A Bedrockot ott kell engedélyezni. Igen
aws_access_key_id Az Azure Databricks titkoskulcs-referenciája egy AWS hozzáférési kulcsazonosítóhoz, amely engedélyekkel rendelkezik a Bedrock-szolgáltatásokkal való interakcióhoz. Ha közvetlenül szeretné beilleszteni az API-kulcsot, tekintse meg a következőt aws_access_key_id_plaintext: Az alábbi mezők egyikével kell megadnia egy API-kulcsot: aws_access_key_id vagy aws_access_key_id_plaintext.
aws_access_key_id_plaintext Egy AWS hozzáférési kulcsazonosító, amely engedélyekkel rendelkezik a Bedrock-szolgáltatások egyszerű szöveges sztringként való használatához. Ha a kulcs hivatkozásához az Azure Databricks Secrets használatát részesíti előnyben, tekintse meg a következőt: aws_access_key_id. Az alábbi mezők egyikével kell megadnia egy API-kulcsot: aws_access_key_id vagy aws_access_key_id_plaintext.
aws_secret_access_key Az Azure Databricks titkos kulcsának hivatkozása egy AWS titkos hozzáférési kulcshoz, amely hozzáférési kulcs azonosítójával van párosítva, és rendelkezik engedélyekkel a Bedrock-szolgáltatásokkal történő interakcióhoz. Ha közvetlenül szeretné beilleszteni az API-kulcsot, tekintse meg a következőt aws_secret_access_key_plaintext: Az alábbi mezők egyikével kell megadnia egy API-kulcsot: aws_secret_access_key vagy aws_secret_access_key_plaintext.
aws_secret_access_key_plaintext A hozzáférési kulcs azonosítójával párosított AWS titkos hozzáférési kulcs, amely egyszerű szöveges sztringként nyújtott Bedrock-szolgáltatásokkal való interakcióra vonatkozó engedélyekkel rendelkezik. Ha a kulcs hivatkozásához az Azure Databricks Secrets használatát részesíti előnyben, tekintse meg a következőt: aws_secret_access_key. Az alábbi mezők egyikével kell megadnia egy API-kulcsot: aws_secret_access_key vagy aws_secret_access_key_plaintext.
bedrock_provider Az Amazon Bedrock mögöttes szolgáltatója. Támogatott értékek (nem érzékeny a kis- és nagybetűkre) a következők: Anthropic, Cohere, AI21Labs, Amazon Igen

Az alábbi példa bemutatja, hogyan hozhat létre végpontot az Amazon Bedrock használatával hozzáférési kulcsok használatával.

client.create_endpoint(
    name="bedrock-anthropic-completions-endpoint",
    config={
        "served_entities": [
            {
                "external_model": {
                    "name": "claude-v2",
                    "provider": "amazon-bedrock",
                    "task": "llm/v1/completions",
                    "amazon_bedrock_config": {
                        "aws_region": "<YOUR_AWS_REGION>",
                        "aws_access_key_id": "{{secrets/my_amazon_bedrock_secret_scope/aws_access_key_id}}",
                        "aws_secret_access_key": "{{secrets/my_amazon_bedrock_secret_scope/aws_secret_access_key}}",
                        "bedrock_provider": "anthropic",
                    },
                }
            }
        ]
    },
)

Note

Ha a meglévő Amazon Bedrock-védőkorlátokat az Amazon Bedrock-modellekkel szeretné használni az AI Gatewayen keresztül, beállíthatja a X-Amzn-Bedrock-GuardrailIdentifier fejlécet a választott védőkorlát ARN értékére, és szükség szerint beállíthatja X-Amzn-Bedrock-GuardrailVersion . Ezeket a fejléceket a rendszer az Amazon Bedrocknak továbbítja.

Ha AWS-engedélyekkel kapcsolatos problémák merülnek fel, a Databricks azt ajánlja, hogy a hitelesítő adatokat közvetlenül a Amazon Bedrock APIellenőrizze.

AI21 Labs

Konfigurációs paraméter Leírás Kötelező Alapértelmezett
ai21labs_api_key Az Azure Databricks titkos kulcsának referenciája egy AI21 Labs API-kulcshoz. Ha közvetlenül szeretné beilleszteni az API-kulcsot, tekintse meg a következőt ai21labs_api_key_plaintext: Az alábbi mezők egyikével kell megadnia egy API-kulcsot: ai21labs_api_key vagy ai21labs_api_key_plaintext.
ai21labs_api_key_plaintext Az AI21 Labs API-kulcsot karaktersorozatként egyszerű szövegként adják meg. Ha a kulcs hivatkozásához az Azure Databricks Secrets használatát részesíti előnyben, tekintse meg a következőt: ai21labs_api_key. Az alábbi mezők egyikével kell megadnia egy API-kulcsot: ai21labs_api_key vagy ai21labs_api_key_plaintext.

Testreszabott szolgáltató

Important

Egyéni szolgáltatói modell használatához OpenAI API-kompatibilisnek kell lennie.

Konfigurációs paraméter Leírás Kötelező Alapértelmezett
custom_provider_url Az URL, ahol az egyéni szolgáltató modellje található. Az URL-címnek egy adott API-végpontra kell mutatnia; például https://api.provider.com/chat/completions. Igen
bearer_token_auth Ha a testreszabott szolgáltató bearer token hitelesítést alkalmaz, adja meg a szükséges mezőket. A hitelesítési módszert a következő mezők egyikével kell megadnia: bearer_token_auth vagy api_key_auth.
token Az Azure Databricks titkos kulcs hivatkozása a jogkivonathoz a megőrzői hitelesítéshez. Ezt a paramétert a bearer_token_authalatt kell beágyazni. Ha közvetlenül szeretné beilleszteni az API-kulcsot, tekintse meg a következőt token_plaintext: Ha tulajdonosi hitelesítést használ, az alábbi mezők egyikével kell megadnia egy API-kulcsot: token vagy token_plaintext.
token_plaintext A hordozói hitelesítési token egyszerű szövegként van megadva. Ezt a paramétert a bearer_token_authalatt kell beágyazni. Ha inkább az Azure Databricks titkos funkcióit akarja használni a kulcsok hivatkozásához, tekintse meg token. Ha tulajdonosi hitelesítést használ, az alábbi mezők egyikével kell megadnia egy API-kulcsot: token vagy token_plaintext.
api_key_auth Ha az egyéni szolgáltató API-kulcs-hitelesítést használ, adja meg a szükséges mezőket. A hitelesítési módszert a következő mezők egyikével kell megadnia: bearer_token_auth vagy api_key_auth.
key Az API-kulcs hitelesítésének kulcsa. Ennek a paraméternek a api_key_auth alá kell kerülnie. Igen, API-kulcsos hitelesítés használatakor.
value Az Azure Databricks titkos kulcs referenciája az API-kulcs hitelesítési értékéhez. Ha közvetlenül szeretné beilleszteni az API-kulcsot, tekintse meg a következőt value_plaintext: API-kulcs hitelesítése esetén az alábbi mezők egyikével kell megadnia egy API-kulcsot: value vagy value_plaintext.
value_plaintext Az API-kulcs hitelesítésének értéke egyszerű szöveges karakterláncként. Ha inkább az Azure Databricks titkos funkcióit akarja használni a kulcsok hivatkozásához, tekintse meg value. API-kulcs hitelesítése esetén az alábbi mezők egyikével kell megadnia egy API-kulcsot: value vagy value_plaintext.

Az alábbi példa bemutatja, hogyan hozhat létre végpontot egyéni szolgáltatóval bizományosi hitelesítéshasználatával.

client.create_endpoint(
    name="custom-provider-completions-endpoint",
    config={
        "served_entities": [
            {
                "external_model": {
                    "name": "custom-provider-model",
                    "provider": "custom",
                    "task": "llm/v1/chat",
                    "custom_provider_config": {
                        "custom_provider_url": "https://api.provider.com/chat/completions",
                        "bearer_token_auth": {
                            "token": "{{secrets/my_custom_provider_secret_scope/custom_provider_token}}"
                        }
                    }
                }
            }
        ]
    },
)

Az alábbi példa bemutatja, hogyan hozhat létre végpontot egyedi szolgáltatóval a API-kulcshitelesítést használva:

client.create_endpoint(
    name="custom-provider-completions-endpoint",
    config={
        "served_entities": [
            {
                "external_model": {
                    "name": "custom-provider-model",
                    "provider": "custom",
                    "task": "llm/v1/chat",
                    "custom_provider_config": {
                        "custom_provider_url": "https://my-custom-provider.com",
                        "api_key_auth": {
                            "key": "X-API-KEY",
                            "value": "{{secrets/my_custom_provider_secret_scope/custom_provider_api_key}}"
                        }
                    }
                }
            }
        ]
    },
)

AI-átjáró konfigurálása egy végponton

A végpontot úgy is konfigurálhatja, hogy engedélyezze az AI-átjáró funkcióit, például a sebességkorlátozást, a használatkövetést és a védőkorlátokat.

Lásd: AI-átjáró konfigurálása a modellkiszolgálási végpontokon.

Külső modellvégpont lekérdezése

Miután létrehozott egy külső modellvégpontot, készen áll a felhasználóktól érkező forgalom fogadására.

Pontozási kéréseket küldhet a végpontnak az OpenAI-ügyfél, a REST API vagy az MLflow Deployments SDK használatával.

Az alábbi példa lekérdezi az claude-2 Anthropic által üzemeltetett befejezési modellt az OpenAI-ügyfél használatával. Az OpenAI-ügyfél használatához töltse ki a model mezőt a lekérdezni kívánt modellt futtató végpontot kiszolgáló modell nevével.

Ez a példa egy korábban létrehozott végpontot használ, anthropic-completions-endpointamely az antropikus modellszolgáltatótól származó külső modellek eléréséhez van konfigurálva. Tekintse meg, hogyan hozhat létre külső modellvégpontokat.

Lásd a támogatott modelleket a további lekérdezhető modellek és szolgáltatóik megtekintéséhez.

import os
import openai
from openai import OpenAI

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

completion = client.completions.create(
  model="anthropic-completions-endpoint",
  prompt="what is databricks",
  temperature=1.0
)
print(completion)

Várt kimeneti válaszformátum:

{
"id": "123", # Not Required
"model": "anthropic-completions-endpoint",
"choices": [
  {
    "text": "Hello World!",
    "index": 0,
    "logprobs": null, # Not Required
    "finish_reason": "length" # Not Required
  }
],
"usage": {
  "prompt_tokens": 8,
  "total_tokens": 8
  }
}

További lekérdezési paraméterek

A lekérdezés részeként átadhat minden további paramétert, amelyet a végpont szolgáltatója támogat.

Például:

  • logit_bias (az OpenAI és a Cohere támogatja).
  • top_k (az Anthropic, Cohere támogatásával).
  • frequency_penalty (az OpenAI és a Cohere támogatja).
  • presence_penalty (az OpenAI és a Cohere támogatja).
  • stream (támogatja: OpenAI, Anthropic, Cohere, Amazon Bedrock for Anthropic). Ez csak csevegési és befejezési kérelmek esetén érhető el.
  • tools (OpenAI, Anthropic és az Amazon Bedrock for Anthropic támogatásával). Ez csak csevegési és befejezési kérelmek esetén érhető el. Ez a paraméter lehetővé teszi a külső funkciók integrálását, beleértve a Computer Use (bétaverzió) az Anthropic és az Amazon Bedrock Anthropic számára. Tekintse meg az Azure Databricks függvényhívását: .

A hálózati kapcsolat konfigurációi támogatják a külső modelleket

A külső modellek hálózati kapcsolati konfigurációinak (NCC-knek, beleértve az Azure private linket) támogatása nyilvános előzetes verzióban érhető el. Az előzetes verzióban való részvételhez lépjen kapcsolatba a Databricks-fiók csapatával.

Limitations

A választott külső modelltől függően előfordulhat, hogy a konfiguráció miatt az adatok feldolgozása azon a régión kívül történik, ahonnan az adatok származnak. Lásd: Modellmegjelenítési korlátok és régiók.

További források

  • Last updated on