Introdução aos agentes de IA Databricks

Este tutorial guia-o na criação de um agente de IA que utiliza a busca de informação e ferramentas em conjunto. O conjunto de dados consiste em um subconjunto da documentação do Databricks que já está dividido em partes. Neste tutorial, você cria um agente que recupera documentos com base em palavras-chave.

Para simplificar, este tutorial usa uma abordagem simples em memória baseada em TF-IDF para extração de palavras-chave e pesquisa de palavras-chave nos documentos. O de bloco de anotações de exemplo inclui todo o código usado no tutorial. Para obter um exemplo mais realista que usa o Mosaic AI Vetor Search para indexar e pesquisar documentos de forma escalável, consulte ChatAgent exemplos.

Este tutorial aborda alguns dos principais desafios da criação de aplicativos de IA generativa:

• Simplificando a experiência de desenvolvimento para tarefas comuns, como a criação de ferramentas e a execução do agente de depuração.
• Desafios operacionais, tais como:
  • Configuração do agente de rastreamento
  • Definição de entradas e saídas de forma previsível
  • Gerenciando versões de dependências
  • Controle de versão e implantação
• Medir e melhorar a qualidade e fiabilidade de um agente.

Consulte o guia de aplicações de IA generativa para obter orientações para todo o processo de desenvolvimento de um agente.

Exemplo de bloco de notas

Este bloco de anotações autônomo foi projetado para que você trabalhe rapidamente com agentes Mosaic AI usando um corpus de documentos de exemplo. Está pronto para ser executado sem necessidade de configuração ou dados.

Demonstração do agente Mosaic AI

Obter caderno

Criar um agente e ferramentas

O Mosaic AI Agent Framework suporta muitas estruturas de criação diferentes. Este exemplo usa LangGraph para ilustrar conceitos, mas este não é um tutorial LangGraph.

Para obter exemplos de outras estruturas suportadas, consulte ChatAgent exemplos.

O primeiro passo é criar um agente. Você deve especificar um cliente LLM e uma lista de ferramentas. O pacote databricks-langchain Python inclui clientes compatíveis com LangChain e LangGraph para LLMs do Databricks e ferramentas registadas no Catálogo Unity.

O ponto de extremidade deve ser uma API de Modelo de Base de chamada de função ou Modelo Externo usando o AI Gateway. Consulte Modelos suportados.

from databricks_langchain import ChatDatabricks
llm = ChatDatabricks(endpoint="databricks-meta-llama-3-3-70b-instruct")

O código a seguir define uma função que cria um agente a partir do modelo e algumas ferramentas, discutindo os internos desse código de agente está fora do escopo deste guia. Para obter mais informações sobre como criar um agente LangGraph, consulte documentação do LangGraph.

from typing import Optional, Sequence, Union

from langchain_core.language_models import LanguageModelLike
from langchain_core.runnables import RunnableConfig, RunnableLambda
from langchain_core.tools import BaseTool
from langgraph.graph import END, StateGraph
from langgraph.graph.graph import CompiledGraph
from langgraph.prebuilt.tool_executor import ToolExecutor
from mlflow.langchain.chat_agent_langgraph import ChatAgentState, ChatAgentToolNode


def create_tool_calling_agent(
  model: LanguageModelLike,
  tools: Union[ToolExecutor, Sequence[BaseTool]],
  agent_prompt: Optional[str] = None,
) -> CompiledGraph:
  model = model.bind_tools(tools)

  def routing_logic(state: ChatAgentState):
    last_message = state["messages"][-1]
    if last_message.get("tool_calls"):
      return "continue"
    else:
      return "end"

  if agent_prompt:
    system_message = {"role": "system", "content": agent_prompt}
    preprocessor = RunnableLambda(
      lambda state: [system_message] + state["messages"]
    )
  else:
    preprocessor = RunnableLambda(lambda state: state["messages"])
  model_runnable = preprocessor | model

  def call_model(
    state: ChatAgentState,
    config: RunnableConfig,
  ):
    response = model_runnable.invoke(state, config)

    return {"messages": [response]}

  workflow = StateGraph(ChatAgentState)

  workflow.add_node("agent", RunnableLambda(call_model))
  workflow.add_node("tools", ChatAgentToolNode(tools))

  workflow.set_entry_point("agent")
  workflow.add_conditional_edges(
    "agent",
    routing_logic,
    {
      "continue": "tools",
      "end": END,
    },
  )
  workflow.add_edge("tools", "agent")

  return workflow.compile()

Definir ferramentas do agente

As ferramentas são um conceito fundamental para os agentes de construção. Eles fornecem a capacidade de integrar LLMs com código definido por humanos. Quando um LLM de chamada de ferramenta recebe um prompt e uma lista de ferramentas, ele gera os argumentos para invocar a ferramenta. Para obter mais informações sobre ferramentas e usá-las com agentes Mosaic AI, consulte ferramentas de agentes de IA.

O primeiro passo é criar uma ferramenta de extração de palavras-chave baseada no TF-IDF. Este exemplo usa scikit-learn e uma ferramenta Unity Catalog.

O pacote databricks-langchain fornece uma maneira conveniente de trabalhar com as ferramentas do Unity Catalog. O código a seguir ilustra como implementar e registrar uma ferramenta de extração de palavras-chave.

Observação

O espaço de trabalho Databricks tem uma ferramenta interna, system.ai.python_exec, que você pode usar para estender agentes com a capacidade de executar scripts Python em um ambiente de execução em área restrita. Outras ferramentas incorporadas úteis incluem conexões externas e funções de inteligência artificial.

from databricks_langchain.uc_ai import (
  DatabricksFunctionClient,
  UCFunctionToolkit,
  set_uc_function_client,
)

uc_client = DatabricksFunctionClient()
set_uc_function_client(client)

# Change this to your catalog and schema
CATALOG = "main"
SCHEMA = "my_schema"


def tfidf_keywords(text: str) -> list[str]:
  """
  Extracts keywords from the provided text using TF-IDF.

  Args:
    text (string): Input text.
  Returns:
    list[str]: List of extracted keywords in ascending order of importance.
  """
  from sklearn.feature_extraction.text import TfidfVectorizer

  def keywords(text, top_n=5):
    vec = TfidfVectorizer(stop_words="english")
    tfidf = vec.fit_transform([text])  # Convert text to TF-IDF matrix
    indices = tfidf.toarray().argsort()[0, -top_n:]  # Get indices of top N words
    return [vec.get_feature_names_out()[i] for i in indices]

  return keywords(text)


# Create the function in the Unity Catalog catalog and schema specified
# When you use `.create_python_function`, the provided function’s metadata
# (docstring, parameters, return type) are used to create a tool in the specified catalog and schema.
function_info = uc_client.create_python_function(
  func=tfidf_keywords,
  catalog=CATALOG,
  schema=SCHEMA,
  replace=True,  # Set to True to overwrite if the function already exists
)

print(function_info)

Aqui está uma explicação do código acima:

1. Cria um cliente que usa o Unity Catalog no espaço de trabalho Databricks como um "registro" para criar e descobrir ferramentas.
2. Define uma função Python que executa a extração de palavras-chave TF-IDF.
3. Registra a função Python como uma função Unity Catalog.

Este fluxo de trabalho resolve vários problemas comuns. Agora você tem um registro central para ferramentas que, como outros objetos no Unity Catalog, podem ser governadas. Por exemplo, se uma empresa tiver uma maneira padrão de calcular a taxa interna de retorno, você poderá defini-la como uma função no Unity Catalog e conceder acesso a todos os usuários ou agentes com a função FinancialAnalyst.

Para tornar esta ferramenta usável por um agente LangChain, use o [UCFunctionToolkit](/generative-ai/agent-framework/create-custom-tool.md) que cria uma coleção de ferramentas para dar ao LLM para seleção.

# Use ".*" here to specify all the tools in the schema, or
# explicitly list functions by name
# uc_tool_names = [f"{CATALOG}.{SCHEMA}.*"]
uc_tool_names = [f"{CATALOG}.{SCHEMA}.tfidf_keywords"]
uc_toolkit = UCFunctionToolkit(function_names=uc_tool_names)

O código a seguir mostra como testar a ferramenta:

uc_toolkit.tools[0].invoke({ "text": "The quick brown fox jumped over the lazy brown dog." })

O código a seguir cria um agente que usa a ferramenta de extração de palavra-chave.

import mlflow
mlflow.langchain.autolog()

agent = create_tool_calling_agent(llm, tools=[*uc_toolkit.tools])

agent.invoke({"messages": [{"role": "user", "content":"What are the keywords for the sentence: 'the quick brown fox jumped over the lazy brown dog'?"}]})

No traço resultante, pode ver que o LLM selecionou a ferramenta.

Usar rastreamentos para depurar agentes

O MLflow Tracing é uma ferramenta poderosa para depurar e observar aplicações generativas de IA, incluindo agentes. Ele captura informações detalhadas de execução por meio de spans, que encapsulam segmentos de código específicos e registram entradas, saídas e dados de temporização.

Para bibliotecas populares como LangChain, habilite o rastreamento automático com mlflow.langchain.autolog(). Você também pode usar mlflow.start_span() para personalizar um rastreamento. Por exemplo, você pode adicionar campos de valor de dados personalizados ou rotulagem para observabilidade. O código executado no contexto dessa extensão é associado aos campos que você define. Neste exemplo de TF-IDF em memória, dê-lhe um nome e um tipo de intervalo.

Para saber mais sobre rastreamento, consulte observabilidade do agente com o MLflow Tracing.

O exemplo a seguir cria uma ferramenta de recuperação usando um simples índice em memória TF-IDF. Isto demonstra tanto o registo automático para execuções de ferramentas quanto o rastreamento de percursos personalizado para observabilidade adicional.

from sklearn.feature_extraction.text import TfidfVectorizer
import mlflow
from langchain_core.tools import tool


documents = parsed_docs_df
doc_vectorizer = TfidfVectorizer(stop_words="english")
tfidf_matrix = doc_vectorizer.fit_transform(documents["content"])


@tool
def find_relevant_documents(query, top_n=5):
  """gets relevant documents for the query"""
  with mlflow.start_span(name="LittleIndex", span_type="RETRIEVER") as retriever_span:
    retriever_span.set_inputs({"query": query})
    retriever_span.set_attributes({"top_n": top_n})

    query_tfidf = doc_vectorizer.transform([query])
    similarities = (tfidf_matrix @ query_tfidf.T).toarray().flatten()
    ranked_docs = sorted(enumerate(similarities), key=lambda x: x[1], reverse=True)

    result = []
    for idx, score in ranked_docs[:top_n]:
      row = documents.iloc[idx]
      content = row["content"]
      doc_entry = {
        "page_content": content,
        "metadata": {
          "doc_uri": row["doc_uri"],
          "score": score,
        },
      }
      result.append(doc_entry)

    retriever_span.set_outputs(result)
    return result

Este código usa um tipo de span especial, RETRIEVER, que é reservado para ferramentas retriever. Outros recursos do agente de IA do Mosaic (como o AI Playground, a interface do usuário de revisão e a avaliação) usam o tipo RETRIEVER span para exibir os resultados da recuperação.

As ferramentas do Retriever exigem que você especifique seu esquema para garantir a compatibilidade com os recursos downstream do Databricks. Para mais informações sobre mlflow.models.set_retriever_schema, consulte Especificar esquemas personalizados de recuperador.

import mlflow
from mlflow.models import set_retriever_schema

uc_toolkit = UCFunctionToolkit(function_names=[f"{CATALOG}.{SCHEMA}.*"])

graph = create_tool_calling_agent(llm, tools=[*uc_toolkit.tools, find_relevant_documents])

mlflow.langchain.autolog()
set_retriever_schema(
  primary_key="chunk_id",
  text_column="chunk_text",
  doc_uri="doc_uri",
  other_columns=["title"],
)

graph.invoke(input = {"messages": [("user", "How do the docs say I use llm judges on databricks?")]})

Definir o agente

A próxima etapa é avaliar o agente e prepará-lo para a implantação. A um nível elevado, isto envolve o seguinte:

1. Defina uma API previsível para o agente usando uma assinatura.
2. Adicione a configuração do modelo, o que facilita a configuração de parâmetros.
3. Registe o modelo com as dependências que lhe dão um ambiente reproduzível e permitem configurar a sua autenticação para outros serviços.

A interface MLflow ChatAgent simplifica a definição de entradas e saídas do agente. Para usá-lo, defina seu agente como uma subclasse de ChatAgent, implementando inferência não streaming com a função predict e inferência streaming com a função predict_stream.

ChatAgent é agnóstica à sua escolha de estrutura de criação de agentes, permitindo que você teste e use facilmente diferentes estruturas e implementações de agente - o único requisito é implementar as interfaces predict e predict_stream.

Criar seu agente usando ChatAgent oferece vários benefícios, incluindo:

• Suporte de saída de streaming
• Histórico abrangente de mensagens de chamada de ferramentas: Devolve várias mensagens, incluindo mensagens intermediárias de chamada de ferramentas, para aperfeiçoar a qualidade e o gerenciamento das conversas.
• Suporte ao sistema multiagente
• integração de recursos do Databricks: compatibilidade pronta para uso com AI Playground, Avaliação de Agentes e Monitoramento de Agentes.
• Interfaces de criação tipadas: Escreva código de agente usando classes Python tipadas, beneficiando-se do IDE e do preenchimento automático do notebook.

Para obter mais informações sobre como criar um ChatAgent consulte Usar ChatAgent para criar agentes.

from mlflow.pyfunc import ChatAgent
from mlflow.types.agent import (
  ChatAgentChunk,
  ChatAgentMessage,
  ChatAgentResponse,
  ChatContext,
)
from typing import Any, Optional


class DocsAgent(ChatAgent):
  def __init__(self, agent):
    self.agent = agent
    set_retriever_schema(
      primary_key="chunk_id",
      text_column="chunk_text",
      doc_uri="doc_uri",
      other_columns=["title"],
    )

  def predict(
    self,
    messages: list[ChatAgentMessage],
    context: Optional[ChatContext] = None,
    custom_inputs: Optional[dict[str, Any]] = None,
  ) -> ChatAgentResponse:
    # ChatAgent has a built-in helper method to help convert framework-specific messages, like langchain BaseMessage to a python dictionary
    request = {"messages": self._convert_messages_to_dict(messages)}

    output = agent.invoke(request)
    # Here 'output' is already a ChatAgentResponse, but to make the ChatAgent signature explicit for this demonstration, the code returns a new instance
    return ChatAgentResponse(**output)

O código a seguir mostra como usar o ChatAgent.

AGENT = DocsAgent(agent=agent)
AGENT.predict(
  {
    "messages": [
      {"role": "user", "content": "What is DLT in Databricks?"},
    ]
  }
)

Configurar agentes com parâmetros

O Agent Framework permite controlar a execução do agente com parâmetros. Pode-se testar rapidamente diferentes configurações de agente, como alternar endpoints de LLM ou experimentar ferramentas diferentes sem precisar alterar o código subjacente.

O código a seguir cria um dicionário de configuração que define os parâmetros do agente ao inicializar o modelo.

Para obter mais detalhes sobre a parametrização de agentes, consulte Parametrizar o código dos agentes para implementação em vários ambientes.

)

from mlflow.models import ModelConfig

baseline_config = {
  "endpoint_name": "databricks-meta-llama-3-1-70b-instruct",
  "temperature": 0.01,
  "max_tokens": 1000,
  "system_prompt": """You are a helpful assistant that answers questions about Databricks. Questions unrelated to Databricks are irrelevant.


  You answer questions using a set of tools. If needed, you ask the user follow-up questions to clarify their request.
  """,
  "tool_list": ["catalog.schema.*"],
}


class DocsAgent(ChatAgent):
  def __init__(self):
    self.config = ModelConfig(development_config=baseline_config)
    self.agent = self._build_agent_from_config()


def _build_agent_from_config(self):
  temperature = config.get("temperature", 0.01)
  max_tokens = config.get("max_tokens", 1000)
  system_prompt = config.get("system_prompt", """You are a helpful assistant.
    You answer questions using a set of tools. If needed you ask the user follow-up questions to clarify their request.""")
  llm_endpoint_name = config.get("endpoint_name", "databricks-meta-llama-3-3-70b-instruct")
  tool_list = config.get("tool_list", [])

  llm = ChatDatabricks(endpoint=llm_endpoint_name, temperature=temperature, max_tokens=max_tokens)
  toolkit = UCFunctionToolkit(function_names=tool_list)
  agent = create_tool_calling_agent(llm, tools=[*toolkit.tools, find_relevant_documents], prompt=system_prompt)

  return agent

Registrar o agente

Depois de definir o agente, ele está pronto para ser registrado. No MLflow, registrar um agente significa salvar a configuração do agente (incluindo dependências) para que ele possa ser usado para avaliação e implantação.

Observação

Ao desenvolver agentes num notebook, o MLflow infere as dependências do agente a partir do ambiente do notebook.

Para registrar um agente a partir de um bloco de anotações, você pode escrever todo o código que define o modelo em uma única célula e, em seguida, usar o comando %%writefile magic para salvar a definição do agente em um arquivo:

%%writefile agent.py
...
<Code that defines the agent>

Se o agente exigir acesso a recursos externos, como o Unity Catalog para executar a ferramenta de extração de palavras-chave, você deverá configurar a autenticação para o agente para que ele possa acessar os recursos quando for implantado.

Para simplificar a autenticação para recursos do Databricks, habilite passagem de autenticação automática:

from mlflow.models.resources import DatabricksFunction, DatabricksServingEndpoint


resources = [
  DatabricksServingEndpoint(endpoint_name=LLM_ENDPOINT_NAME),
  DatabricksFunction(function_name=tool.uc_function_name),
]


with mlflow.start_run():
  logged_agent_info = mlflow.pyfunc.log_model(
    artifact_path="agent",
    python_model="agent.py",
    pip_requirements=[
      "mlflow",
      "langchain",
      "langgraph",
      "databricks-langchain",
      "unitycatalog-langchain[databricks]",
      "pydantic",
    ],
    resources=resources,
  )

Para saber mais sobre agentes de registo, consulte registo baseado em código.

Avaliar o agente

O próximo passo é avaliar o agente para ver como ele se comporta. A Avaliação de Agentes é desafiadora e levanta muitas questões, como as seguintes:

• Quais são as métricas certas para avaliar a qualidade? Como posso confiar nos resultados dessas métricas?
• Eu preciso avaliar muitas ideias - como faço para...
  • executar a avaliação rapidamente para que a maior parte do meu tempo não seja gasto esperando?
  • comparar rapidamente essas diferentes versões do meu agente em termos de qualidade, custo e latência?
• Como posso identificar rapidamente a causa raiz de quaisquer problemas de qualidade?

Como cientista de dados ou desenvolvedor, você pode não ser o verdadeiro especialista no assunto. O restante desta seção descreve as ferramentas de Avaliação de Agentes que podem ajudá-lo a definir um bom resultado.

Criar um conjunto de avaliação

Para definir o que significa qualidade para um agente, você usa métricas para medir o desempenho do agente em um conjunto de avaliação. Consulte Definir "qualidade": Conjuntos de avaliação.

Com a Avaliação de agentes, você pode criar conjuntos de avaliação sintéticos e medir a qualidade executando avaliações. A ideia é partir dos fatos, como um conjunto de documentos, e "trabalhar para trás", usando esses fatos para gerar um conjunto de perguntas. Você pode condicionar as perguntas geradas fornecendo algumas diretrizes:

from databricks.agents.evals import generate_evals_df
import pandas as pd


databricks_docs_url = "https://raw.githubusercontent.com/databricks/genai-cookbook/refs/heads/main/quick_start_demo/chunked_databricks_docs_filtered.jsonl"
parsed_docs_df = pd.read_json(databricks_docs_url, lines=True)


agent_description = f"""
The agent is a RAG chatbot that answers questions about Databricks. Questions unrelated to Databricks are irrelevant.
"""
question_guidelines = f"""
# User personas
- A developer who is new to the Databricks platform
- An experienced, highly technical Data Scientist or Data Engineer


# Example questions
- what API lets me parallelize operations over rows of a delta table?
- Which cluster settings will give me the best performance when using Spark?


# Additional Guidelines
- Questions should be succinct, and human-like
"""


num_evals = 25
evals = generate_evals_df(
  docs=parsed_docs_df[
    :500
  ],  # Pass your docs. They should be in a Pandas or Spark DataFrame with columns `content STRING` and `doc_uri STRING`.
  num_evals=num_evals,  # How many synthetic evaluations to generate
  agent_description=agent_description,
  question_guidelines=question_guidelines,
)

As avaliações geradas incluem o seguinte:

• Um campo de solicitação que se parece com o ChatAgentRequest mencionado anteriormente:

  {"messages":[{"content":"What command must be run at the start of your workload to explicitly target the Workspace Model Registry if your workspace default catalog is in Unity Catalog and you use Databricks Runtime 13.3 LTS or above?","role":"user"}]}
  

• Uma lista de "conteúdo recuperado esperado". O esquema retriever foi definido com campos content e doc_uri.

  [{"content":"If your workspace’s [default catalog](https://docs.databricks.com/data-governance/unity-catalog/create-catalogs.html#view-the-current-default-catalog) is in Unity Catalog (rather than `hive_metastore`) and you are running a cluster using Databricks Runtime 13.3 LTS or above, models are automatically created in and loaded from the workspace default catalog, with no configuration required. To use the Workspace Model Registry in this case, you must explicitly target it by running `import mlflow; mlflow.set_registry_uri(\"databricks\")` at the start of your workload.","doc_uri":"https://docs.databricks.com/machine-learning/manage-model-lifecycle/workspace-model-registry.html"}]
  

• Uma lista de factos esperados. Quando você compara duas respostas, pode ser difícil encontrar pequenas diferenças entre elas. Os fatos esperados destilam o que separa uma resposta correta de uma resposta parcialmente correta de uma resposta incorreta e melhoram tanto a qualidade dos juízes de IA quanto a experiência das pessoas que trabalham no agente:

  ["The command must import the MLflow module.","The command must set the registry URI to \"databricks\"."]
  

• Um campo source_id que aqui é SYNTHETIC_FROM_DOC. À medida que você constrói conjuntos de avaliação mais completos, as amostras virão de várias fontes diferentes, então este campo as distingue.

Para saber mais sobre como criar conjuntos de avaliação, consulte Sintetizar conjuntos de avaliação.

Avaliar o agente usando juízes LLM

Avaliar manualmente o desempenho de um agente em tantos exemplos gerados não escalará bem. Em escala, usar LLMs como juízes é uma solução muito mais razoável. Para usar os juízes internos que estão disponíveis ao usar a Avaliação do Agente, use o seguinte código:

with mlflow.start_run(run_name="my_agent"):
  eval_results = mlflow.evaluate(
    data=evals,  # Your evaluation set
    model=model_info.model_uri,  # Logged agent from above
    model_type="databricks-agent",  # activate Mosaic AI Agent Evaluation
)

O agente simples marcou 68% no total. Seus resultados podem diferir aqui, dependendo da configuração que você usa. Executar um experimento para comparar três LLMs diferentes em termos de custo e qualidade é tão simples quanto alterar a configuração e reavaliar.

Considere alterar a configuração do modelo para usar um LLM diferente, um prompt do sistema ou uma configuração de temperatura.

Esses juízes podem ser personalizados para seguir as mesmas diretrizes que os especialistas humanos usariam para avaliar uma resposta. Para obter mais informações sobre juízes LLM, consulte juízes de IA integrados.

Com a Avaliação de agentes, você pode personalizar a maneira como mede a qualidade de um determinado agente usando métricas personalizadas. Você pode pensar na avaliação como um teste de integração e nas métricas individuais como testes de unidade. O exemplo a seguir usa uma métrica booleana para verificar se o agente usou a extração de palavra-chave e o retriever para uma determinada solicitação:

from databricks.agents.evals import metric

@metric
def uses_keywords_and_retriever(request, trace):
  retriever_spans = trace.search_spans(span_type="RETRIEVER")
  keyword_tool_spans = trace.search_spans(name=f"{CATALOG}__{SCHEMA}__tfidf_keywords")
  return len(keyword_tool_spans) > 0 and len(retriever_spans) > 0


# same evaluate as above, with the addition of 'extra_metrics'
with mlflow.start_run(run_name="my_agent"):
  eval_results = mlflow.evaluate(
    data=evals,  # Your evaluation set
    model=model_info.model_uri,  # Logged agent from above
    model_type="databricks-agent",  # activate Mosaic AI Agent Evaluation,
    extra_metrics=[uses_keywords_and_retriever],
  )

Observe que o agente nunca usa a extração de palavra-chave. Como você pode corrigir esse problema?

Implantar e monitorar o agente

Quando você estiver pronto para começar a testar seu agente com usuários reais, o Agent Framework fornece uma solução pronta para produção para atender o agente no Mosaic AI Model Serving.

A implantação de agentes no Model Serving oferece os seguintes benefícios:

• O Model Serving gerencia o dimensionamento automático, o registro, o controle de versão e o controle de acesso, permitindo que você se concentre no desenvolvimento de agentes de qualidade.
• Os especialistas no assunto podem usar o aplicativo de avaliações para interagir com o agente e fornecer feedback que pode ser incorporado ao seu monitoramento e avaliações.
• Você pode monitorar o agente executando avaliações no tráfego ao vivo. Embora o tráfego dos utilizadores não inclua os dados reais, os juízes do LLM (e a métrica personalizada que você criou) realizam uma avaliação não supervisionada.

O código a seguir implanta os agentes num endpoint de serviço. Para obter mais informações, consulte Implementar um agente para aplicação de IA generativa.

from databricks import agents
import mlflow

# Connect to the Unity Catalog model registry
mlflow.set_registry_uri("databricks-uc")

# Configure UC model location
UC_MODEL_NAME = f"{CATALOG}.{SCHEMA}.getting_started_agent"
# REPLACE WITH UC CATALOG/SCHEMA THAT YOU HAVE `CREATE MODEL` permissions in

# Register to Unity Catalog
uc_registered_model_info = mlflow.register_model(
  model_uri=model_info.model_uri, name=UC_MODEL_NAME
)
# Deploy to enable the review app and create an API endpoint
deployment_info = agents.deploy(
  model_name=UC_MODEL_NAME, model_version=uc_registered_model_info.version
)