Az AI-ügynökök használatának első lépései

Készítse el első AI-ügynökét a Mozaik AI-ügynök keretrendszerével. Ebben az oktatóanyagban a következőket meg fogja tanulni:

Ügynök létrehozása az Agent Framework használatával.
Ügynökéhez adjon hozzá egy eszközt.
Helyezze üzembe az ügynököt egy végpontot kiszolgáló Databricks-modellben.

Az ügynökök és más generációs AI-alkalmazások elméleti bemutatása: Mik azok a gen AI-alkalmazások?

Követelmények

A munkaterületen engedélyezve kell lennie a következő funkcióknak:

Unity-katalógus
Mozaik AI-ügynök keretrendszere
Alapmodellek (jogkivonatonkénti fizetés, kiosztott átviteli sebesség vagy külső modellek). Korlátozott regionális rendelkezésre állású szolgáltatások megtekintése

Példajegyzetfüzet

Ez a jegyzetfüzet tartalmazza az első AI-ügynök létrehozásához és üzembe helyezéséhez szükséges összes kódot. Importálja a jegyzetfüzetet az Azure Databricks-munkaterületre a futtatáshoz.

Mozaik AI-ügynök bemutatója

Jegyzetfüzet szerezz

Az ügynök definiálása

Az AI-ügynökök a következőkből állnak:

Nagy nyelvi modell (LLM), amely képes indokokat és döntéseket hozni
Az LLM által használható eszközök nem csak szöveg létrehozására használhatók, például Python-kód futtatására vagy adatok beolvasására

Futtassa a következő kódot egy Databricks-jegyzetfüzetben egy egyszerű eszközhívó ügynök definiálásához:

Telepítse a szükséges Python-csomagokat:
```
%pip install -U -qqqq mlflow databricks-openai databricks-agents"
dbutils.library.restartPython()
```
- mlflow: Ügynökfejlesztéshez és ügynökkövetéshez használatos.
- databricks-openai: A Databricks által üzemeltetett LLM-hez való csatlakozáshoz és a Unity Catalog eszközeinek eléréséhez használható.
- databricks-agents: Az ügynök csomagolására és üzembe helyezésére szolgál.

Határozza meg az ügynököt. Ez a kódrészlet a következőket teszi:

Az OpenAI-ügyféllel csatlakozik a végpontot kiszolgáló Databricks-modellhez.
Az MLflow nyomkövetés engedélyezése a(z) autolog() használatával. Ez rendszerezést ad hozzá, így láthatja, hogy az ügynök mit tesz egy lekérdezés elküldésekor.
Hozzáadja a system.ai.python_exec eszközt az ügynökhöz. Ez a beépített Unity Catalog-függvény lehetővé teszi, hogy az ügynök Python-kódot futtasson.
MLflow-segédfüggvények (output_to_responses_items_stream, create_function_call_output_item) használatával konvertálja a streamelt LLM-kimenetet Válasz API-kompatibilis formátumra.

import json
import mlflow
from databricks.sdk import WorkspaceClient
from databricks_openai import UCFunctionToolkit, DatabricksFunctionClient
# Import MLflow utilities for converting from chat completions to Responses API format
from mlflow.types.responses import output_to_responses_items_stream, create_function_call_output_item

# Enable automatic tracing for easier debugging
mlflow.openai.autolog()

# Get an OpenAI client configured to connect to Databricks model serving endpoints
openai_client = WorkspaceClient().serving_endpoints.get_open_ai_client()

# Load Databricks built-in tools (Python code interpreter)
client = DatabricksFunctionClient()
builtin_tools = UCFunctionToolkit(function_names=["system.ai.python_exec"], client=client).tools
for tool in builtin_tools:
  del tool["function"]["strict"]

def call_tool(tool_name, parameters):
  if tool_name == "system__ai__python_exec":
    return DatabricksFunctionClient().execute_function("system.ai.python_exec", parameters=parameters).value
  raise ValueError(f"Unknown tool: {tool_name}")

def call_llm(prompt):
  for chunk in openai_client.chat.completions.create(
    model="databricks-claude-sonnet-4-5",
    messages=[{"role": "user", "content": prompt}],
    tools=builtin_tools,
    stream=True
  ):
    yield chunk.to_dict()

def run_agent(prompt):
  """
  Send a user prompt to the LLM, and yield LLM + tool call responses
  The LLM is allowed to call the code interpreter tool if needed, to respond to the user
  """
  # Convert output into Responses API-compatible events
  for chunk in output_to_responses_items_stream(call_llm(prompt)):
    yield chunk.model_dump(exclude_none=True)
  # If the model executed a tool, call it and yield the tool call output in Responses API format
  if chunk.item.get('type') == 'function_call':
    tool_name = chunk.item["name"]
    tool_args = json.loads(chunk.item["arguments"])
    tool_result = call_tool(tool_name, tool_args)
    yield {"type": "response.output_item.done", "item": create_function_call_output_item(call_id=chunk.item["call_id"], output=tool_result)}

Teszteld az ügynököt

Tesztelje az ügynököt úgy, hogy egy Python-kód futtatását igénylő kéréssel kérdezi le:

for output_chunk in run_agent("What is the square root of 429?"):
  print(output_chunk)

Az LLM kimenetén kívül a részletes nyomkövetési információk közvetlenül a jegyzetfüzetben is megjelennek. Ezek a nyomkövetések segítenek a lassú vagy sikertelen ügynökhívások hibakeresésében. Ezeket a nyomokat a rendszer automatikusan hozzáadta mlflow.openai.autolog()-vel.

Az ügynök üzembe helyezése

Most, hogy rendelkezik egy ügynökkel, csomagolhatja és üzembe helyezheti azt egy végpontot kiszolgáló Databricksben. Az üzembe helyezett ügynök visszajelzésének gyűjtéséhez ossza meg másokkal, és csevegjen vele a beépített csevegőfelületet használva.

Ügynökkód előkészítése az üzembe helyezéshez

Az ügynök kódjának üzembe helyezéséhez csomagolja be az MLflow ResponsesAgent felület használatával. Az ResponsesAgent interfész az ügynököknek az Azure Databricks telepítésére való csomagolásának javasolt módja.

Az ResponsesAgent interfész implementálásához definiálja mind a predict_stream() metódusokat (streamelési válaszokhoz), mind pedig a predict() metódusokat (nem streamelt kérelmekhez). Mivel a mögöttes ügynöklogika már a Responses API-kompatibilis eseményeket adja ki, a megvalósítás egyszerű:

from mlflow.pyfunc import ResponsesAgent
from mlflow.types.responses import ResponsesAgentRequest, ResponsesAgentResponse, ResponsesAgentStreamEvent

class QuickstartAgent(ResponsesAgent):
  def predict_stream(self, request: ResponsesAgentRequest):
    # Extract the user's prompt from the request
    prompt = request.input[-1].content
    # Stream response items from our agent
    for chunk in run_agent(prompt):
      yield ResponsesAgentStreamEvent(**chunk)

  def predict(self, request: ResponsesAgentRequest) -> ResponsesAgentResponse:
    outputs = [
      event.item
      for event in self.predict_stream(request)
      if event.type == "response.output_item.done"
    ]
    return ResponsesAgentResponse(output=outputs)

Adja hozzá a következő kódot a jegyzetfüzetéhez a ResponsesAgent osztály teszteléséhez.

from mlflow.types.responses import ResponsesAgentRequest

AGENT = QuickstartAgent()

# Create a ResponsesAgentRequest with input messages
request = ResponsesAgentRequest(
  input=[
    {
      "role": "user",
      "content": "What's the square root of 429?"
    }
  ]
)

for event in AGENT.predict_stream(request):
  print(event)

Az összes ügynökkódot egyetlen fájlba kombinálhatja, így naplózhatja és üzembe helyezheti.

Összesítse az összes ügynökkódot egy jegyzetfüzetcellába.
A cella elején adja hozzá a varázsparancsot %%writefile quickstart_agent.py az ügynök fájlba mentéséhez.
A cella alján hívja meg az ügynökobjektumot a mlflow.models.set_model() jelzéssel. Ez jelzi, hogy az MLflow melyik ügynökobjektumot használja az előrejelzések kiszolgálása során. Ez a lépés hatékonyan konfigurálja a kiindulópontot az ügynökünk kódjához.

A jegyzetfüzet cellának a következőképpen kell kinéznie:

%%writefile quickstart_agent.py

import json
from databricks.sdk import WorkspaceClient
from databricks_openai import UCFunctionToolkit, DatabricksFunctionClient

import mlflow
from mlflow.pyfunc import ResponsesAgent
from mlflow.types.responses import (
  ResponsesAgentRequest,
  ResponsesAgentResponse,
  ResponsesAgentStreamEvent,
  output_to_responses_items_stream,
  create_function_call_output_item
)

# Enable automatic tracing for deployed agent
mlflow.openai.autolog()

# Get an OpenAI client configured to talk to Databricks model serving endpoints
openai_client = WorkspaceClient().serving_endpoints.get_open_ai_client()

# Load Databricks built-in tools (Python code interpreter)
client = DatabricksFunctionClient()
builtin_tools = UCFunctionToolkit(function_names=["system.ai.python_exec"], client=client).tools
for tool in builtin_tools:
  del tool["function"]["strict"]

def call_tool(tool_name, parameters):
  if tool_name == "system__ai__python_exec":
    return DatabricksFunctionClient().execute_function("system.ai.python_exec", parameters=parameters).value
  raise ValueError(f"Unknown tool: {tool_name}")

def call_llm(prompt):
  for chunk in openai_client.chat.completions.create(
    model="databricks-claude-sonnet-4-5",
    messages=[{"role": "user", "content": prompt}],
    tools=builtin_tools,
    stream=True
  ):
    yield chunk.to_dict()

def run_agent(prompt):
  """
  Send a user prompt to the LLM, and yield LLM + tool call responses
  The LLM is allowed to call the code interpreter tool if needed, to respond to the user
  """
  # Convert output into Responses API-compatible events
  for chunk in output_to_responses_items_stream(call_llm(prompt)):
    yield chunk.model_dump(exclude_none=True)
  # If the model executed a tool, call it and yield the tool call output in Responses API format
  if chunk.item.get('type') == 'function_call':
    tool_name = chunk.item["name"]
    tool_args = json.loads(chunk.item["arguments"])
    tool_result = call_tool(tool_name, tool_args)
    yield {"type": "response.output_item.done", "item": create_function_call_output_item(call_id=chunk.item["call_id"], output=tool_result)}

class QuickstartAgent(ResponsesAgent):
  def predict_stream(self, request: ResponsesAgentRequest):
    # Extract the user's prompt from the request
    prompt = request.input[-1].content
    # Stream response items from our agent
    for chunk in run_agent(prompt):
      yield ResponsesAgentStreamEvent(**chunk)

  def predict(self, request: ResponsesAgentRequest) -> ResponsesAgentResponse:
    outputs = [
      event.item
      for event in self.predict_stream(request)
      if event.type == "response.output_item.done"
    ]
    return ResponsesAgentResponse(output=outputs)

AGENT = QuickstartAgent()
mlflow.models.set_model(AGENT)

Az ügynök rögzítése

Jegyezze az ügynököt, és regisztrálja az Unity Catalogba. Ez az ügynököt és annak függőségeit egyetlen összetevőbe csomagolja az üzembe helyezés érdekében.

import mlflow
from mlflow.models.resources import DatabricksFunction, DatabricksServingEndpoint
from pkg_resources import get_distribution

# Change the catalog name ("main") and schema name ("default") to register the agent to a different location
registered_model_name = "main.default.quickstart_agent"

# Specify Databricks resources that the agent needs to access.
# This step lets Databricks automatically configure authentication
# so the agent can access these resources when it's deployed.
resources = [
  DatabricksServingEndpoint(endpoint_name="databricks-claude-sonnet-4-5"),
  DatabricksFunction(function_name="system.ai.python_exec"),
]

mlflow.set_registry_uri("databricks-uc")
logged_agent_info = mlflow.pyfunc.log_model(
  artifact_path="agent",
  python_model="quickstart_agent.py",
  extra_pip_requirements=[f"databricks-connect=={get_distribution('databricks-connect').version}"],
  resources=resources,
  registered_model_name=registered_model_name
)

Az ügynök üzembe helyezése

A regisztrált ügynök üzembe helyezése egy kiszolgálóvégponton:

from databricks import agents

deployment_info = agents.deploy(
  model_name=registered_model_name,
  model_version=logged_agent_info.registered_model_version,
  scale_to_zero=True
)

Az ügynökvégpont elindítása után cseveghet vele az AI Playground használatával, vagy megoszthatja az érintettekkel visszajelzés céljából.

Következő lépések

A célok alapján adja meg, hogy hová menjen tovább:

Az ügynök minőségének mérése és javítása: Tekintse meg az ügynökértékelés rövid útmutatóját.

Speciálisabb ügynökök létrehozása: Hozzon létre egy ügynököt, amely strukturálatlan adatokkal végzi a RAG-ot, kezeli a többfordulós beszélgetéseket, és az Ügynökértékelés használatával méri a minőséget. Nézd meg az oktatóanyagot: lekérő ügynök létrehozása, kiértékelése és üzembe helyezése.

Megtudhatja, hogyan hozhat létre ügynököket más keretrendszerek használatával: Megtudhatja, hogyan hozhat létre ügynököket olyan népszerű kódtárak használatával, mint a LangGraph, a tiszta Python és az OpenAI. Lásd: Szerzői AI-ügynökök a kódban

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-12-09

Megosztás a következőn keresztül:

Az AI-ügynökök használatának első lépései

Követelmények

Példajegyzetfüzet

Mozaik AI-ügynök bemutatója

Az ügynök definiálása

Teszteld az ügynököt

Az ügynök üzembe helyezése

Ügynökkód előkészítése az üzembe helyezéshez

Az ügynök rögzítése

Az ügynök üzembe helyezése

Következő lépések

Visszajelzés

További források