Modelos externos no Serviço de Modelo do Mosaic AI

Importante

Os exemplos de código neste artigo demonstram o uso da API CRUD de implantações do MLflow em Visualização Pública.

Este artigo descreve os modelos externos no Mosaic AI Model Serving, incluindo seus provedores de modelo com suporte e limitações.

O que são modelos externos?

Importante

Agora você pode configurar o Gateway do Mosaic AI em pontos de extremidade de serviço de modelo que atendem a modelos externos. O Gateway de IA oferece governança, monitoramento e preparação para produção para esses pontos de extremidade de serviço de modelo. Consulte a introdução ao Gateway o Mosaic AI.

Os modelos externos são modelos de terceiros hospedados fora do Databricks. Com o Serviço de Modelo, os modelos externos permitem simplificar o uso e o gerenciamento de vários provedores de modelos de linguagem grande (LLM), como o OpenAI e o Anthropic, em uma organização. Você também pode usar o Serviço de Modelo do Mosaic AI como provedor para atender a modelos personalizados, que oferece limites de taxa para esses pontos de extremidade. Como parte desse suporte, o Serviço de Modelo oferece uma interface de alto nível que simplifica a interação com esses serviços, fornecendo um ponto de extremidade unificado para lidar com solicitações específicas relacionadas ao LLM.

Além disso, o suporte do Azure Databricks para modelos externos fornece gerenciamento centralizado de credenciais. Ao armazenar chaves de API em um local seguro, as organizações podem aprimorar sua postura de segurança minimizando a exposição de chaves de API confidenciais em todo o sistema. Também ajuda a evitar a exposição dessas chaves no código ou requer que os usuários finais gerenciem as chaves com segurança.

Veja Tutorial: Criar pontos de extremidade de modelo externo para consultar modelos OpenAI para obter orientação passo a passo sobre a criação de ponto de extremidade de modelo externo e consultar modelos suportados atendidos por esses pontos de extremidade usando o SDK de implantações do MLflow. Veja os guias a seguir para obter instruções sobre como usar a IU de serviço e a API REST:

• Criar pontos de extremidade do serviço de modelo personalizados
• Usar modelos de base

Requisitos

• Chave de API ou campos de autenticação para o provedor de modelo.
• Workspace do Databricks em Regiões com suporte para modelos externos.

Fornecedores de modelos

Os modelos externos no Serviço de Modelo são projetados para dar suporte a uma variedade de provedores de modelos. Um provedor representa a origem dos modelos de aprendizado de máquina, como OpenAI, Anthropic e assim por diante. Cada provedor tem suas características e configurações específicas que são encapsuladas no campo external_model da configuração do ponto de extremidade do modelo externo.

Os seguintes provedores têm suporte:

• openai: Para modelos oferecidos pelo OpenAI e pelas integrações do Azure para Azure OpenAI e Azure OpenAI com AAD.
• anthropic: para modelos oferecidos por Anthropic.
• cohere: para modelos oferecidos por Cohere.
• amazon-bedrock: para modelos oferecidos pela Amazon Bedrock.
• google-cloud-vertex-ai: Para modelos oferecidos pelo Google Cloud Vertex AI.
• databricks-model-serving: para endpoints do Mosaic AI Model Serving com esquemas compatíveis. Consulte Configuração do ponto de extremidade.
• personalizado: para provedores ou modelos alternativos por trás de proxies personalizados compatíveis com a API OpenAI, mas sem suporte direto do Databricks.

Para solicitar suporte para um provedor não listado aqui, tente usar a opção de provedor personalizado ou entre em contato com sua equipe de conta do Databricks.

Modelos com suporte

O modelo escolhido afeta diretamente os resultados das respostas que você obtém das chamadas à API. Portanto, escolha um modelo que se ajuste aos requisitos de seu caso de uso. Por exemplo, para gerar respostas de conversas, você pode escolher um modelo de chat. Por outro lado, para gerar inserções de texto, você pode escolher um modelo de inserção.

Confira os modelos com suporte.

Usar modelos servidos nos pontos de extremidade do Serviço de Modelo do Mosaic AI

Os pontos de extremidade do Serviço de Modelo do Mosaic AI como provedor têm suporte para os tipos de ponto de extremidade llm/v1/completions, llm/v1/chat e llm/v1/embeddings. Esses pontos de extremidade devem aceitar os parâmetros de consulta padrão marcados como obrigatórios, enquanto outros parâmetros podem ser ignorados, dependendo se o ponto de extremidade do Mosaic AI Model Serving dá suporte a eles ou não.

Confira POST /serving-endpoints/{name}/invocations na referência de API para parâmetros de consulta padrão.

Esses pontos de extremidade devem gerar respostas no seguinte formato OpenAI.

Para tarefas de conclusão:

{
"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
  }
}

Para tarefas de chats:

{
  "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
  }
}

Para tarefas de incorporação de dados:

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

Configuração de endpoint

Para acionar e consultar modelos externos, você precisa configurar um endpoint de serviço. Consulte Criar um ponto de extremidade de serviço de modelo externo

Para um ponto de extremidade de serviço de modelo externo, você deve incluir o campo external_model e seus parâmetros na seção served_entities da configuração do ponto de extremidade. Se você configurar vários modelos externos em um ponto de extremidade de serviço, deverá fornecer um traffic_config para definir a porcentagem de roteamento de tráfego para cada modelo externo.

O campo external_model define o modelo para o qual este endpoint encaminha solicitações. Ao especificar um modelo, é crítico que o fornecedor dê suporte para o modelo que você está solicitando. Por exemplo, openai como provedor tem suporte para modelos como text-embedding-ada-002, mas outros provedores podem não ter. Se o modelo não for suportado pelo provedor, o Databricks retornará um erro HTTP 4xx ao tentar rotear solicitações para esse modelo.

A tabela abaixo resume os parâmetros de campo external_model. Confira POST /api/2.0/serving-endpoints para obter parâmetros de configuração do endpoint.

Parâmetro	Descrições
name	O nome do modelo a ser usado. Por exemplo, gpt-3.5-turbo para o modelo de GPT-3.5-Turbo OpenAI. Isso é passado como parte do corpo da solicitação com a chave correspondente: "model".
provider	Especifica o nome do provedor para esse modelo. Esse valor de cadeia de caracteres precisa corresponder a um provedor de modelo externo suportado. Por exemplo, openai para modelos do GPT-3.5 OpenAI.
task	A tarefa corresponde ao tipo de interação do modelo de linguagem que você deseja. As tarefas com suporte são "llm/v1/completions", "llm/v1/chat", "llm/v1/embeddings".
<provider>_config	Contém todos os detalhes de configuração adicionais necessários para o modelo. Isso inclui a especificação da URL de base da API e da chave da API. Consulte Configurar o provedor para um ponto de extremidade. Se você estiver usando o custom provedor, especifique esse parâmetro como custom_provider_config.

A seguir, um exemplo de criação de um ponto de extremidade de modelo externo usando a API de create_endpoint(). Neste exemplo, uma solicitação enviada ao endpoint de conclusão é direcionada para o modelo claude-2 fornecido por 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}}"
                    }
                }
            }
        ]
    }
)

Configurar o provedor para um endpoint

Quando você cria um ponto de extremidade, deve fornecer as configurações necessárias para o provedor de modelo especificado. As seções a seguir resumem os parâmetros de configuração de ponto de extremidade disponíveis para cada provedor de modelo.

Observação

O Databricks criptografa e armazena com segurança as credenciais fornecidas para cada provedor de modelos. Essas credenciais são excluídas automaticamente quando os seus endpoints associados são excluídos.

OpenAI

Parâmetro de configuração	Descrição	Obrigatório	Padrão
openai_api_key	A referência de chave secreta do Azure Databricks para uma chave de API da OpenAI usando o serviço OpenAI. Se você preferir colar sua chave de API diretamente, consulte openai_api_key_plaintext.	Você deve fornecer uma chave de API usando um dos seguintes campos: openai_api_key ou openai_api_key_plaintext.
openai_api_key_plaintext	A chave de API da OpenAI usando o serviço OpenAI fornecido como uma cadeia de caracteres de texto não criptografado. Se você preferir fazer referência à sua chave usando os Segredos do Azure Databricks, consulte openai_api_key.	Você deve fornecer uma chave de API usando um dos seguintes campos: openai_api_key ou openai_api_key_plaintext deve ser fornecido.
openai_api_type	Um campo opcional para especificar o tipo de API do OpenAI a ser usada.	Não	openai
openai_api_base	A URL de base da API do OpenAI.	Não	https://api.openai.com/v1
openai_api_version	Um campo opcional para especificar a versão da API do OpenAI.	Não
openai_organization	Um campo opcional para especificar a organização no OpenAI.	Não

Coesão

Parâmetro de configuração	Descrição	Obrigatório	Padrão
cohere_api_key	A referência de chave secreta do Azure Databricks para uma chave de API da Cohere. Se você preferir colar sua chave de API diretamente, consulte cohere_api_key_plaintext.	Você deve fornecer uma chave de API usando um dos seguintes campos: cohere_api_key ou cohere_api_key_plaintext.
cohere_api_key_plaintext	A chave de API do Cohere fornecida como uma cadeia de caracteres de texto sem formatação. Se você preferir fazer referência à sua chave usando os Segredos do Azure Databricks, consulte cohere_api_key.	Você deve fornecer uma chave de API usando um dos seguintes campos: cohere_api_key ou cohere_api_key_plaintext.
cohere_api_base	A URL base do serviço Cohere.	Não

Antrópico

Parâmetro de configuração	Descrição	Obrigatório	Padrão
anthropic_api_key	A referência de chave secreta do Azure Databricks para uma chave de API da Anthropic. Se você preferir colar sua chave de API diretamente, consulte anthropic_api_key_plaintext.	Você deve fornecer uma chave de API usando um dos seguintes campos: anthropic_api_key ou anthropic_api_key_plaintext.
anthropic_api_key_plaintext	A chave de API da Anthropic fornecida como uma cadeia de caracteres de texto não criptografado. Se você preferir fazer referência à sua chave usando os Segredos do Azure Databricks, consulte anthropic_api_key.	Você deve fornecer uma chave de API usando um dos seguintes campos: anthropic_api_key ou anthropic_api_key_plaintext.

OpenAI do Azure

O OpenAI do Azure tem recursos distintos em comparação com o serviço OpenAI direto. Para obter uma visão geral, consulte a documentação de comparação.

Parâmetro de configuração	Descrição	Obrigatório	Padrão
openai_api_key	A referência de chave secreta do Azure Databricks para uma chave de API da OpenAI usando o serviço Azure. Se você preferir colar sua chave de API diretamente, consulte openai_api_key_plaintext.	Você deve fornecer uma chave de API usando um dos seguintes campos: openai_api_key ou openai_api_key_plaintext.
openai_api_key_plaintext	A chave de API da OpenAI usando o serviço do Azure fornecido como uma cadeia de caracteres de texto não criptografado. Se você preferir fazer referência à sua chave usando os Segredos do Azure Databricks, consulte openai_api_key.	Você deve fornecer uma chave de API usando um dos seguintes campos: openai_api_key ou openai_api_key_plaintext.
openai_api_type	Para validação do token de acesso, use azure.	Sim
openai_api_base	A URL base do serviço de API do OpenAI do Azure fornecido pelo Azure.	Sim
openai_api_version	A versão do Serviço OpenAI do Azure a ser utilizada, especificada por uma data.	Sim
openai_deployment_name	O nome do recurso de implantação do Serviço OpenAI do Azure.	Sim
openai_organization	Um campo opcional para especificar a organização no OpenAI.	Não

Se você estiver usando a OpenAI do Azure com o Microsoft Entra ID, use os seguintes parâmetros na configuração do ponto de extremidade. O Databricks define https://cognitiveservices.azure.com/ como o escopo padrão para o token de identidade do Microsoft Entra.

Parâmetro de configuração	Descrição	Obrigatório	Padrão
microsoft_entra_tenant_id	A ID do locatário para autenticação do Microsoft Entra ID.	Sim
microsoft_entra_client_id	A ID do cliente para a autenticação do Microsoft Entra ID.	Sim
microsoft_entra_client_secret	A referência de chave secreta do Azure Databricks para um segredo do cliente usado para autenticação do Microsoft Entra ID. Se você preferir colar o segredo do cliente diretamente, consulte microsoft_entra_client_secret_plaintext.	Você deve fornecer uma chave de API usando um dos seguintes campos: microsoft_entra_client_secret ou microsoft_entra_client_secret_plaintext.
microsoft_entra_client_secret_plaintext	O segredo do cliente usado para autenticação do Microsoft Entra ID fornecido como uma cadeia de caracteres de texto não criptografado. Se você preferir fazer referência à sua chave usando os Segredos do Azure Databricks, consulte microsoft_entra_client_secret.	Você deve fornecer uma chave de API usando um dos seguintes campos: microsoft_entra_client_secret ou microsoft_entra_client_secret_plaintext.
openai_api_type	Use azuread para autenticação usando o Microsoft Entra ID.	Sim
openai_api_base	A URL base do serviço de API do OpenAI do Azure fornecido pelo Azure.	Sim
openai_api_version	A versão do Serviço OpenAI do Azure a ser utilizada, especificada por uma data.	Sim
openai_deployment_name	O nome do recurso de implantação do Serviço OpenAI do Azure.	Sim
openai_organization	Um campo opcional para especificar a organização no OpenAI.	Não

O exemplo a seguir demonstra como criar um endpoint com o 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"
                }
            }
        }]
    }
)

IA do Vértice do Google Cloud

Parâmetro de configuração	Descrição	Obrigatório	Padrão
private_key	A referência de chave secreta do Azure Databricks para uma chave privada da conta de serviço que tem acesso ao Serviço de IA do Google Cloud Vertex. Consulte as Melhores práticas para gerenciar chaves de conta de serviço. Se você preferir colar sua chave de API diretamente, consulte private_key_plaintext.	Você deve fornecer uma chave de API usando um dos seguintes campos: private_key ou private_key_plaintext.
private_key_plaintext	Essa é a chave privada para a conta de serviço que tem acesso ao Serviço Google Cloud Vertex AI. Consulte as Melhores práticas para gerenciar chaves de conta de serviço. Se você preferir fazer referência à sua chave usando os Segredos do Azure Databricks, consulte private_key.	Você deve fornecer uma chave de API usando um dos seguintes campos: private_key ou private_key_plaintext.
region	Essa é a região do Serviço do Google Cloud Vertex AI. Confira as regiões com suporte para obter mais detalhes. Alguns modelos só estão disponíveis em regiões específicas.	Sim
project_id	Essa é a ID do projeto do Google Cloud à qual a conta de serviço está associada.	Sim

Amazon Bedrock

Para usar o Amazon Bedrock como provedor de modelo externo, os clientes precisam garantir que o Bedrock esteja habilitado na região especificada da AWS e que o par de chaves da AWS especificado tenha as permissões apropriadas para interagir com os serviços Bedrock. Para obter mais informações, consulte Gerenciamento de Identidades e Acesso do AWS.

Parâmetro de configuração	Descrição	Obrigatório	Padrão
aws_region	A região do AWS a ser usada. O Bedrock deve estar habilitado lá.	Sim
aws_access_key_id	A referência de chave secreta do Azure Databricks para uma ID de chave de acesso do AWS com permissões para interagir com os serviços do Bedrock. Se você preferir colar sua chave de API diretamente, consulte aws_access_key_id_plaintext.	Você deve fornecer uma chave de API usando um dos seguintes campos: aws_access_key_id ou aws_access_key_id_plaintext.
aws_access_key_id_plaintext	Uma ID de chave de acesso da AWS com permissões para interagir com os serviços Bedrock fornecidos como uma cadeia de caracteres de texto sem formatação. Se você preferir fazer referência à sua chave usando os Segredos do Azure Databricks, consulte aws_access_key_id.	Você deve fornecer uma chave de API usando um dos seguintes campos: aws_access_key_id ou aws_access_key_id_plaintext.
aws_secret_access_key	A referência de chave secreta do Azure Databricks para uma chave de acesso secreta do AWS emparelhada com a ID da chave de acesso, com permissões para interagir com os serviços do Bedrock. Se você preferir colar sua chave de API diretamente, consulte aws_secret_access_key_plaintext.	Você deve fornecer uma chave de API usando um dos seguintes campos: aws_secret_access_key ou aws_secret_access_key_plaintext.
aws_secret_access_key_plaintext	Uma chave de acesso secreta do AWS emparelhada com a ID da chave de acesso, com permissões para interagir com os serviços do Bedrock fornecidos como uma cadeia de caracteres de texto não criptografado. Se você preferir fazer referência à sua chave usando os Segredos do Azure Databricks, consulte aws_secret_access_key.	Você deve fornecer uma chave de API usando um dos seguintes campos: aws_secret_access_key ou aws_secret_access_key_plaintext.
bedrock_provider	O provedor subjacente no Amazon Bedrock. Os valores com suporte (sem distinção entre maiúsculas e minúsculas) incluem: Anthropic, Cohere, AI21Labs, Amazon	Sim

O exemplo a seguir demonstra como criar um endpoint com Amazon Bedrock usando chaves de acesso.

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",
                    },
                }
            }
        ]
    },
)

Se houver problemas de permissão da AWS, a Databricks recomenda que você verifique as credenciais diretamente com o API Amazon Bedrock.

Laboratórios AI21

Parâmetro de configuração	Descrição	Obrigatório	Padrão
ai21labs_api_key	A referência de chave secreta do Azure Databricks para uma chave de API da AI21 Labs. Se você preferir colar sua chave de API diretamente, consulte ai21labs_api_key_plaintext.	Você deve fornecer uma chave de API usando um dos seguintes campos: ai21labs_api_key ou ai21labs_api_key_plaintext.
ai21labs_api_key_plaintext	Uma chave de API do AI21 Labs fornecida como uma cadeia de caracteres de texto sem formatação. Se você preferir fazer referência à sua chave usando os Segredos do Azure Databricks, consulte ai21labs_api_key.	Você deve fornecer uma chave de API usando um dos seguintes campos: ai21labs_api_key ou ai21labs_api_key_plaintext.

Provedor personalizado

Parâmetro de configuração	Descrição	Obrigatório	Padrão
custom_provider_url	A URL onde o modelo do provedor personalizado está localizado. A URL deve apontar para um ponto de extremidade de API específico; por exemplo, https://api.provider.com/chat/completions.	Sim
bearer_token_auth	Se o provedor personalizado utilizar a autenticação de token de portador, especifique os campos necessários.	Você deve fornecer um método de autenticação usando um dos seguintes campos: bearer_token_auth ou api_key_auth.
token	A referência de chave secreta do Azure Databricks para o token da autenticação do portador. Esse parâmetro deve ser aninhado em bearer_token_auth. Se você preferir colar sua chave de API diretamente, consulte token_plaintext.	Se estiver usando a autenticação do portador, você deverá fornecer uma chave de API usando um dos seguintes campos: token ou token_plaintext.
token_plaintext	O token para autenticação de portador fornecido como uma cadeia de caracteres de texto sem formatação. Esse parâmetro deve ser aninhado em bearer_token_auth. Se você preferir referenciar sua chave usando segredos do Azure Databricks, consulte token.	Se estiver usando a autenticação do portador, você deverá fornecer uma chave de API usando um dos seguintes campos: token ou token_plaintext.
api_key_auth	Se o provedor personalizado utilizar a autenticação de chave de API, especifique os campos necessários.	Você deve fornecer um método de autenticação usando um dos seguintes campos: bearer_token_auth ou api_key_auth.
key	A chave para autenticação de chave de API. Esse parâmetro deve ser aninhado em api_key_auth	Sim, ao usar a autenticação de chave de API.
value	A referência de chave secreta do Azure Databricks para o token da autenticação da chave de API. Se você preferir colar sua chave de API diretamente, consulte value_plaintext.	Se estiver usando a autenticação de chave de API, você deverá fornecer uma chave de API usando um dos seguintes campos: value ou value_plaintext.
value_plaintext	O valor da chave de API para autenticação fornecido como uma cadeia de caracteres de texto simples. Se você preferir referenciar sua chave usando segredos do Azure Databricks, consulte value.	Se estiver usando a autenticação de chave de API, você deverá fornecer uma chave de API usando um dos seguintes campos: value ou value_plaintext.

O exemplo a seguir demonstra como criar um endpoint com um provedor personalizado usando autenticação Bearer:

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}}"
                        }
                    }
                }
            }
        ]
    },
)

O exemplo a seguir demonstra como criar um ponto de extremidade com um provedor personalizado usando a autenticação de chave de 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}}"
                        }
                    }
                }
            }
        ]
    },
)

Configurar o AI Gateway em um endpoint

Você também pode configurar seu endpoint para habilitar os recursos do Mosaic AI Gateway, como limitação de taxa, rastreamento de uso e proteções.

Consulte Configurar o Gateway de IA nos pontos de extremidade do serviço de modelo.

Consultar um ponto de extremidade de modelo externo

Após criar um endpoint de modelo externo, ele está pronto para receber o tráfego dos usuários.

Você pode enviar solicitações de pontuação para o endpoint usando o cliente OpenAI, a API REST ou o SDK de Implementações do MLflow.

• Confira os parâmetros de consulta padrão para uma solicitação de pontuação em POST /serving-endpoints/{name}/invocations.
• Usar modelos de base

O exemplo a seguir consulta o modelo de conclusões claude-2 hospedado pela Anthropic usando o cliente OpenAI. Para usar o cliente OpenAI, preencha o campo model com o nome do endpoint de atendimento do modelo que hospeda o modelo que você deseja consultar.

Esse exemplo usa um endpoint previamente criado, anthropic-completions-endpoint, configurado para acessar modelos externos do provedor de modelos Anthropic. Veja como criar pontos de extremidade de modelo externo.

Veja Modelos suportados para modelos adicionais que você pode consultar e seus fornecedores.

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)

Formato de resposta de saída esperado:

{
"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
  }
}

Parâmetros de consulta adicionais

Você pode passar quaisquer parâmetros adicionais suportados pelo fornecedor do endpoint como parte da sua consulta.

Por exemplo:

• logit_bias (com suporte para OpenAI, Cohere).
• top_k (com suporte para Anthropic, Cohere).
• frequency_penalty (com suporte para OpenAI, Cohere).
• presence_penalty (com suporte para OpenAI, Cohere).
• stream (apoiado por OpenAI, Anthropic, Cohere, Amazon Bedrock for Anthropic). Isso só está disponível para solicitações de chat e completamentos.

• tools (com suporte da OpenAI, Antropic, Amazon Bedrock for Anthropic). Isso só está disponível para solicitações de chat e completamentos. Esse parâmetro permite a integração de funcionalidades externas, incluindo o Uso de Computador (beta) para Antropic e Amazon Bedrock for Anthropic. Confira Chamada de função no Azure Databricks.

Suporte a configurações de conectividade de rede para modelos externos

O suporte para NCCs (configurações de conectividade de rede) para modelos externos, incluindo o link privado do Azure, está na Versão Prévia Pública. Para participar da versão prévia, entre em contato com sua equipe de contas do Databricks.

Limitações

Dependendo do modelo externo escolhido, sua configuração pode fazer com que seus dados sejam processados fora da região de dados em que foram originados. Consulte Limites e regiões do serviço de modelo.

Recursos adicionais

• Tutorial: Criar endpoints de modelos externos para consultar modelos do OpenAI.
• Use modelos de base.