O senhor pode começar com AI agentes

Crie seu primeiro agente AI usando o Mosaic AI Agent Framework. Neste tutorial, o senhor aprenderá:

Crie um agente usando o Agent Framework.
Adicione uma ferramenta ao seu agente.
O senhor implantou seu agente em um Databricks servindo o modelo endpoint.

Para obter uma introdução conceitual aos agentes e outros aplicativos gen AI, consulte O que são aplicativos gen AI?

Requisitos

O site workspace deve ter os seguintes recursos ativados:

Unity Catalog
Estrutura do Mosaic AI Agent
Modelos de fundação (pay-per-tokens, provisionamento, taxa de transferência ou modelos externos). Ver recurso com disponibilidade regional limitada

Exemplo de notebook

Este Notebook contém todo o código de que o senhor precisa para criar e implantar seu primeiro agente AI. Importe o Notebook para o site Databricks workspace para executá-lo.

Mosaic AI demonstração do agente

Open notebook in new tab

Defina o agente

Um agente AI consiste no seguinte:

Um modelo de linguagem grande (LLM) que pode raciocinar e tomar decisões
Ferramentas que o LLM pode usar para fazer mais do que apenas gerar texto, como executar código Python ou buscar dados

Execute o código a seguir em um Notebook Databricks para definir um agente de chamada de ferramenta simples:

Instale o pacote Python necessário:
Python
```
%pip install -U -qqqq mlflow databricks-openai databricks-agents
dbutils.library.restartPython()
```
- mlflow: Usado para desenvolvimento e rastreamento de agentes.
- databricks-openai: Usado para conectar-se ao LLM hospedado no Databricks.
- databricks-agent: Usado para embalar e implantar o agente.

Defina o agente. Esse trecho de código faz o seguinte:

Conecta-se ao modelo Databricks servindo endpoint usando o cliente OpenAI.
Habilita o rastreamento do MLflow usando autolog(). Isso adiciona instrumentação para que você possa ver o que seu agente faz quando você envia uma consulta.
Adiciona a ferramenta system.ai.python_exec ao seu agente. Essa função integrada Unity Catalog permite que seu agente execute o código Python.
Define uma função que consulta o LLM com um prompt e trata as respostas.

Python
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

Teste o agente

Teste o agente consultando-o com um prompt que exige a execução do código Python:

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

Além da saída do LLM, o senhor verá informações detalhadas de rastreamento diretamente no Notebook. Esses rastreamentos ajudam a depurar chamadas lentas ou falhadas do agente. Esses traços foram adicionados automaticamente usando mlflow.openai.autolog() .

implantado o agente

Agora que o senhor tem um agente, pode empacotá-lo e implantá-lo em um Databricks que serve endpoint. Começar a coletar feedback sobre um agente implantado, compartilhando-o com outras pessoas e conversando com ele usando uma UI de bate-papo integrada.

Prepare o código do agente para implantação

Para preparar o código do agente para implantação, envolva-o usando a interface ChatAgent do MLflow. A interface ChatAgent é a maneira recomendada de empacotar agentes para implantação em Databricks.

Para implementar a interface ChatAgent, você deve definir uma função predict() que envie a mensagem do usuário ao agente, colete a resposta do agente e a retorne no formato ChatAgentResponses.

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

Adicione o seguinte código ao Notebook para testar a classe ChatAgent:

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

Combine todo o código do agente em um único arquivo para que o senhor possa log e implantá-lo.

Consolide todo o código do agente em uma célula do Notebook.
Na parte superior da célula, adicione o comando mágico %%writefile quickstart_agent.py para salvar seu agente em um arquivo.
Na parte inferior da célula, chame mlflow.models.set_model() com seu objeto agente. Isso informa ao MLflow qual objeto de agente deve ser usado ao fornecer previsões. Essa etapa configura efetivamente o ponto de entrada do nosso código de agente.

A célula do Notebook deve se parecer com o seguinte:

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

registrar o agente

Faça o login do seu agente e registre-o em Unity Catalog. Isso agrupa o agente e suas dependências em um único artefato para implantação.

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

implantado o agente

implantar seu agente registrado em um site endpoint:

Python
from databricks import agents

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

Depois que o agente endpoint começar, o senhor pode conversar com ele usando o AI Playground ou compartilhá-lo com as partes interessadas para obter feedback.

Próximas etapas

Escolha para onde ir a seguir com base em seus objetivos:

Avalie e melhore a qualidade do seu agente : consulte o guia de início rápido da Avaliação de Agentes.

Crie agentes mais avançados : crie um agente que execute RAG usando dados não estruturados, gerencie conversas de vários turnos e use a Avaliação de Agentes para medir a qualidade. Veja o tutorial: Criar, avaliar e implantar um agente de recuperação.

Aprenda a criar agentes utilizando outras estruturas : Aprenda a criar agentes utilizando bibliotecas populares como LangGraph, pure Python e OpenAI. Consulte os agentes de autorização AI no código.

Requisitos​

Exemplo de notebook​

Mosaic AI demonstração do agente

Defina o agente​

Teste o agente​

implantado o agente​

Prepare o código do agente para implantação​

registrar o agente​

implantado o agente​

Próximas etapas​

Requisitos

Exemplo de notebook

Defina o agente

Teste o agente

implantado o agente

Prepare o código do agente para implantação

registrar o agente

implantado o agente

Próximas etapas