Dela via

Kom igång med AI-agenter

Skapa din första AI-agent med Hjälp av Mosaic AI Agent Framework. I den här handledningen kommer du att:

  • Skapa en agent med Agent Framework.
  • Lägg till ett verktyg i din agent.
  • Distribuera din agent till en Databricks-modell som betjänar slutpunkten.

En konceptuell introduktion till agenter och andra gen-AI-appar finns i Vad är gen AI-appar?

Kravspecifikation

Arbetsytan måste ha följande funktioner aktiverade:

Exempelanteckningsbok

Den här notebook-filen innehåller all kod som du behöver för att skapa och distribuera din första AI-agent. Importera anteckningsboken till din Azure Databricks-arbetsyta för att köra den.

Demo av Mosaic AI-agent

Hämta anteckningsbok

Definiera agenten

En AI-agent består av följande:

  • En stor språkmodell (LLM) som kan resonera och fatta beslut
  • Verktyg som LLM kan använda för att göra mer än att bara generera text, till exempel att köra Python-kod eller hämta data

Kör följande kod i en Databricks-anteckningsbok för att definiera en enkel verktygssamtalsagent:

  1. Installera nödvändiga Python-paket:

    %pip install -U -qqqq mlflow databricks-openai databricks-agents
dbutils.library.restartPython()
    • mlflow: Används för agentutveckling och agentspårning.
    • databricks-openai: Används för att ansluta till LLM värdsatta av Databricks.
    • databricks-agent: Används för att paketera och distribuera agenten.

  2. Definiera agenten. Det här kodfragmentet gör följande:

    • Ansluter till Databricks-modellen som betjänar slutpunkten med hjälp av OpenAI-klienten.
    • Aktiverar MLflow-spårning med .autolog() Detta lägger till instrumentation så att du kan se vad din agent gör när du skickar en fråga.
    • Lägger till system.ai.python_exec-verktyget till din agent. Med den här inbyggda Unity Catalog-funktionen kan din agent köra Python-kod.
    • Definierar en funktion som kommunicerar med LLM med en uppmaning och hanterar svar.
    import mlflow
import json
from databricks.sdk import WorkspaceClient
from databricks_openai import UCFunctionToolkit, DatabricksFunctionClient

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

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

# 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)
  raise ValueError(f"Unknown tool: {tool_name}")

def run_agent(prompt):
  """
  Send a user prompt to the LLM and return a list of LLM response messages
  The LLM is allowed to call the code interpreter tool, if needed, to respond to the user
  """
  result_msgs = []
  response = openai_client.chat.completions.create(
    model="databricks-claude-3-7-sonnet",
    messages=[{"role": "user", "content": prompt}],
    tools=builtin_tools,
  )
  msg = response.choices[0].message
  result_msgs.append(msg.to_dict())

  # If the model executed a tool, call it
  if msg.tool_calls:
    call = msg.tool_calls[0]
    tool_result = call_tool(call.function.name, json.loads(call.function.arguments))
    result_msgs.append({"role": "tool", "content": tool_result.value, "name": call.function.name, "tool_call_id": call.id})
  return result_msgs

Testa agenten

Testa agenten genom att fråga den med en fråga som kräver att Python-kod körs:

answer = run_agent("What is the 100th fibonacci number?")
for message in answer:
  print(f'{message["role"]}: {message["content"]}')

Förutom LLM:s resultat ser du detaljerad spårningsinformation direkt i din notebook. Dessa spårningar hjälper dig att felsöka långsamma eller misslyckade agentanrop. Dessa spårningar lades automatiskt till med hjälp av mlflow.openai.autolog() .

Distribuera agenten

Nu när du har en agent kan du paketera och distribuera den till en Databricks-serverslutpunkt. Börja samla in feedback om en distribuerad agent genom att dela den med andra och chatta med den med hjälp av ett inbyggt chattgränssnitt.

Förbereda agentkod för distribution

Om du vill förbereda agentkoden för distributionen omsluter du den med MLflows ChatAgent gränssnitt. Gränssnittet ChatAgent är det rekommenderade sättet att paketera agenter för distribution på Azure Databricks.

  1. För att implementera ChatAgent gränssnittet måste du definiera en predict() funktion som skickar användarens meddelande till agenten, samlar in agentens svar och returnerar det i ChatAgentResponses formatet.

    import uuid
from typing import Any, Optional

from mlflow.pyfunc import ChatAgent
from mlflow.types.agent import ChatAgentMessage, ChatAgentResponse, ChatContext

class QuickstartAgent(ChatAgent):
  def predict(
    self,
    messages: list[ChatAgentMessage],
    context: Optional[ChatContext] = None,
    custom_inputs: Optional[dict[str, Any]] = None,
  ) -> ChatAgentResponse:
    # 1. Extract the last user prompt from the input messages
    prompt = messages[-1].content

    # 2. Call run_agent to get back a list of response messages
    raw_msgs = run_agent(prompt)

    # 3. Map each response message into a ChatAgentMessage and return
    # the response
    out = []
    for m in raw_msgs:
      out.append(ChatAgentMessage(
        id=uuid.uuid4().hex,
        **m
      ))

    return ChatAgentResponse(messages=out)

  2. Lägg till följande kod i notebook-filen för att testa klassen ChatAgent :

    AGENT = QuickstartAgent()
for response_message in AGENT.predict({"messages": [{"role": "user", "content": "What's the 100th fibonacci number?"}]}).messages:
  print(f"role: {response_message.role}, content: {response_message.content}")

  3. Kombinera all agentkod i en enda fil så att du kan logga och distribuera den.

  • Konsolidera all din agentkod till en notebook-cell.
  • Överst i cellen lägger du till det %%writefile quickstart_agent.py magiska kommandot för att spara agenten i en fil.
  • "Anropa mlflow.models.set_model() med ditt agentobjekt längst ned i cellen." Detta talar om för MLflow vilket agentobjekt som ska användas när förutsägelser hanteras. Det här steget konfigurerar effektivt startpunkten för vår agentkod.

Notebook-cellen bör se ut så här:

%%writefile quickstart_agent.py

import json
import uuid
from databricks.sdk import WorkspaceClient
from databricks_openai import UCFunctionToolkit, DatabricksFunctionClient
from typing import Any, Optional

import mlflow
from mlflow.pyfunc import ChatAgent
from mlflow.types.agent import ChatAgentMessage, ChatAgentResponse, ChatContext

# Add an mlflow.openai.autolog() call to capture traces in the serving endpoint

# Get an OpenAI client configured to talk to Databricks model serving endpoints
# We'll use this to query an LLM in our agent
openai_client = WorkspaceClient().serving_endpoints.get_open_ai_client()

# Load Databricks built-in tools (a stateless Python code interpreter tool)
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)
  raise ValueError(f"Unknown tool: {tool_name}")

def run_agent(prompt):
  """
  Send a user prompt to the LLM, and return a list of LLM response messages
  The LLM is allowed to call the code interpreter tool if needed, to respond to the user
  """
  result_msgs = []
  response = openai_client.chat.completions.create(
    model="databricks-claude-3-7-sonnet",
    messages=[{"role": "user", "content": prompt}],
    tools=builtin_tools,
  )
  msg = response.choices[0].message
  result_msgs.append(msg.to_dict())

  # If the model executed a tool, call it
  if msg.tool_calls:
    call = msg.tool_calls[0]
    tool_result = call_tool(call.function.name, json.loads(call.function.arguments))
    result_msgs.append({"role": "tool", "content": tool_result.value, "name": call.function.name, "tool_call_id": call.id})
  return result_msgs

class QuickstartAgent(ChatAgent):
  def predict(
    self,
    messages: list[ChatAgentMessage],
    context: Optional[ChatContext] = None,
    custom_inputs: Optional[dict[str, Any]] = None,
  ) -> ChatAgentResponse:
    prompt = messages[-1].content
    raw_msgs = run_agent(prompt)
    out = []
    for m in raw_msgs:
      out.append(ChatAgentMessage(
        id=uuid.uuid4().hex,
        **m
      ))

    return ChatAgentResponse(messages=out)

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

Logga agenten

Logga din agent och registrera den i Unity Catalog. Detta paketerar din agent och dess beroenden i en enda artefakt för distribution.

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-3-7-sonnet"),
  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
)

Distribuera agenten

Distribuera din registrerade agent till en serverslutpunkt:

from databricks import agents

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

När agentslutpunkten har startat kan du chatta med den med AI Playground eller dela den med intressenter för feedback.

Nästa steg

Välj vart du ska gå härnäst baserat på dina mål:

Mät och förbättra agentens kvalitet: Se Snabbstart för agentutvärdering.

Skapa mer avancerade agenter: Skapa en agent som utför RAG med ostrukturerade data, hanterar konversationer med flera turer och använder Agentutvärdering för att mäta kvalitet. Se Självstudie: Skapa, utvärdera och distribuera en hämtningsagent.

Lär dig hur du skapar agenter med andra ramverk: Lär dig hur du skapar agenter med hjälp av populära bibliotek som LangGraph, ren Python och OpenAI. Se Skapa AI-agenter i kod