Modèles externes dans Model Serving
Cette page décrit les modèles externes configurés directement sur un endpoint de Model Serving. Pour enregistrer des fournisseurs de modèles externes en tant qu'objets Unity Catalog régis que vous pouvez query dans les Workspaces et sur lesquels vous pouvez suivre les dépenses, consultez Services de fournisseurs de modèles dans Unity Catalog.
Les exemples de code de cet article démontrent l'utilisation de la préversion publique de l'API CRUD des déploiements MLflow.
Cet article décrit les modèles externes dans Model Serving, y compris ses fournisseurs de modèles pris en charge et ses limitations.
Que sont les modèles externes ?
Vous pouvez maintenant configurer la passerelle IA sur des Endpoint de mise en service de modèles qui servent des modèles externes. AI Gateway apporte la gouvernance, le monitoring et la préparation à la production à ces Endpoint de service de modèle. Voir Gouvernance de l’IA avec Unity AI Gateway.
Les modèles externes sont des modèles tiers hébergés en dehors de Databricks. Pris en charge par Model Serving, les modèles externes vous permettent de rationaliser l'utilisation et la gestion de divers fournisseurs de grands modèles de langage (LLM), tels qu'OpenAI et Anthropic, au sein d'une organisation. Vous pouvez également utiliser Model Serving en tant que fournisseur pour servir des modèles personnalisés, ce qui offre des limites de débit pour ces Endpoint. Dans le cadre de ce support, Model Serving offre une interface de haut niveau qui simplifie l’interaction avec ces services en fournissant un Endpoint unifié pour gérer les requêtes spécifiques liées aux LLM.
De plus, le support Databricks pour les modèles externes fournit une gestion centralisée des identifiants. En stockant les clés API dans un emplacement sécurisé, les organisations peuvent renforcer leur posture de sécurité en minimisant l'exposition des clés API sensibles dans l'ensemble du système. Cela permet également d'éviter d'exposer ces clés dans le code ou d'exiger des utilisateurs finaux qu'ils gèrent les clés en toute sécurité.
Voir Tutoriel : Créer des Endpoint de modèle externes pour query des modèles OpenAI pour des conseils pas à pas sur la création d'Endpoint de modèle externes et l'query des modèles pris en charge servis par ces Endpoint à l'aide du SDK de déploiement MLflow. Consultez les guides suivants pour obtenir des instructions sur l’utilisation de l’interface utilisateur Serving et de l’API REST :
Exigences
- Clé API ou champs d'authentification pour le fournisseur de modèles.
- Workspace Databricks dans les régions prises en charge par les modèles externes.
Fournisseurs de modèles
Les modèles externes dans Model Serving sont conçus pour prendre en charge une variété de fournisseurs de modèles. Un fournisseur représente la source des Modèles de machine learning, tels qu'OpenAI, Anthropic, etc. Chaque fournisseur a ses propres caractéristiques et configurations qui sont encapsulées dans le champ external_model de la configuration de l'Endpoint de modèle externe.
Les fournisseurs suivants sont pris en charge :
- openai : Pour les modèles proposés par OpenAI et les intégrations Azure pour Azure OpenAI et Azure OpenAI avec AAD.
- anthropic : Pour les modèles proposés par Anthropic.
- cohere : pour les modèles proposés par Cohere.
- amazon-bedrock : Pour les modèles offerts par Amazon Bedrock.
- google-cloud-vertex-ai : pour les modèles offerts par Google Cloud Vertex AI.
- databricks-model-serving : Pour les Endpoint de Model Serving dotés de schémas compatibles. Consultez la Configuration de l'Endpoint.
- custom : Pour les fournisseurs ou modèles alternatifs derrière des proxys personnalisés qui sont compatibles avec l'API OpenAI, mais non directement pris en charge par Databricks.
Pour demander de l'aide pour un fournisseur non listé ici, essayez d'utiliser l'option de fournisseur personnalisé ou contactez votre équipe de compte Databricks.
Modèles pris en charge
Le modèle que vous choisissez affecte directement les résultats des réponses que vous obtenez des appels d'API. Par conséquent, choisissez un modèle qui répond à vos exigences de cas d'utilisation. Par exemple, pour la génération de réponses conversationnelles, vous pouvez choisir un modèle de discussion. Inversement, pour générer des intégrations de texte, vous pouvez choisir un modèle d'intégration.
Consultez les modèles pris en charge.
Utiliser les modèles servis sur les endpoints de Model Serving
Les Endpoints de Model Serving en tant que fournisseur sont pris en charge pour les types d'Endpoint llm/v1/completions, llm/v1/chat et llm/v1/embeddings. Ces Endpoints doivent accepter les query parameters standards marqués comme requis, tandis que d'autres parameters pourraient être ignorés selon que l'Endpoint de Model Serving les prend en charge ou non.
Voir POST /serving-endpoints/{name}/invocations dans la référence de l'API pour les paramètres de query standard.
Ces Endpoint doivent produire des réponses dans le format OpenAI suivant.
Pour les tâches d'achèvement :
{
"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
}
}
Pour les tâches de chat :
{
"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
}
}
Pour les tâches d'intégrations :
{
"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
}
}
Configuration de l'Endpoint
Pour déployer et interroger des modèles externes, vous devez configurer un endpoint de déploiement. Voir Créer un endpoint de service de modèle externe
Pour un Endpoint de diffusion de modèle externe, vous devez inclure le champ external_model et ses parameters dans la section served_entities de la configuration de l'Endpoint. Si vous configurez plusieurs modèles externes dans un Endpoint de diffusion, vous devez fournir un traffic_config pour définir le pourcentage de routage du trafic pour chaque modèle externe.
Le champ external_model définit le modèle vers lequel cet endpoint transfère les requêtes. Lorsque vous spécifiez un modèle, il est essentiel que le fournisseur prenne en charge le modèle que vous demandez. Par exemple, openai en tant que fournisseur prend en charge des modèles tels que text-embedding-ada-002, mais d'autres fournisseurs pourraient ne pas le faire. Si le modèle n'est pas pris en charge par le fournisseur, Databricks renvoie une erreur HTTP 4xx lors de la tentative de routage des requêtes vers ce modèle.
Le tableau ci-dessous récapitule les paramètres de champ external_model. Consultez POST /api/2.0/serving-endpoints pour les paramètres de configuration des Endpoint.
parameter | Descriptions |
|---|---|
| Le nom du modèle à utiliser. Par exemple, |
| Indique le nom du fournisseur pour ce modèle. Cette valeur de chaîne doit correspondre à un fournisseur de modèle externe pris en charge. Par exemple, |
| La tâche correspond au type d'interaction du modèle linguistique que vous souhaitez. Les tâches prises en charge sont « llm/v1/completions », « llm/v1/chat », « llm/v1/embeddings ». |
| Contient tous les détails de configuration supplémentaires nécessaires pour le modèle. Cela inclut la spécification de l'URL de base de l'API et de la clé API. Consultez Configurer le fournisseur d'un Endpoint. Si vous utilisez le fournisseur |
Voici un exemple de création d'un endpoint de modèle externe à l'aide de l'API create_endpoint(). Dans cet exemple, une requête envoyée à l'Endpoint de complétion est transmise au modèle claude-2 fourni par 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}}"
}
}
}
]
}
)
Configure le fournisseur pour un Endpoint
Lorsque vous créez un endpoint, vous devez fournir les configurations requises pour le fournisseur de modèle spécifié. Les sections suivantes récapitulent les paramètres de configuration d'endpoint disponibles pour chaque fournisseur de modèles.
Databricks chiffre et stocke en toute sécurité les identifiants fournis pour chaque fournisseur de modèle. Ces identifiants sont automatiquement supprimés lorsque leurs Endpoint associés sont supprimés.
OpenAI
Paramètre de configuration | Description | Obligatoire | Par défaut |
|---|---|---|---|
| La référence de la clé secrète Databricks pour une clé API OpenAI utilisant le service OpenAI. Si vous préférez coller votre clé API directement, veuillez consulter | Vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| La clé API OpenAI utilisant le service OpenAI fourni sous forme de chaîne de texte brut. Si vous préférez référencer votre clé à l'aide de Databricks Secrets, consultez | Vous devez fournir une clé API en utilisant l'un des champs suivants : | |
| Un champ facultatif pour spécifier le type d'API OpenAI à utiliser. | Non |
|
| L'URL de base de l'API OpenAI. | Non |
|
| Un champ facultatif pour spécifier la version de l'API OpenAI. | Non | |
| Un champ facultatif pour spécifier l'organisation dans OpenAI. | Non |
Cohere
Paramètre de configuration | Description | Obligatoire | Par défaut |
|---|---|---|---|
| La référence de clé secrète Databricks pour une clé API Cohere. Si vous préférez coller votre clé API directement, veuillez consulter | Vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| La clé API Cohere fournie sous forme de chaîne de texte brut. Si vous préférez référencer votre clé à l'aide de Databricks Secrets, consultez | Vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| L'URL de base pour le service Cohere. | Non |
Anthropic
Paramètre de configuration | Description | Obligatoire | Par défaut |
|---|---|---|---|
| La référence de la clé secrète Databricks pour une clé API Anthropic. Si vous préférez coller votre clé API directement, veuillez consulter | Vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| La clé API Anthropic fournie sous forme de chaîne en texte brut. Si vous préférez référencer votre clé à l'aide de Databricks Secrets, consultez | Vous devez fournir une clé API à l'aide de l'un des champs suivants : |
Azure OpenAI
Azure OpenAI présente des fonctionnalités distinctes par rapport au service OpenAI direct. Pour un aperçu, veuillez consulter la documentation de comparaison.
Paramètre de configuration | Description | Obligatoire | Par défaut |
|---|---|---|---|
| La référence de clé secrète Databricks pour une clé API OpenAI utilisant le service Azure. Si vous préférez coller votre clé API directement, veuillez consulter | Vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| La clé de l'API OpenAI utilisant le service Azure fournie sous forme de chaîne de caractères en clair. Si vous préférez référencer votre clé à l'aide de Databricks Secrets, consultez | Vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| Utiliser | Oui | |
| L'URL de base du service Azure OpenAI API fourni par Azure. | Oui | |
| La version du service Azure OpenAI à utiliser, spécifiée par une date. | Oui | |
| Le nom de la ressource de déploiement pour le service Azure OpenAI. | Oui | |
| Un champ facultatif pour spécifier l'organisation dans OpenAI. | Non |
Si vous utilisez Azure OpenAI avec Microsoft Entra ID, utilisez les paramètres suivants dans votre configuration de Endpoint. Databricks transmet https://cognitiveservices.azure.com/ comme étendue default pour le jeton Microsoft Entra ID.
Paramètre de configuration | Description | Obligatoire | Par défaut |
|---|---|---|---|
| L'ID de tenant pour l'authentification Microsoft Entra ID. | Oui | |
| L'ID client pour l'authentification Microsoft Entra ID. | Oui | |
| La référence de la clé secrète Databricks pour un secret client utilisé pour l'authentification Microsoft Entra ID. Si vous préférez coller votre secret client directement, consultez | Vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| La clé secrète client utilisée pour l'authentification Microsoft Entra ID fournie sous forme de chaîne de texte brut. Si vous préférez référencer votre clé à l'aide de Databricks Secrets, consultez | Vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| Utilisez | Oui | |
| L'URL de base du service Azure OpenAI API fourni par Azure. | Oui | |
| La version du service Azure OpenAI à utiliser, spécifiée par une date. | Oui | |
| Le nom de la ressource de déploiement pour le service Azure OpenAI. | Oui | |
| Un champ facultatif pour spécifier l'organisation dans OpenAI. | Non |
L'exemple suivant montre comment créer un Endpoint avec Azure OpenAI :
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
Paramètre de configuration | Description | Obligatoire | Par défaut |
|---|---|---|---|
| Référence de la clé secrète Databricks pour le fichier JSON de la clé de compte de service complet du compte de service qui a accès au service Google Cloud Vertex AI. Il s'agit de l'intégralité du contenu du fichier de clé JSON download depuis Google Cloud, et pas seulement du champ | Vous devez fournir une clé en utilisant l'un des champs suivants : | |
| La clé de compte de service JSON complète du compte de service ayant accès au service Google Cloud Vertex AI, fournie en tant que secret en texte clair. Il s'agit de l'intégralité du contenu du fichier de clé JSON download depuis Google Cloud, et pas seulement du champ | Vous devez fournir une clé en utilisant l'un des champs suivants : | |
| Ceci est la région pour le service Google Cloud Vertex AI. Consultez les régions prises en charge pour plus de détails. Certains modèles ne sont disponibles que dans des régions spécifiques. | Oui | |
| Il s'agit de l'ID de projet Google Cloud auquel le compte de service est associé. | Oui |
Amazon Bedrock
Pour utiliser Amazon Bedrock comme fournisseur de modèles externe, les clients doivent s'assurer que Bedrock est activé dans la région AWS spécifiée et que la paire de clés AWS spécifiée dispose des autorisations appropriées pour interagir avec les services Bedrock. Pour en savoir plus, consultez AWS Identity and Access Management.
Amazon Bedrock prend en charge plusieurs mécanismes d'authentification. Un seul des éléments suivants doit être fourni :
- Une informations d'identification de service Unity Catalog qui référence un rôle IAM AWS
- Un profil d'instance AWS
- AWS clés d'accès (en utilisant Databricks Secrets ou en texte brut)
Si des clés d'accès sont utilisées, **à la fois** un ID de clé d'accès et une clé d'accès secrète sont requis.
Paramètre de configuration | Description | Obligatoire | Par défaut |
|---|---|---|---|
| La région AWS à utiliser. Amazon Bedrock doit être activé dans cette région. | Oui | |
| Référence à un identifiant de service Unity Catalog utilisé par l'entité servie pour accéder aux Ressources AWS. Les informations d'identification doivent faire référence à un rôle IAM AWS. | Non | |
| Nom de ressource Amazon (ARN) du profil d'instance utilisé par l'entité servie pour accéder aux ressources AWS. | Non | |
| ID de clé d'accès AWS utilisé par l'entité servie pour accéder aux ressources AWS, fourni à l'aide d'une référence de secret Databricks. | Non | |
| ID de clé d'accès AWS utilisé par l'entité servie pour accéder aux Ressources AWS, fourni sous forme de chaîne de caractères en clair. | Non | |
| Clé d’accès secrète AWS utilisée par l’entité servie pour accéder aux ressources AWS, associée à l’ID de la clé d’accès et fournie à l’aide d’une référence secrète Databricks. | Non | |
| Clé d'accès secrète AWS utilisée par l'entité servie pour accéder aux ressources AWS, associée à l'ID de la clé d'accès et fournie sous forme de chaîne de texte brut. | Non | |
| Le fournisseur sous-jacent dans Amazon Bedrock. Valeurs prises en charge (non sensible à la casse) : Anthropic, Cohere, AI21Labs, Amazon. | Oui |
L'exemple suivant montre comment créer un Endpoint avec Amazon Bedrock à l'aide d'un profil d'instance. Si vous préférez utiliser des clés d'accès, utilisez aws_access_key_id et aws_secret_access_key. Si vous préférez utiliser un identifiant de service, utilisez uc_service_credential_name.
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>",
"uc_service_credential_name": "<YOUR_UC_SERVICE_CREDENTIAL_NAME>", ## Remove if using other authentication methods
# "instance_profile_arn": "<YOUR_AWS_INSTANCE_PROFILE_ARN>",
# "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",
},
}
}
]
},
)
Pour utiliser les garde-fous Amazon Bedrock existants avec les modèles Amazon Bedrock via AI Gateway, vous pouvez définir l'en-tête X-Amzn-Bedrock-GuardrailIdentifier sur l'ARN du garde-fou de votre choix, et définir X-Amzn-Bedrock-GuardrailVersion si nécessaire. Ces en-têtes sont transmis à Amazon Bedrock.
S'il y a des problèmes d'autorisations AWS, Databricks vous recommande de vérifier les identifiants directement avec l'API Amazon Bedrock.
AI21 Labs
Paramètre de configuration | Description | Obligatoire | Par défaut |
|---|---|---|---|
| La référence de clé secrète Databricks pour une clé API AI21 Labs. Si vous préférez coller votre clé API directement, veuillez consulter | Vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| Une clé API AI21 Labs fournie sous forme de chaîne en texte brut. Si vous préférez référencer votre clé à l'aide de Databricks Secrets, consultez | Vous devez fournir une clé API à l'aide de l'un des champs suivants : |
Fournisseur personnalisé
Pour utiliser un modèle de fournisseur personnalisé, il doit être compatible avec l'API OpenAI.
Paramètre de configuration | Description | Obligatoire | Par défaut |
|---|---|---|---|
| L’URL où se trouve le modèle du fournisseur personnalisé. L’URL doit pointer vers un endpoint API spécifique ; par exemple, | Oui | |
| Si le fournisseur personnalisé utilise l'authentification par jeton porteur, veuillez spécifier les champs requis. | Vous devez fournir une méthode d'authentification à l'aide de l'un des champs suivants : | |
| La référence de la clé secrète Databricks pour le jeton d'authentification du porteur. Ce parameter doit être imbriqué sous | Si vous utilisez l'authentification par jeton bearer, vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| Le jeton pour l'authentification du porteur, fourni sous forme de chaîne de texte brut. Ce parameter doit être imbriqué sous | Si vous utilisez l'authentification par jeton bearer, vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| Si le fournisseur personnalisé utilise l'authentification par clé API, spécifiez les champs requis. | Vous devez fournir une méthode d'authentification à l'aide de l'un des champs suivants : | |
| La clé pour l'authentification par clé API. Ce paramètre doit être imbriqué sous | Oui, lorsque vous utilisez l'authentification par clé d'API. | |
| La référence de la clé secrète Databricks pour la valeur de l'authentification par clé API. Si vous préférez coller votre clé API directement, veuillez consulter | Si vous utilisez l'authentification par clé API, vous devez fournir une clé API à l'aide de l'un des champs suivants : | |
| La valeur pour l'authentification par clé API fournie sous forme de chaîne de texte brut. Si vous préférez référencer votre clé à l'aide des secrets Databricks, consultez | Si vous utilisez l'authentification par clé API, vous devez fournir une clé API à l'aide de l'un des champs suivants : |
L'exemple suivant montre comment créer un endpoint avec un fournisseur personnalisé en utilisant l' authentification par jeton du porteur :
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}}"
}
}
}
}
]
},
)
L’exemple suivant montre comment créer un endpoint avec un fournisseur personnalisé à l’aide de l’ authentification par clé d’API :
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}}"
}
}
}
}
]
},
)
Configurer la passerelle IA sur un endpoint
Vous pouvez également configurer votre Endpoint pour activer les fonctionnalités de la Passerelle IA, telles que la limitation du débit, le suivi de l’utilisation et les garde-fous.
Consultez Configurer la passerelle IA sur les Endpoint Model Serving.
Query un endpoint de modèle externe
Après avoir créé un endpoint de modèle externe, il est prêt à recevoir du trafic des utilisateurs.
Vous pouvez envoyer des requêtes de scoring à l'endpoint en utilisant le client OpenAI, l'API REST ou le SDK de déploiement MLflow.
- Consultez les paramètres de query standard pour une requête de scoring dans POST /serving-endpoints/{name}/invocations.
- Utiliser les modèles de fondation
L'exemple suivant interroge le modèle de complétions claude-2 hébergé par Anthropic à l'aide du client OpenAI. Pour utiliser le client OpenAI, renseignez le champ model avec le nom de l'Endpoint de mise à disposition du modèle qui héberge le modèle que vous souhaitez interroger.
Cet exemple utilise un Endpoint créé précédemment, anthropic-completions-endpoint, configuré pour l'accès aux modèles externes du fournisseur de modèles Anthropic. Découvrez comment créer des Endpoints de modèles externes.
Consultez Modèles pris en charge pour les modèles supplémentaires que vous pouvez interroger et leurs fournisseurs.
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)
Format de la réponse de sortie attendue :
{
"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
}
}
Paramètres de query supplémentaires
Vous pouvez transmettre tous les paramètres supplémentaires pris en charge par le fournisseur de l'endpoint dans votre requête.
Par exemple :
-
logit_bias(pris en charge par OpenAI, Cohere). -
top_k(pris en charge par Anthropic, Cohere). -
frequency_penalty(pris en charge par OpenAI, Cohere). -
presence_penalty(pris en charge par OpenAI, Cohere). -
stream(pris en charge par OpenAI, Anthropic, Cohere, Amazon Bedrock pour Anthropic). Ceci n'est disponible que pour les requêtes de chat et de complétion. -
tools(pris en charge par OpenAI, Anthropic, Amazon Bedrock pour Anthropic). Ceci est disponible uniquement pour les requêtes de chat et de complétions. Ce parameter permet l'intégration de fonctionnalités externes, y compris Computer Use (beta) pour Anthropic et Amazon Bedrock pour Anthropic. Voir l'Appel de fonction sur Databricks.
Prise en charge des configurations de connectivité réseau pour les modèles externes
La prise en charge des configurations de connectivité réseau (CCN) pour les modèles externes, y compris AWS PrivateLink, est actuellement en préversion publique. Contactez votre équipe de compte Databricks pour participer à l’aperçu.
Limitations
Selon le modèle externe que vous choisissez, votre configuration pourrait entraîner le traitement de vos données en dehors de la région d'origine de vos données. Voir les limites et les régions de Model Serving.