Tutorial: Crie endpoint de modelo externo para consultar modelos do OpenAI
Esta página fornece instruções passo a passo para configurar e consultar um endpoint de modelo externo que serve modelos OpenAI para conclusões, chat e embeddings. Você cria o endpoint com o SDK de Implantações MLflow e o consulta com o cliente OpenAI. Para obter mais informações, consulte modelos externos.
Após criar um endpoint, o Databricks recomenda configurar o Unity Gateway nele para adicionar recursos de governança, como acompanhamento de uso, log de carga útil, guardrails e limites de taxa. Todos os modelos externos atendidos 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 Governança de IA com o Unity Gateway.
Diga ao Genie Code (modo Agente) para fazer isso por você:
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 Servindo para realizar esta tarefa, consulte Criar um endpoint de servindo modelo externo.
Requisitos
- Databricks Runtime 13.0 ML ou acima.
- MLflow 2.9 ou acima.
- Chaves de API OpenAI.
- Instale a CLI do Databricks versão 0.205 ou acima.
(Opcional) Passo 0: Armazenar a chave da API OpenAI usando a CLI de Segredos do Databricks
É possível fornecer suas API key como strings simples no o passo 3 ou usando Segredos do Databricks.
Para armazenar a OpenAI API key como um segredo, é possível usar a CLI de Segredos do Databricks (versão 0.205 e acima). Também é possível usar a API REST para segredos.
O seguinte cria o Secret Scope chamado, my_openai_secret_scope, e então 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: Instale o MLflow com suporte a modelos externos
Utilize o seguinte para instalar uma versão do MLflow com suporte para modelos externos:
%pip install mlflow[genai]>=2.9.0
o passo 2: Criar e gerenciar um endpoint de modelo externo
Os exemplos de código nesta seção demonstram o uso do SDK CRUD de Implantações do MLflow em visualização pública.
Para criar um endpoint de modelo externo para um modelo de linguagem grande (LLM), use o método create_endpoint() do SDK de Implantações do MLflow. Você também pode criar endpoints de modelo externo na interface do usuário de disponibilização.
O snippet de código a seguir cria um endpoint de conclusões para OpenAI gpt-3.5-turbo-instruct, conforme especificado na seção served_entities da configuração. Para seu endpoint, certifique-se de preencher name e openai_api_key com 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 trecho de código a seguir mostra como fornecer sua key de API OpenAI como uma string de texto simples para uma forma alternativa de criar o mesmo endpoint de conclusões como 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 você estiver usando o Azure OpenAI, também pode especificar o nome de implantação do Azure OpenAI, a URL do endpoint 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, acompanhamento de uso, log de carga útil ou guardrails no endpoint, use o Unity Gateway. A configuração de limites de taxa por meio do Unity Gateway oferece suporte a limites baseados em query (QPM) e baseados em tokens (TPM) e permite definir limites por usuário, por grupo e para todo o endpoint.
Consulte Configurar governança em Endpoint de servindo modelo (legado) para obter um exemplo programático que atualiza um endpoint para adicionar limites de taxa e outros recursos do Unity Gateway.
O padrão client.update_endpoint() documentado anteriormente com um campo rate_limits de nível superior está obsoleto. Use a configuração do Unity Gateway no endpoint em vez disso.
O passo 3: enviar solicitações para um endpoint de modelo externo
A Databricks recomenda consultar endpoint de modelo externos usando o cliente OpenAI. O Model Serving expõe uma API unificada e compatível com OpenAI em todos os provedores, assim, o mesmo código de cliente funciona, seja o modelo subjacente de OpenAI, Anthropic, Cohere, Amazon Bedrock, Google Cloud Vertex AI ou um provedor personalizado.
Instale o cliente OpenAI em seu compute:
%pip install openai
O seguinte envia uma solicitação de conclusão de chat para um endpoint que serve um modelo de chat OpenAI. Substitua o valor de base_url pelo URL do seu workspace Databricks, e forneça um access token pessoal do Databricks para api_key. Defina o parâmetro model para o nome do seu endpoint de servindo 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 llm/v1/completions tarefa, 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 dentro de um Notebook Databricks, poderá usar o auxiliar databricks-openai, que configura automaticamente a autenticação e o URL base do workspace. Consulte Usar modelos básicos para obter detalhes.
O passo 4: Compare modelos de um provedor diferente
O serviço de modelos suporta muitos provedores de modelo externos, incluindo Open AI, Anthropic, Cohere, Amazon Bedrock, Vertex AI do Google Cloud e outros.
O exemplo a seguir cria um endpoint 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}}"
},
},
}
],
},
)
Compare as respostas de cada endpoint
Como todos os endpoints de modelo externos expõem uma API compatível com OpenAI, você pode consultar ambos os endpoints com o mesmo cliente OpenAI trocando o parâmetro model 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)