Wprowadzenie do agentów sztucznej inteligencji

Zbuduj swojego pierwszego agenta AI za pomocą frameworka Mosaic AI. W tym samouczku nauczysz się następujących rzeczy:

Tworzenie agenta przy użyciu platformy Agent Framework.
Dodaj narzędzie do agenta.
Wdróż agenta w modelu usługi Databricks obsługującym punkt końcowy.

Aby zapoznać się z koncepcyjnym wprowadzeniem do agentów i innych aplikacji generatywnej sztucznej inteligencji, zobacz Co to są aplikacje generatywnej sztucznej inteligencji?

Wymagania

Obszar roboczy musi mieć włączone następujące funkcje:

Katalog Unity
Framework agentów Mosaic AI
Modele podstawowe (płatność za token, aprowizowana przepływność lub modele zewnętrzne). Zobacz Funkcje z ograniczoną dostępnością regionalną

Przykładowy notatnik

Ten notes zawiera cały kod, który należy utworzyć i wdrożyć pierwszego agenta sztucznej inteligencji. Zaimportuj notatnik do obszaru roboczego usługi Azure Databricks, aby go uruchomić.

Demo agenta Mosaic AI

Pobierz laptopa

Definiowanie agenta

Agent sztucznej inteligencji składa się z następujących elementów:

Duży model językowy (LLM), który może rozumować i podejmować decyzje
Narzędzia, których usługa LLM może używać do wykonywania innych czynności niż tylko generowania tekstu, na przykład uruchamiania kodu w języku Python lub pobierania danych

Uruchom następujący kod w notatniku Databricks, aby zdefiniować prostego agenta wywołującego narzędzia.

Zainstaluj wymagane pakiety języka Python:
```
%pip install -U -qqqq mlflow databricks-openai databricks-agents"
dbutils.library.restartPython()
```
- mlflow: służy do opracowywania agentów i śledzenia agentów.
- databricks-openai: Służy do nawiązywania połączenia z hostowaną na Databricks usługą LLM i uzyskiwania dostępu do narzędzi Unity Catalog.
- databricks-agents: służy do tworzenia pakietów i wdrażania agenta.

Zdefiniuj agenta. Ten fragment kodu wykonuje następujące czynności:

Nawiązuje połączenie z punktem końcowym usługi modelu Databricks przy użyciu klienta OpenAI.
Włącza śledzenie MLflow za pomocą autolog(). Dodaje to instrumentację, która pozwala zobaczyć, co robi agent podczas przesyłania zapytania.
Narzędzie system.ai.python_exec dodaje się do agenta. Ta wbudowana funkcja Unity Catalog umożliwia agentowi uruchamianie kodu w języku Python.
Używa funkcji pomocniczych MLflow (output_to_responses_items_stream, create_function_call_output_item) do konwertowania strumieniowych danych wyjściowych LLM na format zgodny z API Responses.

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)}

Przetestuj agenta

Przetestuj agenta, wysyłając do niego zapytanie z monitem, który wymaga uruchomienia kodu w języku Python:

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

Oprócz danych wyjściowych usługi LLM szczegółowe informacje dotyczące śledzenia będą widoczne bezpośrednio w notesie. Te ślady ułatwiają debugowanie wolnych lub nieudanych wywołań agenta. Te ślady zostały automatycznie dodane przy użyciu polecenia mlflow.openai.autolog() .

Wdrażanie agenta

Teraz, gdy masz agenta, możesz spakować go i wdrożyć w punkcie końcowym obsługującym usługę Databricks. Rozpocznij zbieranie opinii na temat wdrożonego agenta, udostępniając go innym osobom i rozmawiając z nim przy użyciu wbudowanego interfejsu użytkownika czatu.

Przygotowywanie kodu agenta do wdrożenia

Aby przygotować kod agenta do wdrożenia, opakuj go przy użyciu interfejsu MLflow ResponsesAgent. Interfejs ResponsesAgent jest zalecanym sposobem tworzenia pakietów agentów do wdrożenia w usłudze Azure Databricks.

Aby zaimplementować interfejs ResponsesAgent, zdefiniuj metody predict_stream() (dla odpowiedzi strumieniowych) i predict() (dla żądań bez strumieniowania). Ponieważ podstawowa logika agenta generuje już zdarzenia zgodne z interfejsem API Odpowiedzi, implementacja jest prosta:

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)

Dodaj następujący kod do notesu, aby przetestować klasę ResponsesAgent :

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)

Połącz cały kod agenta w jeden plik, aby można było go rejestrować i wdrażać.

Skonsoliduj cały kod agenta w jedną komórkę notatnika.
Na górze komórki dodaj magiczne polecenie %%writefile quickstart_agent.py, aby zapisać agenta w pliku.
Na dole komórki wywołaj mlflow.models.set_model() z obiektem agenta. Informuje to MLflow, który obiekt agenta ma być używany podczas obsługi przewidywań. Ten krok efektywnie konfiguruje punkt wejścia do naszego kodu agenta.

Komórka notesu powinna wyglądać następująco:

%%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)

Zaloguj agenta

Zaloguj swojego agenta i zarejestruj go w Unity Catalog. To zgrupuje Twojego agenta i jego zależności w jednym artefakcie do wdrożenia.

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
)

Wdrażanie agenta

Wdróż swojego zarejestrowanego agenta na punkcie obsługi.

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
)

Po uruchomieniu punktu końcowego agenta możesz porozmawiać z nim przy użyciu narzędzia AI Playground lub udostępnić go uczestnikom projektu w celu uzyskania opinii.

Dalsze kroki

Wybierz miejsce, w którym chcesz przejść dalej, na podstawie Twoich celów:

Mierz i poprawiaj jakość swojego agenta: zobacz Szybki start: Ocena agenta.

Tworzenie bardziej zaawansowanych agentów: Utwórz agenta, który wykonuje RAG przy użyciu danych nieustrukturyzowanych, obsługuje wielowątkowe konwersacje i korzysta z Oceny Agenta do mierzenia jakości. Zobacz Samouczek: kompilowanie, ocenianie i wdrażanie agenta pobierania.

Dowiedz się, jak tworzyć agentów przy użyciu innych platform: dowiedz się, jak tworzyć agentów przy użyciu popularnych bibliotek, takich jak LangGraph, pure Python i OpenAI. Zobacz Tworzenie agentów sztucznej inteligencji w kodzie

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-12-09

Udostępnij przez

Wprowadzenie do agentów sztucznej inteligencji

Wymagania

Przykładowy notatnik

Demo agenta Mosaic AI

Definiowanie agenta

Przetestuj agenta

Wdrażanie agenta

Przygotowywanie kodu agenta do wdrożenia

Zaloguj agenta

Wdrażanie agenta

Dalsze kroki

Sprzężenie zwrotne

Dodatkowe źródła