Tutorial: Criar pontos de extremidade de modelo externo para fazer consulta aos modelos do OpenAI

Esta página fornece instruções passo a passo para configurar e consultar um endpoint de modelo externo que disponibiliza modelos da OpenAI para completions, chat e embeddings. Você cria o endpoint com o MLflow Deployments SDK e faz consultas a ele com o cliente OpenAI. Para obter mais informações, consulte modelos externos.

Depois de criar um endpoint, a Databricks recomenda configurar o Unity AI Gateway nesse endpoint para adicionar recursos de governança, como rastreamento de uso, registro em log de payloads, proteções e limites de taxa. Todos os modelos externos servidos por meio do Model Serving são consultados usando a API compatível com OpenAI, para que você possa usar um único cliente entre provedores. Consulte o Unity AI Gateway.

Se preferir usar a interface de usuário do Serviço para executar esta tarefa, consulte Criar um endpoint de serviço de modelo externo.

Requisitos

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

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

Você pode fornecer suas chaves de API como cadeias de caracteres de texto simples na Etapa 3 ou usando Azure Databricks Secrets.

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

A seguir, cria o escopo de segredo 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 do MLflow com suporte a modelos externos:

%pip install mlflow[genai]>=2.9.0

Etapa 2: Criar e gerenciar um endpoint de modelo externo

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

O trecho de código a seguir cria um endpoint de completude para o OpenAI gpt-3.5-turbo-instruct, conforme especificado na seção served_entities da configuração. Para o ponto de extremidade, certifique-se de preencher o name e o openai_api_key com seus valores únicos 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 snippet de código a seguir mostra como você pode fornecer sua chave de API OpenAI como uma cadeia de caracteres de texto simples para uma maneira alternativa de criar o mesmo ponto de extremidade de conclusão 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 usando o OpenAI do Azure, também é possível especificar o nome da implantação do OpenAI do Azure, 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 taxa de requisições, rastreamento de uso, registro em log de payloads ou proteções no endpoint, use o Gateway de IA da Unity. A configuração de limites de taxa pelo Unity AI Gateway oferece suporte a limites por consulta (QPM) e baseados em tokens (TPM) e permite definir limites por usuário, por grupo e para todo o endpoint.

Consulte Configurar o Gateway de IA do Unity em endpoints de disponibilização de modelos para ver um exemplo programático que atualiza um endpoint para adicionar limites de taxa e outros recursos do Gateway de IA do Unity.

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

A Databricks recomenda consultar endpoints externos de modelos usando o cliente OpenAI. O Serviço de Modelo expõe uma API unificada compatível com OpenAI entre provedores, portanto, o mesmo código do cliente funciona se o modelo subjacente é do OpenAI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI ou um provedor personalizado.

Instale o cliente OpenAI em sua computação:

%pip install openai

O exemplo a seguir envia uma solicitação para a API de conclusões de chat a um endpoint que disponibiliza um modelo de chat da OpenAI. Substitua o valor base_url pela URL do seu workspace do Azure Databricks e forneça um token de acesso pessoal do Azure Databricks para api_key. Defina o model parâmetro como o nome do ponto de extremidade de serviç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 uma solicitação de conclusões para um endpoint configurado para a tarefa llm/v1/completions, use 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 uma solicitação 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 você executar o cliente OpenAI em um notebook do Azure Databricks, poderá usar o auxiliar databricks-openai, que configura automaticamente a autenticação e a URL base do espaço de trabalho. Consulte Usar modelos de base para obter detalhes.

Etapa 4: compare modelos de um fornecedor diferente

O serviço de modelos dá suporte para muitos provedores de modelos externos, incluindo Open IA, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI, entre outros. É possível comparar LLMs entre provedores, ajudando você 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 o serviço Anthropic claude-2 e compara sua resposta com a de uma pergunta respondida pelo OpenAI gpt-3.5-turbo-instruct. Ambas as respostas têm o mesmo formato padrão, o que facilita a comparação.

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

Compare as respostas de cada ponto de extremidade

Como todos os pontos de extremidade de modelo externos expõem uma API compatível com OpenAI, você pode consultar ambos os pontos de extremidade com o mesmo cliente OpenAI alternando o model parâmetro para o nome do ponto de extremidade 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 no serviço de modelos
• Gateway de IA do Unity
• Configurar o Gateway de IA do Unity em endpoints de fornecimento de modelo
• Usar modelos de base