Consultar modelos básicos por tipo
Beta
Este recurso está em Beta. Os administradores da account podem controlar o acesso a este recurso na página Pré-visualizações do console da account. Consulte Gerenciar pré-visualizações do Databricks.
Neste artigo, você aprenderá a escrever solicitações de query para modelos básicos hospedados no Databricks e disponibilizados por serviços de modelo no Unity AI Gateway, organizados por tipo de modelo: chat, visão, áudio e vídeo e raciocínio.
Requisitos
- Consulte Requisitos.
- Instale o pacote apropriado em seu cluster com base na opção de cliente de consulta que você escolher.
Os exemplos a seguir são baseados em Unity AI Gateway e serviços de modelo. Se você usa endpoints de servindo modelo em vez de serviços de modelo, substitua o nome do serviço de modelo pelo nome de um endpoint. Veja Descobrir modelos base para uma lista de modelos base disponíveis e seus nomes de serviço de modelo e endpoint.
Chat
Modelos de base otimizados para bate-papo e tarefas de uso geral.
Os exemplos nesta seção mostram como consultar um serviço de modelo usando as diferentes opções de cliente.
Para um exemplo de inferência em lotes, consulte Enriquecer dados usando AI Functions.
- OpenAI Chat Completions
- OpenAI Responses
- REST API
- Databricks Python SDK
- LangChain
Para usar o cliente OpenAI, especifique o nome do serviço de modelo como a entrada model.
from databricks_openai import DatabricksOpenAI
client = DatabricksOpenAI()
response = client.chat.completions.create(
model="system.ai.claude-sonnet-4-5",
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is a mixture of experts model?",
}
],
max_tokens=256
)
Para consultar modelos de base fora do workspace, é preciso usar o cliente OpenAI diretamente. Você também precisa da sua instância de workspace do Databricks para conectar o cliente OpenAI ao Databricks. O exemplo a seguir pressupõe que você tenha um token de API do Databricks e openai instalado no seu compute.
import os
import openai
from openai import OpenAI
client = OpenAI(
api_key=os.environ.get('DATABRICKS_TOKEN'),
base_url="https://<workspace-url>/ai-gateway/mlflow/v1"
)
response = client.chat.completions.create(
model="system.ai.claude-sonnet-4-5",
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is a mixture of experts model?",
}
],
max_tokens=256
)
Como exemplo, a seguir está o formato de solicitação esperado para um modelo de chat ao usar a API REST.
{
"messages": [
{
"role": "user",
"content": "What is a mixture of experts model?"
}
],
"max_tokens": 100,
"temperature": 0.1
}
A seguir, um formato de resposta esperado para uma solicitação feita usando a API REST:
{
"model": "databricks-claude-sonnet-4-5",
"choices": [
{
"message": {},
"index": 0,
"finish_reason": null
}
],
"usage": {
"prompt_tokens": 7,
"completion_tokens": 74,
"total_tokens": 81
},
"object": "chat.completion",
"id": null,
"created": 1698824353
}
A API Responses é compatível apenas com modelos OpenAI.
Para usar a API OpenAI Responses, especifique o nome do serviço de modelo como a entrada model.
from databricks_openai import DatabricksOpenAI
client = DatabricksOpenAI()
response = client.responses.create(
model="system.ai.gpt-5",
input=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is a mixture of experts model?",
}
],
max_output_tokens=256
)
Para consultar modelos de base fora do workspace, é preciso usar o cliente OpenAI diretamente. Você também precisa da sua instância de workspace do Databricks para conectar o cliente OpenAI ao Databricks. O exemplo a seguir pressupõe que você tenha um token de API do Databricks e openai instalado no seu compute.
import os
import openai
from openai import OpenAI
client = OpenAI(
api_key=os.environ.get('DATABRICKS_TOKEN'),
base_url="https://<workspace-url>/ai-gateway/mlflow/v1"
)
response = client.responses.create(
model="system.ai.gpt-5",
input=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is a mixture of experts model?",
}
],
max_output_tokens=256
)
Como exemplo, o seguinte é o formato de solicitação esperado ao usar a API de Respostas do OpenAI. O caminho do URL para esta API é /serving-endpoints/responses.
{
"model": "databricks-gpt-5",
"input": [
{
"role": "user",
"content": "What is a mixture of experts model?"
}
],
"max_output_tokens": 100,
"temperature": 0.1
}
O seguinte é um formato de resposta esperado para uma solicitação feita usando a API de Respostas:
{
"id": "resp_abc123",
"object": "response",
"created_at": 1698824353,
"model": "databricks-gpt-5",
"output": [
{
"type": "message",
"role": "assistant",
"content": []
}
],
"usage": {
"input_tokens": 7,
"output_tokens": 74,
"total_tokens": 81
}
}
curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d '{
"model": "system.ai.claude-sonnet-4-5",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": " What is a mixture of experts model?"
}
]
}' \
https://<workspace-url>/ai-gateway/mlflow/v1/chat/completions
Como exemplo, a seguir está o formato de solicitação esperado para um modelo de chat ao usar a API REST.
{
"messages": [
{
"role": "user",
"content": "What is a mixture of experts model?"
}
],
"max_tokens": 100,
"temperature": 0.1
}
A seguir, um formato de resposta esperado para uma solicitação feita usando a API REST:
{
"model": "databricks-claude-sonnet-4-5",
"choices": [
{
"message": {},
"index": 0,
"finish_reason": null
}
],
"usage": {
"prompt_tokens": 7,
"completion_tokens": 74,
"total_tokens": 81
},
"object": "chat.completion",
"id": null,
"created": 1698824353
}
Este código deve ser colocado em execução em um Notebook no seu workspace. Consulte Usar o SDK do Databricks para Python a partir de um Notebook do Databricks.
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole
w = WorkspaceClient()
response = w.serving_endpoints.query(
name="system.ai.claude-sonnet-4-5",
messages=[
ChatMessage(
role=ChatMessageRole.SYSTEM, content="You are a helpful assistant."
),
ChatMessage(
role=ChatMessageRole.USER, content="What is a mixture of experts model?"
),
],
max_tokens=128,
)
print(f"RESPONSE:\n{response.choices[0].message.content}")
Como exemplo, a seguir está o formato de solicitação esperado para um modelo de chat ao usar a API REST.
{
"messages": [
{
"role": "user",
"content": "What is a mixture of experts model?"
}
],
"max_tokens": 100,
"temperature": 0.1
}
A seguir, um formato de resposta esperado para uma solicitação feita usando a API REST:
{
"model": "databricks-claude-sonnet-4-5",
"choices": [
{
"message": {},
"index": 0,
"finish_reason": null
}
],
"usage": {
"prompt_tokens": 7,
"completion_tokens": 74,
"total_tokens": 81
},
"object": "chat.completion",
"id": null,
"created": 1698824353
}
Para consultar um serviço de modelo usando a LangChain, você pode usar a classe ChatModel ChatDatabricks e especificar model.
%pip install databricks-langchain
from langchain_core.messages import HumanMessage, SystemMessage
from databricks_langchain import ChatDatabricks
messages = [
SystemMessage(content="You're a helpful assistant"),
HumanMessage(content="What is a mixture of experts model?"),
]
llm = ChatDatabricks(model="system.ai.claude-sonnet-4-5")
llm.invoke(messages)
Como exemplo, a seguir está o formato de solicitação esperado para um modelo de chat ao usar a API REST.
{
"messages": [
{
"role": "user",
"content": "What is a mixture of experts model?"
}
],
"max_tokens": 100,
"temperature": 0.1
}
A seguir, um formato de resposta esperado para uma solicitação feita usando a API REST:
{
"model": "databricks-claude-sonnet-4-5",
"choices": [
{
"message": {},
"index": 0,
"finish_reason": null
}
],
"usage": {
"prompt_tokens": 7,
"completion_tokens": 74,
"total_tokens": 81
},
"object": "chat.completion",
"id": null,
"created": 1698824353
}
Visão
Consulte modelos de visão hospedados pela Databricks por meio de serviços de modelo no Unity AI Gateway para entender e analisar imagens com uma API unificada.
- OpenAI client
Para usar o cliente OpenAI, especifique o nome do serviço de modelo como a entrada model.
from openai import OpenAI
import base64
import requests
# Get the workspace API URL and token from the notebook context
API_ROOT = dbutils.notebook.entry_point.getDbutils().notebook().getContext().apiUrl().get()
API_TOKEN = dbutils.notebook.entry_point.getDbutils().notebook().getContext().apiToken().get()
client = OpenAI(
api_key=API_TOKEN,
base_url=f"{API_ROOT}/ai-gateway/mlflow/v1",
)
# Download and encode image
image_url = "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
resp = requests.get(image_url)
resp.raise_for_status()
image_data = base64.b64encode(resp.content).decode("utf-8")
# OpenAI request
completion = client.chat.completions.create(
model="system.ai.claude-sonnet-4-5",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "what's in this image?"},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
},
],
}
],
)
print(completion.choices[0].message.content)
A API de Conclusões de Chat oferece suporte a múltiplas entradas de imagem, permitindo que o modelo analise cada imagem e sintetize informações de todas as entradas para gerar uma resposta ao prompt.
from openai import OpenAI
import base64
import requests
# Get the workspace API URL and token from the notebook context
API_ROOT = dbutils.notebook.entry_point.getDbutils().notebook().getContext().apiUrl().get()
API_TOKEN = dbutils.notebook.entry_point.getDbutils().notebook().getContext().apiToken().get()
client = OpenAI(
api_key=API_TOKEN,
base_url=f"{API_ROOT}/ai-gateway/mlflow/v1",
)
# Download and encode multiple images
image1_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
resp1 = requests.get(image1_url)
resp1.raise_for_status()
image1_data = base64.b64encode(resp1.content).decode("utf-8")
image2_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
resp2 = requests.get(image2_url)
resp2.raise_for_status()
image2_data = base64.b64encode(resp2.content).decode("utf-8")
# OpenAI request
completion = client.chat.completions.create(
model="system.ai.claude-sonnet-4-5",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "What are in these images? Is there any difference between them?"},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{image1_data}"},
},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{image2_data}"},
},
],
}
],
)
print(completion.choices[0].message.content)
Requisitos de imagem de entrada
Modelo | Formatos compatíveis | Várias imagens por solicitação | Limitações de tamanho de imagem | Recomendações de Redimensionamento de Imagem | Considerações sobre a qualidade da imagem |
|---|---|---|---|---|---|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 500 entradas de imagem individuais por solicitação | Limite de tamanho de arquivo: até 10 MB de tamanho total da carga útil por solicitação | N/A |
|
|
| Até 50 imagens para solicitações de API. Todas as imagens fornecidas são processadas em uma solicitação. | Limite de tamanho de arquivo: 7 MB cada imagem. | N/A | N/A |
|
| Até 50 imagens para solicitações de API. Todas as imagens fornecidas são processadas em uma solicitação. | Limite de tamanho de arquivo: 7 MB cada imagem. | N/A | N/A |
|
| Até 50 imagens para solicitações de API. Todas as imagens fornecidas são processadas em uma solicitação. | Limite de tamanho de arquivo: 7 MB cada imagem. | N/A | N/A |
|
| Até 50 imagens para solicitações de API. Todas as imagens fornecidas são processadas em uma solicitação. | Limite de tamanho de arquivo: 7 MB cada imagem. | N/A | N/A |
|
| Até 50 imagens para solicitações de API. Todas as imagens fornecidas são processadas em uma solicitação. | Limite de tamanho de arquivo: 7 MB cada imagem. | N/A | N/A |
|
| Até 50 imagens para solicitações de API. Todas as imagens fornecidas são processadas em uma solicitação. | Limite de tamanho de arquivo: 7 MB cada imagem. | N/A | N/A |
|
| Até 50 imagens para solicitações de API. Todas as imagens fornecidas são processadas em uma solicitação. | Limite de tamanho de arquivo: 7 MB cada imagem. | N/A | N/A |
|
| Até 5 imagens para solicitações de API
| Limite de tamanho do arquivo: 10 MB no total em todas as imagens por solicitação de API | N/A | N/A |
|
| Até 5 imagens para solicitações de API
| Limite de tamanho do arquivo: 10 MB no total em todas as imagens por solicitação de API | N/A | N/A |
|
|
|
| Para desempenho ideal, redimensione as imagens antes de fazer upload, se forem muito grandes.
|
|
Conversão de imagem para tokens
Cada imagem em uma solicitação a um modelo de fundação contribui para o uso de tokens. Consulte a calculadora de preços para estimar os preços de imagem com base no uso de tokens e no modelo que você está utilizando.
Limitações da compreensão de imagem
A seguir, as limitações de compreensão de imagem para os modelos de fundação suportados hospedados no Databricks:
Modelo | Limitações |
|---|---|
Os seguintes modelos Claude são compatíveis:
| A seguir, estão os limites para modelos Claude no Databricks:
|
Áudio e vídeo
Envie entradas de áudio e vídeo para modelos básicos do Gemini fornecidos pelo Unity AI Gateway no Databricks. É possível fornecer mídia como uma URL ou como dados em linha codificados em base64 usando a Chat Completions API ou a Google Gemini API.
É possível fornecer entradas de áudio e vídeo usando dois métodos:
- URL : Passe uma URL publicamente acessível para o arquivo de mídia. Para vídeo, URLs do YouTube também são compatíveis.
- Dados inline Base64 : Codifique o arquivo como uma strings base64 e passe-o como um URI de dados (por exemplo,
data:video/mp4;base64,<encoded_data>).
API de Conclusões de Chat
A API de conclusões de chat permite que você passe entrada de vídeo e áudio. Use os tipos de conteúdo video_url e audio_url no array messages para passar entradas de mídia. Cada item de conteúdo inclui um campo url que aceita um URL da web ou um URI de dados base64.
Os exemplos a seguir mostram entrada de vídeo e áudio usando a API de Conclusões de Chat.
- Python
- REST API
import os
import base64
from openai import OpenAI
DATABRICKS_TOKEN = os.environ.get('DATABRICKS_TOKEN')
DATABRICKS_BASE_URL = os.environ.get('DATABRICKS_BASE_URL')
client = OpenAI(
api_key=DATABRICKS_TOKEN,
base_url=DATABRICKS_BASE_URL
)
# Encode a local video file as base64
with open("video.mp4", "rb") as f:
video_b64 = base64.standard_b64encode(f.read()).decode("utf-8")
response = client.chat.completions.create(
model="system.ai.gemini-3-1-pro",
messages=[{
"role": "user",
"content": [
{"type": "text", "text": "Summarize what happens in these videos."},
{
"type": "video_url",
"video_url": {"url": "https://example.com/sample-video.mp4"}
},
{
"type": "video_url",
"video_url": {"url": f"data:video/mp4;base64,{video_b64}"}
},
]
}],
max_tokens=1024
)
print(response.choices[0].message.content)
import os
import base64
from openai import OpenAI
DATABRICKS_TOKEN = os.environ.get('DATABRICKS_TOKEN')
DATABRICKS_BASE_URL = os.environ.get('DATABRICKS_BASE_URL')
client = OpenAI(
api_key=DATABRICKS_TOKEN,
base_url=DATABRICKS_BASE_URL
)
# Encode a local audio file as base64
with open("audio.mp3", "rb") as f:
audio_b64 = base64.standard_b64encode(f.read()).decode("utf-8")
response = client.chat.completions.create(
model="system.ai.gemini-3-1-pro",
messages=[{
"role": "user",
"content": [
{"type": "text", "text": "Transcribe this audio and summarize the key points."},
{
"type": "audio_url",
"audio_url": {"url": "https://example.com/sample-audio.mp3"}
},
{
"type": "audio_url",
"audio_url": {"url": f"data:audio/mp3;base64,{audio_b64}"}
},
]
}],
max_tokens=1024
)
print(response.choices[0].message.content)
curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d '{
"model": "system.ai.gemini-3-1-pro",
"messages": [{
"role": "user",
"content": [
{"type": "text", "text": "Summarize what happens in these videos."},
{
"type": "video_url",
"video_url": {"url": "https://example.com/sample-video.mp4"}
},
{
"type": "video_url",
"video_url": {"url": "data:video/mp4;base64,<base64_encoded_data>"}
}
]
}],
"max_tokens": 1024
}' \
https://<workspace-url>/ai-gateway/mlflow/v1/chat/completions
curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d '{
"model": "system.ai.gemini-3-1-pro",
"messages": [{
"role": "user",
"content": [
{"type": "text", "text": "Transcribe this audio and summarize the key points."},
{
"type": "audio_url",
"audio_url": {"url": "https://example.com/sample-audio.mp3"}
},
{
"type": "audio_url",
"audio_url": {"url": "data:audio/mp3;base64,<base64_encoded_data>"}
}
]
}],
"max_tokens": 1024
}' \
https://<workspace-url>/ai-gateway/mlflow/v1/chat/completions
API do Google Gemini
Use a API do Google Gemini para passar mídia como inlineData (codificada em base64) ou fileData (referência de URL) dentro do array parts.
Os exemplos a seguir mostram entrada de vídeo e áudio usando a API do Google Gemini.
- Python
- REST API
from google import genai
from google.genai import types
import base64
import os
DATABRICKS_TOKEN = os.environ.get('DATABRICKS_TOKEN')
client = genai.Client(
api_key="databricks",
http_options=types.HttpOptions(
base_url="https://<workspace-url>/ai-gateway/gemini",
headers={
"Authorization": f"Bearer {DATABRICKS_TOKEN}",
},
),
)
# Encode a local video file as base64
with open("video.mp4", "rb") as f:
video_b64 = base64.standard_b64encode(f.read()).decode("utf-8")
response = client.models.generate_content(
model="system.ai.gemini-3-1-pro",
contents=[
types.Content(
role="user",
parts=[
types.Part(text="Summarize what happens in these videos."),
types.Part(
file_data=types.FileData(
mime_type="video/mp4",
file_uri="https://example.com/sample-video.mp4",
)
),
types.Part(
inline_data=types.Blob(
mime_type="video/mp4",
data=video_b64,
)
),
],
),
],
config=types.GenerateContentConfig(
max_output_tokens=1024,
),
)
print(response.text)
from google import genai
from google.genai import types
import base64
import os
DATABRICKS_TOKEN = os.environ.get('DATABRICKS_TOKEN')
client = genai.Client(
api_key="databricks",
http_options=types.HttpOptions(
base_url="https://<workspace-url>/ai-gateway/gemini",
headers={
"Authorization": f"Bearer {DATABRICKS_TOKEN}",
},
),
)
# Encode a local audio file as base64
with open("audio.mp3", "rb") as f:
audio_b64 = base64.standard_b64encode(f.read()).decode("utf-8")
response = client.models.generate_content(
model="system.ai.gemini-3-1-pro",
contents=[
types.Content(
role="user",
parts=[
types.Part(text="Transcribe this audio and summarize the key points."),
types.Part(
file_data=types.FileData(
mime_type="audio/mp3",
file_uri="https://example.com/sample-audio.mp3",
)
),
types.Part(
inline_data=types.Blob(
mime_type="audio/mp3",
data=audio_b64,
)
),
],
),
],
config=types.GenerateContentConfig(
max_output_tokens=1024,
),
)
print(response.text)
curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d '{
"contents": [{
"role": "user",
"parts": [
{"text": "Summarize what happens in these videos."},
{
"fileData": {
"mimeType": "video/mp4",
"fileUri": "https://example.com/sample-video.mp4"
}
},
{
"inlineData": {
"mimeType": "video/mp4",
"data": "<base64_encoded_data>"
}
}
]
}]
}' \
https://<workspace-url>/ai-gateway/gemini/v1beta/models/system.ai.gemini-3-1-pro:generateContent
curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d '{
"contents": [{
"role": "user",
"parts": [
{"text": "Transcribe this audio and summarize the key points."},
{
"fileData": {
"mimeType": "audio/mp3",
"fileUri": "https://example.com/sample-audio.mp3"
}
},
{
"inlineData": {
"mimeType": "audio/mp3",
"data": "<base64_encoded_data>"
}
}
]
}]
}' \
https://<workspace-url>/ai-gateway/gemini/v1beta/models/system.ai.gemini-3-1-pro:generateContent
Limitações
- Várias entradas de áudio ou vídeo podem ser incluídas em uma única solicitação, mas arquivos grandes aumentam a latência e o uso de tokens.
Raciocínio
Modelos básicos otimizados para tarefas de raciocínio. A API de Foundation Model do Databricks fornece uma API unificada para interagir com todos os Foundation Models, incluindo modelos de raciocínio. O raciocínio concede aos modelos básicos recursos aprimorados para abordar tarefas complexas. Alguns modelos também fornecem transparência, revelando seu processo de pensamento passo a passo antes de entregar uma resposta final.
Tipos de modelos de raciocínio
Há dois tipos de modelos: somente raciocínio e híbridos. A tabela a seguir descreve como diferentes modelos usam diferentes abordagens para controlar o raciocínio:
Modelos | Tipo de modelo de raciocínio | Detalhes | Parâmetros |
|---|---|---|---|
Modelos GPT-5 como | Somente raciocínio | Esses modelos sempre usam raciocínio interno em suas respostas. | Use o seguinte parâmetro na sua solicitação:
|
Modelos Claude como | Raciocínio híbrido | Esses modelos oferecem suporte a respostas rápidas e instantâneas e a um raciocínio mais aprofundado quando necessário. | Inclua os seguintes parâmetros para usar o raciocínio híbrido:
|
Modelos Gemini 3, como | Raciocínio híbrido | Esses modelos oferecem suporte a respostas rápidas e instantâneas e a um raciocínio mais aprofundado quando necessário. | Inclua os seguintes parâmetros para usar o raciocínio híbrido:
|
Modelos Gemini 2.5 como | Raciocínio híbrido | Esses modelos oferecem suporte a respostas rápidas e instantâneas e a um raciocínio mais aprofundado quando necessário. | Inclua os seguintes parâmetros para usar o raciocínio híbrido:
|
Modelos GPT OSS como | Somente raciocínio | Esses modelos sempre usam raciocínio interno em suas respostas. | Use o seguinte parâmetro na sua solicitação:
|
Exemplos de consulta
Todos os modelos de raciocínio são acessados através do endpoint de conclusões de bate-papo.
- Claude model example
- GPT-5.1
- GPT OSS model example
- Gemini model example
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ.get('YOUR_DATABRICKS_TOKEN'),
base_url=os.environ.get('YOUR_DATABRICKS_BASE_URL')
)
response = client.chat.completions.create(
model="system.ai.claude-sonnet-4-5",
messages=[{"role": "user", "content": "Why is the sky blue?"}],
max_tokens=20480,
extra_body={
"thinking": {
"type": "enabled",
"budget_tokens": 10240
}
}
)
msg = response.choices[0].message
reasoning = msg.content[0]["summary"][0]["text"]
answer = msg.content[1]["text"]
print("Reasoning:", reasoning)
print("Answer:", answer)
O parâmetro reasoning_effort para GPT-5.1 é definido como none por default, mas pode ser substituído em solicitações. Um maior esforço de raciocínio pode resultar em respostas mais ponderadas e precisas, mas pode aumentar a latência e o uso de tokens.
curl -X POST "https://<workspace-url>/ai-gateway/mlflow/v1/chat/completions" \
-H "Authorization: Bearer $DATABRICKS_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"model": "system.ai.gpt-5-1",
"messages": [
{
"role": "user",
"content": "Why is the sky blue?"
}
],
"max_tokens": 4096,
"reasoning_effort": "none"
}'
O parâmetro reasoning_effort aceita "low", "medium" (default) ou "high" valores. Maior esforço de raciocínio pode resultar em respostas mais ponderadas e precisas, mas pode aumentar a latência e o uso de tokens.
curl -X POST "https://<workspace-url>/ai-gateway/mlflow/v1/chat/completions" \
-H "Authorization: Bearer $DATABRICKS_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"model": "system.ai.gpt-oss-120b",
"messages": [
{
"role": "user",
"content": "Why is the sky blue?"
}
],
"max_tokens": 4096,
"reasoning_effort": "high"
}'
Este exemplo usa system.ai.gemini-3-1-pro. O parâmetro reasoning_effort está definido como "low" por default, mas pode ser substituído em solicitações, conforme visto no exemplo a seguir.
curl -X POST "https://<workspace-url>/ai-gateway/mlflow/v1/chat/completions" \
-H "Authorization: Bearer $DATABRICKS_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"model": "system.ai.gemini-3-1-pro",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Why is the sky blue?"
}
],
"max_tokens": 2000,
"stream": true,
"reasoning_effort": "high"
}'
A resposta da API inclui blocos de conteúdo de raciocínio e texto:
ChatCompletionMessage(
role="assistant",
content=[
{
"type": "reasoning",
"summary": [
{
"type": "summary_text",
"text": ("The question is asking about the scientific explanation for why the sky appears blue... "),
"signature": ("EqoBCkgIARABGAIiQAhCWRmlaLuPiHaF357JzGmloqLqkeBm3cHG9NFTxKMyC/9bBdBInUsE3IZk6RxWge...")
}
]
},
{
"type": "text",
"text": (
"# Why the Sky Is Blue\n\n"
"The sky appears blue because of a phenomenon called Rayleigh scattering. Here's how it works..."
)
}
],
refusal=None,
annotations=None,
audio=None,
function_call=None,
tool_calls=None
)
Gerenciar raciocínio em várias interações
Esta seção é específica para o modelo databricks-claude-sonnet-4-5.
Em conversas multietapas, somente os blocos de raciocínio associados ao último turno do assistente ou sessão de uso de ferramenta são visíveis para o modelo e contados como tokens de entrada.
Se não se desejar passar tokens de raciocínio de volta para o modelo (por exemplo, se não for necessário que ele raciocine sobre os passos anteriores), pode-se omitir o bloco de raciocínio inteiramente. Por exemplo:
response = client.chat.completions.create(
model="system.ai.claude-sonnet-4-5",
messages=[
{"role": "user", "content": "Why is the sky blue?"},
{"role": "assistant", "content": text_content},
{"role": "user", "content": "Can you explain in a way that a 5-year-old child can understand?"}
],
max_tokens=20480,
extra_body={
"thinking": {
"type": "enabled",
"budget_tokens": 10240
}
}
)
answer = response.choices[0].message.content[1]["text"]
print("Answer:", answer)
No entanto, se você precisar que o modelo raciocine sobre seu processo de raciocínio anterior — por exemplo, se você estiver construindo experiências que exponham seu raciocínio intermediário — você deve incluir a mensagem completa e não modificada do assistente, incluindo o bloco de raciocínio da interação anterior. Veja como continuar uma conversa com a mensagem completa do assistente:
assistant_message = response.choices[0].message
response = client.chat.completions.create(
model="system.ai.claude-sonnet-4-5",
messages=[
{"role": "user", "content": "Why is the sky blue?"},
{"role": "assistant", "content": text_content},
{"role": "user", "content": "Can you explain in a way that a 5-year-old child can understand?"},
assistant_message,
{"role": "user", "content": "Can you simplify the previous answer?"}
],
max_tokens=20480,
extra_body={
"thinking": {
"type": "enabled",
"budget_tokens": 10240
}
}
)
answer = response.choices[0].message.content[1]["text"]
print("Answer:", answer)
Como funciona um modelo de raciocínio?
Modelos de raciocínio introduzem tokens de raciocínio especiais além dos tokens de entrada e saída padrão. Esses tokens permitem que o modelo "pense" no prompt, dividindo-o e considerando diferentes maneiras de responder. Após este processo de raciocínio interno, o modelo gera sua resposta final como tokens de saída visíveis. Alguns modelos, como databricks-claude-sonnet-4-5, exibem esses tokens de raciocínio aos usuários, enquanto outros, como a série OpenAI o, os descartam e não os expõem na saída final.
Modelos compatíveis
Consulte Descobrir modelos de base para ver os modelos de base disponíveis e os tipos de interação que cada um suporta, incluindo chat, visão, áudio e vídeo e raciocínio.