Tutorial: Criar endpoints de modelo externos para consultar modelos da OpenAI

Esta página fornece instruções passo a passo para configurar e consultar um endpoint de modelo externo que serve modelos OpenAI para completamentos, chat e embeddings. Cria o endpoint com o MLflow Deployments SDK e consulta-o com o cliente OpenAI. Para mais informações, consulte modelos externos.

Depois de criar um endpoint, a Databricks recomenda configurar o Unity AI Gateway nele para adicionar funcionalidades de governação como rastreamento de uso, registo de payloads, proteções e limites de taxa. Todos os modelos externos servidos através do Model Serving são consultados através da API compatível com OpenAI, pelo que pode usar um único cliente entre fornecedores. Veja a governação da IA com o Unity AI Gateway.

Create a new notebook that uses the MLflow Deployments SDK to create an external model endpoint named openai-completions-endpoint that serves OpenAI's gpt-3.5-turbo-instruct model for completions, reading my OpenAI API key from a Databricks secret scope. Then send a test completion request to the endpoint and display the response.

Se preferir usar a UI de Serviço para realizar esta tarefa, consulte Criar um endpoint de serviço do modelo externo.

Requerimentos

• Databricks Runtime 13.0 ML ou superior.
• MLflow 2.9 ou superior.
• Chaves de API OpenAI.
• Instale o Databricks CLI versão 0.205 ou superior.

(Opcional) Etapa 0: Armazenar a chave da API OpenAI usando a CLI Databricks Secrets

Você pode fornecer suas chaves de API como cadeias de caracteres de texto sem formatação na Etapa 3 ou usando os Segredos do Azure Databricks.

Para armazenar a chave da API OpenAI como um segredo, você pode usar a CLI Databricks Secrets (versão 0.205 e superior). Você também pode usar a API REST para segredos.

O seguinte cria o escopo secreto chamado my_openai_secret_scope e, em seguida, cria o segredo openai_api_key nesse escopo.

databricks secrets create-scope my_openai_secret_scope
databricks secrets put-secret my_openai_secret_scope openai_api_key

Etapa 1: Instalar o MLflow com suporte a modelos externos

Use o seguinte para instalar uma versão MLflow com suporte a modelos externos:

%pip install mlflow[genai]>=2.9.0

Etapa 2: Criar e gerenciar um ponto de extremidade de modelo externo

Para criar um ponto de extremidade de modelo externo para um modelo de linguagem grande (LLM), use o método create_endpoint() do SDK de implementações MLflow. Você também pode criar pontos de extremidade de modelo externos na interface de serviço.

O trecho de código a seguir cria um ponto de extremidade de conclusão para o OpenAI gpt-3.5-turbo-instruct, conforme especificado na served_entities seção da configuração. Para o seu ponto final, assegure-se de preencher o name e openai_api_key com os seus valores exclusivos para cada campo.

import mlflow.deployments

client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
    name="openai-completions-endpoint",
    config={
        "served_entities": [{
            "name": "openai-completions",
            "external_model": {
                "name": "gpt-3.5-turbo-instruct",
                "provider": "openai",
                "task": "llm/v1/completions",
                "openai_config": {
                    "openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}"
                }
            }
        }]
    }
)

O seguinte trecho de código mostra como podes fornecer a tua chave de API OpenAI como uma string de texto simples para uma forma alternativa de criar o mesmo endpoint de preenchimento como acima.

import mlflow.deployments

client = mlflow.deployments.get_deploy_client("databricks")
client.create_endpoint(
    name="openai-completions-endpoint",
    config={
        "served_entities": [{
            "name": "openai-completions",
            "external_model": {
                "name": "gpt-3.5-turbo-instruct",
                "provider": "openai",
                "task": "llm/v1/completions",
                "openai_config": {
                    "openai_api_key_plaintext": "sk-yourApiKey"
                }
            }
        }]
    }
)

Se estiver a usar o Azure OpenAI, também poderá especificar o nome da implementação do Azure OpenAI, a URL do ponto de extremidade e a versão da API na seção openai_config da configuração.

client.create_endpoint(
    name="openai-completions-endpoint",
    config={
        "served_entities": [
          {
            "name": "openai-completions",
            "external_model": {
                "name": "gpt-3.5-turbo-instruct",
                "provider": "openai",
                "task": "llm/v1/completions",
                "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"
                },
            },
          }
        ],
    },
)

Para configurar limites de pedidos, monitorização da utilização, registo de payloads ou proteções no endpoint, use o Unity AI Gateway. Configurar limites de taxa através do Unity AI Gateway suporta tanto limites baseados em consultas (QPM) como baseados em tokens (TPM) e permite-lhe definir limites por utilizador, por grupo e em todo o endpoint.

Consulte Configurar AI Gateway em endpoints de serviço de modelo para um exemplo programático que atualiza um endpoint para adicionar limites de taxa e outras funcionalidades do Unity AI Gateway.

Etapa 3: Enviar solicitações para um ponto de extremidade de modelo externo

A Databricks recomenda consultar endpoints de modelos externos usando o cliente OpenAI. O Model Serving expõe uma API unificada e compatível com OpenAI entre os fornecedores, pelo que o mesmo código cliente funciona, quer o modelo subjacente seja da OpenAI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI ou um fornecedor personalizado.

Instale o cliente OpenAI no seu computador:

%pip install openai

O seguinte envia um pedido de conclusão de chat para um endpoint que serve um modelo de chat OpenAI. Substitua o valor base_url pelo URL do seu espaço de trabalho do Azure Databricks e forneça um token de acesso pessoal do Azure Databricks para api_key. Defina o parâmetro model como o nome do endpoint de disponibilização do modelo.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("DATABRICKS_TOKEN"),
    base_url="https://<workspace-name>.cloud.databricks.com/serving-endpoints"
)

response = client.chat.completions.create(
    model="openai-chat-endpoint",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ],
    max_tokens=128,
    temperature=0.1,
)
print(response.choices[0].message.content)

Para enviar um pedido de completação para um endpoint configurado para a llm/v1/completions tarefa, utilize client.completions.create():

response = client.completions.create(
    model="openai-completions-endpoint",
    prompt="What is the capital of France?",
    max_tokens=10,
    temperature=0.1,
    n=2,
)
print(response)

Para enviar um pedido de embeddings para um endpoint configurado para a tarefa llm/v1/embeddings, use client.embeddings.create():

response = client.embeddings.create(
    model="openai-embeddings-endpoint",
    input="Databricks is a unified analytics platform.",
)
print(response.data[0].embedding)

Se executares o cliente OpenAI a partir de um Azure Databricks notebook, podes usar o helper databricks-openai, que configura automaticamente a autenticação e a URL base do workspace. Consulte Utilizar modelos de fundação para mais detalhes.

Etapa 4: Comparar modelos de um provedor diferente

O serviço de modelos suporta muitos fornecedores de modelos externos, incluindo Open AI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI e muito mais. Você pode comparar LLMs entre provedores, ajudando a otimizar a precisão, a velocidade e o custo de seus aplicativos usando o AI Playground.

O exemplo a seguir cria um ponto de extremidade para Anthropic claude-2 e compara sua resposta a uma pergunta que usa OpenAI gpt-3.5-turbo-instruct. Ambas as respostas têm o mesmo formato padrão, o que as torna fáceis de comparar.

Criar um endpoint para Anthropic Claude-2

import mlflow.deployments

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

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

Comparar as respostas de cada ponto de extremidade

Como todos os endpoints de modelos externos expõem uma API compatível com OpenAI, pode consultar ambos os endpoints com o mesmo cliente OpenAI mudando o model parâmetro para o nome do endpoint correspondente.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("DATABRICKS_TOKEN"),
    base_url="https://<workspace-name>.cloud.databricks.com/serving-endpoints"
)

prompt = "How is Pi calculated? Be very concise."

openai_response = client.completions.create(
    model="openai-completions-endpoint",
    prompt=prompt,
)
anthropic_response = client.completions.create(
    model="anthropic-completions-endpoint",
    prompt=prompt,
)

print("OpenAI:", openai_response.choices[0].text)
print("Anthropic:", anthropic_response.choices[0].text)

Recursos adicionais

• Modelos externos na disponibilização de modelos
• Governação da IA com o Unity AI Gateway
• Configurar o gateway de IA nos endpoints de disponibilização de modelos
• Usar modelos fundamentais