Tutorial: Compilación, evaluación e implementación de un agente de recuperación

Este tutorial le guía a través de la compilación de un agente de la inteligencia artificial que utiliza la recuperación y las herramientas de forma conjunta.

Este es un tutorial de nivel intermedio que supone cierta familiaridad con los conceptos básicos de la creación de un agente en Databricks. Si no está familiarizado con la creación de agentes, consulte Introducción a los agentes de IA.

El cuaderno de ejemplo incluye todo el código usado en el tutorial.

En este tutorial se tratan algunos de los principales desafíos de la creación de aplicaciones de IA generativas:

• Optimización de la experiencia de desarrollo para tareas comunes, como la creación de herramientas y la ejecución del agente de depuración.
• Desafíos operativos como:
  • Configuración del agente de seguimiento
  • Definición de entradas y salidas de forma predecible
  • Administración de versiones de dependencias
  • Control de versiones e implementación
• Medición y mejora de la calidad y confiabilidad de un agente.

Para simplificar, en este tutorial se usa un enfoque en memoria para habilitar la búsqueda de palabras clave en un conjunto de datos que contiene documentación de Databricks fragmentada. Para obtener un ejemplo más realista que use el vector de búsqueda de Mosaic AI para indexar y buscar documentos escalares, consulte ChatAgent ejemplos.

Cuaderno de ejemplo de

Este cuaderno independiente está diseñado para ayudarle a trabajar rápidamente con agentes de Mosaic AI mediante un corpus de documento de ejemplo. Está listo para ejecutarse sin ningún programa de instalación o datos necesarios.

Demostración del agente Mosaic AI

Obtener el cuaderno

Creación de un agente y herramientas

Mosaic AI Agent Framework admite muchos marcos de creación diferentes. En este ejemplo se usa LangGraph para ilustrar conceptos, pero no se trata de un tutorial de LangGraph.

Para obtener ejemplos de otros marcos admitidos, vea ChatAgent ejemplos.

El primer paso es crear un agente. Debe especificar un cliente LLM y una lista de herramientas. El paquete de Python de databricks-langchain incluye clientes compatibles con LangChain y LangGraph para máquinas virtuales y herramientas de Databricks registradas en el catálogo de Unity.

El punto final debe ser una API de modelo de base que llame a una función o un modelo externo que utilice AI Gateway. Consulte Modelos admitidos.

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

El código siguiente define una función que crea un agente a partir del modelo y algunas herramientas, en la que se describen los elementos internos de este código de agente está fuera del ámbito de esta guía. Para obtener más información sobre cómo crear un agente de LangGraph, consulte ladocumentación de 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 herramientas de agente

Las herramientas son un concepto fundamental para la creación de agentes. Proporcionan la capacidad de integrar LAS VM con código definido por el usuario. Cuando se proporciona un mensaje y una lista de herramientas, un LLM que llama a herramientas genera los argumentos para invocar la herramienta. Para obtener más información sobre las herramientas y su uso con agentes de Mosaic AI, consulte herramientas del agente de IA.

El primer paso es crear una herramienta de extracción de palabras clave basada en TF-IDF. En este ejemplo se usa scikit-learn y una herramienta de Unity Catalog.

El paquete databricks-langchain proporciona una manera cómoda de trabajar con herramientas de Unity Catalog. En el código siguiente se muestra cómo implementar y registrar una herramienta extractora de palabras clave.

Nota:

El área de trabajo de Databricks tiene una herramienta integrada, system.ai.python_exec, que puede usar para ampliar los agentes con la capacidad de ejecutar scripts de Python en un entorno de ejecución de espacio aislado. Otras herramientas integradas útiles incluyen Conexiones externas y Funciones de IA.

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)

Esta es una explicación del código anterior:

1. Crea un cliente que usa Unity Catalog en el área de trabajo de Databricks como un "registro" para crear y detectar herramientas.
2. Define una función de Python que realiza la extracción de palabras clave TF-IDF.
3. Registra la función de Python como una función de catálogo de Unity.

Este flujo de trabajo resuelve varios problemas comunes. Ahora tiene un registro central para herramientas que, al igual que otros objetos de Unity Catalog, se pueden gobernar. Por ejemplo, si una empresa tiene una manera estándar de calcular la tasa interna de retorno, puede definirla como una función en Unity Catalog y conceder acceso a todos los usuarios o agentes con el rol FinancialAnalyst.

Para que un agente de LangChain pueda usar esta herramienta, use UCFunctionToolkit, que crea una colección de herramientas que se van a proporcionar al LLM para su selección:

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

En el código siguiente se muestra cómo probar la herramienta:

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

El código siguiente crea un agente que usa la herramienta de extracción de palabras clave.

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'?"}]})

En el seguimiento resultante, puede ver que LLM seleccionó la herramienta.

Usar seguimientos para depurar agentes

El seguimiento de MLflow es una herramienta eficaz para depurar y observar aplicaciones de IA generativas, incluidos los agentes. Captura información detallada de ejecución a través de intervalos, que encapsulan segmentos de código específicos y registran entradas, salidas y datos de tiempo.

Para bibliotecas populares como LangChain, habilite el seguimiento automático con mlflow.langchain.autolog(). También puede usar mlflow.start_span() para personalizar un seguimiento. Por ejemplo, podría agregar campos de valor de datos personalizados o etiquetados para la observabilidad. El código que se ejecuta en el contexto de ese intervalo se asocia con los campos que defina. En este ejemplo de TF-IDF en memoria, asígnele un nombre y un tipo de intervalo.

Para más información sobre el seguimiento, consulte Seguimiento de MLflow: observabilidad de IA generativa.

En el ejemplo siguiente se crea una herramienta de recuperación mediante un índice TF-IDF sencillo en memoria. Muestra el registro automático para las ejecuciones de herramientas y el seguimiento de intervalos personalizados para mayor observabilidad:

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 un tipo de intervalo especial, RETRIEVER, que está reservado para las herramientas del recuperador. Otras características del agente Mosaic AI (como AI Playground, la interfaz de usuario de revisión y la evaluación) utilizan el tipo de intervalo RETRIEVER para mostrar los resultados recuperación.

Las herramientas del recuperador requieren que especifique su esquema para garantizar la compatibilidad con las características de Databricks de nivel inferior. Para obtener más información sobre mlflow.models.set_retriever_schema, consulte Especificar esquemas de recuperador personalizados.

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?")]})

Definición del agente

El siguiente paso es evaluar el agente y prepararlo para la implementación. En un nivel alto, esto implica lo siguiente:

1. Defina una API predecible para el agente mediante una firma.
2. Agregue la configuración del modelo, lo que facilita la configuración de parámetros.
3. Registre el modelo con dependencias que le proporcionen un entorno reproducible y le permita configurar su autenticación en otros servicios.

La interfaz MLflow ChatAgent simplifica la definición de entradas y salidas del agente. Para usarlo, defina el agente como una subclase de ChatAgent, implementando la inferencia sin streaming con la funciónpredict y la inferencia de streaming con la función predict_stream.

ChatAgent es independiente de su elección del marco de creación de agentes, lo que le permite probar y usar fácilmente diferentes marcos e implementaciones de agente: el único requisito es implementar las interfaces de predict y predict_stream.

La creación del agente mediante ChatAgent proporciona una número de ventajas, entre las que se incluyen:

• Compatibilidad con la salida de streaming
• Historial completo de mensajes de llamada a herramientas: devuelve varios mensajes, incluidos los mensajes intermedios de llamada a herramientas, para mejorar la calidad y la administración de conversaciones.
• soporte para sistema multiagente
• Integración de características de Databricks: compatibilidad integrada con AI Playground, Evaluación del agente y Supervisión del agente.
• Interfaces de creación con tipo: escriba código de agente mediante clases de Python con tipo, que se benefician del IDE y la acción de autocompletar para los cuadernos.

Para obtener más información sobre la creación de ChatAgent, consulte Uso ChatAgent para crear 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)

En el código siguiente se muestra cómo usar el ChatAgent.

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

Configuración de agentes con parámetros

Agent Framework permite controlar la ejecución del agente con parámetros. Esto significa que puede probar rápidamente diferentes configuraciones de agente, como cambiar los puntos de conexión de LLM o probar herramientas diferentes sin cambiar el código subyacente.

El código siguiente crea un diccionario de configuración que establece los parámetros del agente al inicializar el modelo.

Para obtener más información sobre la parametrización de agentes, consulte Parametrizar el código de agente para su implementación en distintos entornos.

)

from mlflow.models import ModelConfig

baseline_config = {
  "endpoint_name": "databricks-meta-llama-3-3-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

Registro del agente

Después de definir el agente, ya está listo para registrarse. En MLflow, el registro de un agente significa guardar la configuración del agente (incluidas las dependencias) para que se pueda usar para la evaluación y la implementación.

Nota:

Al desarrollar agentes en un cuaderno, MLflow deduce las dependencias del agente desde el entorno del cuaderno.

Para registrar un agente desde un cuaderno, puede escribir todo el código que define el modelo en una sola celda y a continuación, usar el comando %%writefile magic para guardar la definición del agente en un archivo:

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

Si el agente requiere acceso a recursos externos, como Unity Catalog para ejecutar la herramienta de extracción de palabras clave, debe configurar la autenticación para el agente para que pueda acceder a los recursos cuando se implemente.

Para simplificar la autenticación de los recursos de Databricks, habilite paso a través de la autenticación 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 más información acerca de los agentes de registro, consulte Registro basado en código.

Evaluación del agente

El siguiente paso es evaluar el agente para ver cómo funciona. La evaluación del agente es complicada y plantea muchas preguntas, como las siguientes:

• ¿Cuáles son las métricas adecuadas para evaluar la calidad? ¿Cómo confío en las salidas de estas métricas?
• Necesito evaluar muchas ideas: cómo puedo...
  • ejecutar la evaluación rápidamente, por lo que no tengo que dedicar casi todo mi tiempo a esperar?
  • comparar rápidamente estas diferentes versiones de mi agente en cuanto a calidad, costo y latencia?
• ¿Cómo puedo identificar de forma rápida la causa principal de cualquier problema de calidad?

Como científico de datos o desarrollador, es posible que no sea el experto en la materia real. En el resto de esta sección se describen las herramientas de evaluación del agente que pueden ayudarle a definir una buena salida.

Creación de un conjunto de evaluación

Para definir qué significa calidad para un agente, use métricas para medir el rendimiento del agente en un conjunto de evaluación. Consulte Definir "calidad": Conjuntos de evaluación.

Con la Evaluación del agente, puede crear conjuntos de evaluación sintéticos y medir la calidad mediante la ejecución de evaluaciones. La idea es empezar a partir de los hechos, como un conjunto de documentos, y "trabajar hacia atrás" usando esos hechos para generar un conjunto de preguntas. Puede condicionar las preguntas que se generan proporcionando algunas directrices:

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

Las evaluaciones generadas incluyen lo siguiente:

• Campo de solicitud similar al 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"}]}
  

• Lista de "contenido recuperado esperado". El esquema del recuperador se definió con los campos content y 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"}]
  

• Una lista de hechos esperados. Al comparar dos respuestas, puede ser difícil encontrar pequeñas diferencias entre ellas. Los hechos esperados destilan lo que separa una respuesta correcta de una respuesta parcialmente correcta de una respuesta incorrecta y mejoran tanto la calidad de los jueces de inteligencia artificial como la experiencia de las personas que trabajan en el agente:

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

• Campo de source_id que aquí es SYNTHETIC_FROM_DOC. A medida que compila conjuntos de evaluación más completos, los ejemplos proceden de varios orígenes diferentes, por lo que este campo los distingue.

Para más información sobre la creación de conjuntos de evaluación, consulte Síntesis de conjuntos de evaluación.

Evaluación del agente mediante jueces LLM

Evaluar manualmente el rendimiento de un agente en tantos ejemplos generados no se escalará bien. A escala, el uso de LLM como jueces es una solución mucho más razonable. Para usar los jueces integrados que están disponibles al usar La evaluación del agente, use el código siguiente:

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
)

El agente simple puntuó el 68 % en general. Los resultados pueden diferir aquí en función de la configuración que use. Ejecutar un experimento para comparar tres LLM diferentes para el costo y la calidad es tan sencillo como cambiar la configuración y volver a evaluar.

Considere la posibilidad de cambiar la configuración del modelo para usar una configuración de LLM, de sistema o de temperatura diferente.

Estos jueces se pueden personalizar para seguir las mismas directrices que los expertos humanos usarían para evaluar una respuesta. Para obtener más información sobre los jueces de LLM, consulte Jueces de IA integrados (MLflow 2).

Con la evaluación del agente, puede personalizar la forma en que mide la calidad de un agente determinado mediante métricas personalizadas. Puede considerar la evaluación como una prueba de integración y métricas individuales como pruebas unitarias. En el ejemplo siguiente se usa una métrica booleana para comprobar si el agente usó la extracción de palabras clave y el recuperador para una solicitud determinada:

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],
  )

Tenga en cuenta que el agente nunca usa la extracción de palabras clave. ¿Cómo podría solucionar este problema?

Implementación y supervisión del agente

Cuando esté listo para empezar a probar el agente con usuarios reales, Agent Framework proporciona una solución lista para producción para servir al agente en Mosaic AI Model Serving.

La implementación de agentes en Model Serving proporciona las siguientes ventajas:

• Model Serving administra el escalado automático, el registro, el control de versiones y el control de acceso, lo que le permite centrarse en el desarrollo de agentes de calidad.
• Los expertos en la materia pueden usar la aplicación de revisión para interactuar con el agente y proporcionar comentarios que se pueden incorporar a la supervisión y las evaluaciones.
• Puede supervisar el agente mediante la ejecución de evaluaciones en el tráfico activo. Aunque el tráfico de usuario no incluirá la verdad del suelo, los jueces de LLM (y la métrica personalizada que ha creado) realizan una evaluación no supervisada.

El código siguiente implementa los agentes en un punto de conexión de servicio. Para más información, consulte Implementación de un agente para aplicaciones de IA generativas.

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
)