Abfragen eines In Azure Databricks bereitgestellten Agents

Erfahren Sie, wie Sie Anforderungen an Agents senden, die für Databricks-Apps oder Model Serving-Endpunkte bereitgestellt werden. Databricks bietet mehrere Abfragemethoden für unterschiedliche Anwendungsfälle und Integrationsanforderungen.

Wählen Sie den Abfrageansatz aus, der am besten zu Ihrem Anwendungsfall passt:

Databricks empfiehlt den Databricks OpenAI Client für neue Anwendungen. Wählen Sie die REST-API aus, wenn sie in Plattformen integriert wird, die openAI-kompatible Endpunkte erwarten.

Databricks OpenAI Client (empfohlen)

Databricks empfiehlt, den DatabricksOpenAI-Client zum Abfragen eines bereitgestellten Agents zu verwenden. Abhängig von der API Ihres bereitgestellten Agents verwenden Sie entweder den Antwort- oder Chatabschlussclient:

In Apps bereitgestellte Agents

Verwenden Sie das folgende Beispiel für Agents, die auf Databricks-Apps gehostet werden, die der ResponsesAgent Schnittstelle folgen. Dies ist der empfohlene Ansatz für die Erstellung von Agenten. Sie müssen ein Databricks OAuth-Token verwenden, um Agents abzufragen, die in Databricks-Apps gehostet werden.

from databricks.sdk import WorkspaceClient
from databricks_openai import DatabricksOpenAI

input_msgs = [{"role": "user", "content": "What does Databricks do?"}]
app_name = "<agent-app-name>"  # TODO: update this with your app name

# The WorkspaceClient must be configured with OAuth authentication
# See: https://docs.databricks.com/aws/en/dev-tools/auth/oauth-u2m.html
w = WorkspaceClient()

client = DatabricksOpenAI(workspace_client=w)

# Run for non-streaming responses. Calls the "invoke" method
# Include the "apps/" prefix in the model name
response = client.responses.create(model=f"apps/{app_name}", input=input_msgs)
print(response)

# Include stream=True for streaming responses. Calls the "stream" method
# Include the "apps/" prefix in the model name
streaming_response = client.responses.create(
    model=f"apps/{app_name}", input=input_msgs, stream=True
)
for chunk in streaming_response:
    print(chunk)

Wenn Sie custom_inputs übergeben möchten, können Sie sie mit dem extra_body Parameter hinzufügen.

streaming_response = client.responses.create(
    model=f"apps/{app_name}",
    input=input_msgs,
    stream=True,
    extra_body={
        "custom_inputs": {"id": 5},
    },
)
for chunk in streaming_response:
    print(chunk)

Agenten bei Model Serving

Verwenden Sie das folgende Beispiel für Legacy-Agents, die auf Model Serving gemäß der ResponsesAgent Schnittstelle gehostet werden. Sie können entweder ein Databricks OAuth-Token oder ein PERSONAL Access Token (PAT) verwenden, um Agents abzufragen, die auf Model Serving gehostet werden.

from databricks_openai import DatabricksOpenAI

input_msgs = [{"role": "user", "content": "What does Databricks do?"}]
endpoint = "<agent-endpoint-name>" # TODO: update this with your endpoint name

client = DatabricksOpenAI()

# Run for non-streaming responses. Invokes `predict`
response = client.responses.create(model=endpoint, input=input_msgs)
print(response)

# Include stream=True for streaming responses. Invokes `predict_stream`
streaming_response = client.responses.create(model=endpoint, input=input_msgs, stream=True)
for chunk in streaming_response:
  print(chunk)

Wenn Sie custom_inputs oder databricks_options übergeben möchten, können Sie sie mit dem Parameter extra_body hinzufügen.

streaming_response = client.responses.create(
    model=endpoint,
    input=input_msgs,
    stream=True,
    extra_body={
        "custom_inputs": {"id": 5},
        "databricks_options": {"return_trace": True},
    },
)
for chunk in streaming_response:
    print(chunk)

Verwenden Sie das folgende Beispiel für Legacy-Agents beim Bereitstellen von Modellen gemäß den ChatAgent- oder ChatModel-Schnittstellen.

from databricks.sdk import WorkspaceClient

messages = [{"role": "user", "content": "What does Databricks do?"}]
endpoint = "<agent-endpoint-name>" # TODO: update this with your endpoint name

ws_client = WorkspaceClient()
client = ws_client.serving_endpoints.get_open_ai_client()

# Run for non-streaming responses. Invokes `predict`
response = client.chat.completions.create(model=endpoint, messages=messages)
print(response)

# Include stream=True for streaming responses. Invokes `predict_stream`
streaming_response = client.chat.completions.create(model=endpoint, messages=messages, stream=True)
for chunk in streaming_response:
  print(chunk)

Wenn Sie custom_inputs oder databricks_options übergeben möchten, können Sie sie mit dem Parameter extra_body hinzufügen.

streaming_response = client.chat.completions.create(
    model=endpoint,
    messages=messages,
    stream=True,
    extra_body={
        "custom_inputs": {"id": 5},
        "databricks_options": {"return_trace": True},
    },
)
for chunk in streaming_response:
    print(chunk)

REST API

Die Databricks-REST-API stellt Endpunkte für Modelle bereit, die openAI-kompatibel sind. Auf diese Weise können Sie Databricks-Agents verwenden, um Anwendungen zu bedienen, die OpenAI-Schnittstellen erfordern.

Dieser Ansatz ist ideal für:

• Sprachunabhängige Anwendungen, die HTTP-Anforderungen verwenden
• Integration mit Drittanbieterplattformen, die openAI-kompatible APIs erwarten
• Migrieren von OpenAI zu Databricks mit minimalen Codeänderungen

Authentifizieren sie sich mit der REST-API mit einem Databricks OAuth-Token. Weitere Optionen und Informationen finden Sie in der Databricks-Authentifizierungsdokumentation .

In Apps bereitgestellte Agents

Verwenden Sie das folgende Beispiel für Agents, die auf Databricks-Apps gehostet werden, die der ResponsesAgent Schnittstelle folgen. Dies ist der empfohlene Ansatz für die Erstellung von Agents. Sie müssen ein Databricks OAuth-Token verwenden, um Agents abzufragen, die in Databricks-Apps gehostet werden.

curl --request POST \
  --url <app-url>.databricksapps.com/responses \
  --header 'Authorization: Bearer <OAuth token>' \
  --header 'content-type: application/json' \
  --data '{
    "input": [{ "role": "user", "content": "hi" }],
    "stream": true
  }'

Wenn Sie custom_inputs übergeben möchten, können Sie sie dem Anfrage-Body hinzufügen.

curl --request POST \
  --url <app-url>.databricksapps.com/responses \
  --header 'Authorization: Bearer <OAuth token>' \
  --header 'content-type: application/json' \
  --data '{
    "input": [{ "role": "user", "content": "hi" }],
    "stream": true,
    "custom_inputs": { "id": 5 }
  }'

Agenten bei der Modellbereitstellung

Verwenden Sie das folgende Beispiel für Legacy-Agents, die auf Model Serving nach der ResponsesAgent Schnittstelle gehostet sind. Sie können entweder ein Databricks OAuth-Token oder ein PERSONAL Access Token (PAT) verwenden, um Agents abzufragen, die auf Model Serving gehostet werden. Der REST-API-Aufruf entspricht folgendem:

• Verwendung des Databricks OpenAI-Clients mit responses.create.
• Senden einer POST-Anforderung an die URL des bestimmten Endpunkts (z. B. https://<host.databricks.com>/serving-endpoints/\<model-name\>/invocations). Weitere Informationen finden Sie auf der Seite "Modellbereitstellung" ihres Endpunkts und in der Dokumentation zur Modellbereitstellung.

curl --request POST \
  --url https://<host.databricks.com\>/serving-endpoints/responses \
  --header 'Authorization: Bearer <OAuth token>' \
  --header 'content-type: application/json' \
  --data '{
    "model": "\<model-name\>",
    "input": [{ "role": "user", "content": "hi" }],
    "stream": true
  }'

Wenn Sie custom_inputs oder databricks_options übergeben möchten, können Sie diese dem Anforderungstext hinzufügen:

curl --request POST \
  --url https://<host.databricks.com\>/serving-endpoints/responses \
  --header 'Authorization: Bearer <OAuth token>' \
  --header 'content-type: application/json' \
  --data '{
    "model": "\<model-name\>",
    "input": [{ "role": "user", "content": "hi" }],
    "stream": true,
    "custom_inputs": { "id": 5 },
    "databricks_options": { "return_trace": true }
  }'

Verwenden Sie Folgendes für Agents, die mit älteren ChatAgent- oder ChatModel-Schnittstellen erstellt wurden. Dies entspricht:

• Verwendung des Databricks OpenAI-Clients mit chat.completions.create.
• Senden einer POST-Anforderung an die URL des bestimmten Endpunkts (z. B. https://<host.databricks.com>/serving-endpoints/\<model-name\>/invocations). Weitere Informationen finden Sie auf der Seite "Modellbereitstellung" ihres Endpunkts und in der Dokumentation zur Modellbereitstellung.

curl --request POST \
  --url https://<host.databricks.com\>/serving-endpoints/chat/completions \
  --header 'Authorization: Bearer <OAuth token>' \
  --header 'content-type: application/json' \
  --data '{
    "model": "\<model-name\>",
    "messages": [{ "role": "user", "content": "hi" }],
    "stream": true
  }'

Wenn Sie custom_inputs oder databricks_options in den Anforderungstext übergeben möchten, können Sie diese dem Anforderungstext hinzufügen.

curl --request POST \
  --url https://<host.databricks.com\>/serving-endpoints/chat/completions \
  --header 'Authorization: Bearer <OAuth token>' \
  --header 'content-type: application/json' \
  --data '{
    "model": "\<model-name\>",
    "messages": [{ "role": "user", "content": "hi" }],
    "stream": true,
    "custom_inputs": { "id": 5 },
    "databricks_options": { "return_trace": true }
  }'

KI-Funktionen: ai_query

Sie können ai_query verwenden, um einen bereitgestellten Agenten auf einem Modell-Server mithilfe von SQL abzufragen. Siehe ai_query Funktion für SQL-Syntax und Parameterdefinitionen.

SELECT ai_query(
  "<model name>", question
) FROM (VALUES ('what is MLflow?'), ('how does MLflow work?')) AS t(question);

Nächste Schritte

Überwachen von GenAI in der Produktion