Tutoriel : Générer, évaluer et déployer un agent de récupération

Ce tutoriel vous guide tout au long de la création d’un agent IA qui utilise ensemble la récupération et les outils.

Il s’agit d’un didacticiel de niveau intermédiaire qui part du principe de la création d’un agent sur Databricks. Si vous êtes nouveau dans la création d’agents, consultez Commencer avec les agents IA.

L’exemple de notebook inclut tout le code utilisé dans le didacticiel.

Ce tutoriel aborde certains des principaux défis liés à la création d’applications d’IA génératives :

• Rationalisation de l’expérience de développement pour les tâches courantes telles que la création d’outils et le débogage de l’exécution de l’agent.
• Défis opérationnels tels que :
  • Configuration de l’agent de suivi
  • Définition d’entrées et de sorties de manière prévisible
  • Gestion des versions des dépendances
  • Contrôle de version et déploiement
• Mesurer et améliorer la qualité et la fiabilité d’un agent.

Par souci de simplicité, ce tutoriel utilise une approche en mémoire pour activer la recherche par mot clé sur un jeu de données contenant la documentation Databricks segmentée. Pour obtenir un exemple plus réaliste qui utilise Mosaic AI Vector Search pour indexer et rechercher des documents de manière scalable, consultez ResponsesAgent des exemples.

Exemple de bloc-notes

Ce notebook autonome est conçu pour vous aider rapidement à utiliser des agents d’IA Mosaïque à l’aide d’un exemple de corpus de documents. Il est prêt à s’exécuter sans configuration ni données requises.

Démonstration de l’agent Mosaic AI

Obtenir le notebook

Créer un agent et des outils

Mosaïque AI Agent Framework prend en charge de nombreux frameworks de création différents. Cet exemple utilise LangGraph pour illustrer les concepts, mais ce n’est pas un didacticiel LangGraph.

Pour obtenir des exemples d’autres frameworks pris en charge, consultez ResponsesAgent des exemples.

La première étape consiste à créer un agent. Vous devez spécifier un client LLM et une liste d’outils. Le databricks-langchain package Python inclut des clients compatibles avec LangChain et LangGraph pour les modèles de langage volumineux (LLM) de Databricks et les outils enregistrés dans le catalogue Unity.

Le point de terminaison doit être une API Foundation Model pour l'appel de fonction ou un modèle externe utilisant la passerelle IA. Consultez Modèles pris en charge.

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

Le code suivant définit une fonction qui crée un agent à partir du modèle et de certains outils, en discutant des éléments internes de ce code d’agent en dehors de l’étendue de cette page. Pour plus d’informations sur la création d’un agent LangGraph, consultez la documentation 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()

Définir des outils d’agent

Les outils sont un concept fondamental pour la création d’agents. Ils permettent d’intégrer des modèles de langage volumineux (LLM) à du code défini par des humains. Lorsque vous fournissez une invite et une liste d’outils, un LLM qui invoque des outils génère les arguments nécessaires pour utiliser l’outil. Pour plus d’informations sur les outils et leur utilisation avec des agents d’IA Mosaïque, consultez outils de l’agent IA.

La première étape consiste à créer un outil d’extraction de mot clé basé sur TF-IDF. Cet exemple utilise scikit-learn et un outil de catalogue Unity.

Le databricks-langchain package offre un moyen pratique d’utiliser les outils de catalogue Unity. Le code suivant montre comment implémenter et inscrire un outil d’extracteur de mots clés.

Remarque

L’espace de travail Databricks dispose d’un outil intégré, system.ai.python_execque vous pouvez utiliser pour étendre les agents avec la possibilité d’exécuter des scripts Python dans un environnement bac à sable (sandbox). D’autres outils intégrés utiles incluent des connexions externes et des fonctions 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)

Voici une explication du code ci-dessus :

1. Crée un client qui utilise Unity Catalog dans l’espace de travail Databricks en tant que « registre » pour créer et découvrir des outils.
2. Définit une fonction Python qui effectue l'extraction de mots clés TF-IDF.
3. Inscrit la fonction Python en tant que fonction catalogue Unity.

Ce flux de travail résout plusieurs problèmes courants. Vous disposez maintenant d’un registre central pour les outils qui, comme d’autres objets du catalogue Unity, peuvent être régis. Par exemple, si une entreprise a un moyen standard de calculer le taux de retour interne, vous pouvez le définir en tant que fonction dans le catalogue Unity et accorder l’accès à tous les utilisateurs ou agents ayant le FinancialAnalyst rôle.

Pour rendre cet outil utilisable par un agent LangChain, utilisez l’UCFunctionToolkit qui crée une collection d’outils à donner au LLM pour la sélection :

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

Le code suivant montre comment tester l’outil :

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

Le code suivant crée un agent qui utilise l’outil d’extraction de mot clé.

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

Dans l'entrée de suivi obtenue, vous pouvez voir que le LLM a sélectionné l’outil.

Utiliser des entrées de suivi pour déboguer des agents

Le tracé MLflow est un outil puissant pour le débogage et l’observation des applications d'IA génératives, y compris les agents. Elle capture des informations détaillées sur les opérations via des spans, qui encapsulent des segments de code spécifiques et enregistrent des entrées, des sorties et des données de chronométrage.

Pour les bibliothèques populaires comme LangChain, activez le suivi automatique avec mlflow.langchain.autolog(). Vous pouvez également utiliser mlflow.start_span() pour personnaliser une trace. Par exemple, vous pouvez ajouter des champs de valeur de données personnalisés ou un étiquetage pour l’observabilité. Code qui s’exécute dans le contexte de cette étendue est associé aux champs que vous définissez. Dans cet exemple en mémoire TF-IDF, donnez-lui un nom et un type d’étendue.

Pour en savoir plus sur le suivi, consultez l’observabilité MLflow Tracing - GenAI.

L’exemple suivant crée un outil de récupération à l’aide d’un index simple en mémoire TF-IDF. Il démontre à la fois la journalisation automatique pour les exécutions d’outils et le traçage personnalisé des étendues pour une observabilité supplémentaire :

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

Ce code utilise un type d’étendue spécial, RETRIEVERqui est réservé aux outils de récupération. D’autres fonctionnalités d’agent de Mosaic AI (comme AI Playground, l'interface de révision utilisateur et l’évaluation) utilisent le RETRIEVER type de portée pour afficher les résultats de récupération.

Les outils retriever vous obligent à spécifier leur schéma pour garantir la compatibilité avec les fonctionnalités Databricks en aval. Pour plus d’informations sur mlflow.models.set_retriever_schema, consultez Spécifier des schémas de récupérateur personnalisés.

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

Définir l’agent

L’étape suivante consiste à évaluer l’agent et à le préparer pour le déploiement. À un niveau élevé, cela implique les éléments suivants :

1. Définissez une API prévisible pour l’agent à l’aide d’une signature.
2. Ajoutez une configuration de modèle, ce qui facilite la configuration des paramètres.
3. Journalisez le modèle avec des dépendances qui lui donnent un environnement reproductible et vous permettent de configurer son authentification auprès d’autres services.

L’interface MLflow ChatAgent simplifie la définition des entrées et sorties de l’agent. Pour l’utiliser, définissez votre agent comme une sous-classe de ChatAgent, en implémentant l’inférence sans diffusion en continu avec la fonction predict et l’inférence de diffusion en continu avec la fonction predict_stream.

ChatAgent est indépendant de votre choix d’infrastructure de création d’agent, ce qui vous permet de tester et d’utiliser facilement différents frameworks et implémentations d’agent - la seule exigence est d’implémenter les interfaces predict et predict_stream.

La création de votre agent à l’aide de ChatAgent offre un certain nombre d'avantages, notamment :

• Prise en charge des sorties en flux continu
• Historique complet des messages appelant les outils : retournez plusieurs messages, y compris les messages d’appel intermédiaires, pour améliorer la qualité et la gestion des conversations.
• Support du système multi-agent
• Intégration des fonctionnalités Databricks : Compatibilité prête à l’emploi avec AI Playground, Agent Evaluation et Agent Monitoring.
• Interfaces de développement typées: écrire du code d'agent à l’aide de classes Python typées, en bénéficiant de l’auto-complétion de l’IDE et du notebook.

Pour plus d’informations sur l’écriture d’un ChatAgent consultez Auteur des agents IA dans le code.

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)

Le code suivant montre comment utiliser le ChatAgent.

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

Configurer des agents avec des paramètres

Agent Framework vous permet de contrôler l’exécution de l’agent avec des paramètres. Cela signifie que vous pouvez tester rapidement différentes configurations d’agent, comme changer de point de terminaison LLM ou essayer différents outils sans modifier le code sous-jacent.

Le code suivant crée un dictionnaire de configuration qui définit les paramètres de l’agent lors de l’initialisation du modèle.

Pour plus d’informations sur le paramétrage des agents, consultez Parametrize code pour le déploiement dans les environnements.

)

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

Enregistrer l'agent

Après avoir défini l’agent, il est maintenant prêt à être enregistré. Dans MLflow, la journalisation d’un agent signifie enregistrer la configuration de l’agent (y compris les dépendances) afin qu’elle puisse être utilisée pour l’évaluation et le déploiement.

Remarque

Lors du développement d’agents dans un notebook, MLflow déduit les dépendances de l’agent à partir de l’environnement de notebook.

Pour enregistrer un agent à partir d’un notebook, vous pouvez écrire tout le code qui définit le modèle dans une seule cellule, puis utiliser la commande magic pour enregistrer la %%writefile définition de l’agent dans un fichier :

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

Si l’agent a besoin d’accéder à des ressources externes, comme Unity Catalog pour exécuter l’outil d’extraction de mot clé, vous devez configurer l’authentification pour l’agent afin qu’il puisse accéder aux ressources lorsqu’il est déployé.

Pour simplifier l’authentification pour les ressources Databricks, activez la passe directe d’authentification automatique :

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

Pour en savoir plus sur les agents de journalisation, consultez journalisation basée sur le code.

Évaluer l’agent

L’étape suivante consiste à évaluer l’agent pour voir comment il s’exécute. L’évaluation de l’agent est difficile et soulève de nombreuses questions, telles que les suivantes :

• Quelles sont les mesures appropriées pour évaluer la qualité ? Comment faire confiance aux sorties de ces métriques ?
• J’ai besoin d’évaluer de nombreuses idées - comment faire...
  • exécuter l'évaluation rapidement afin que je ne passe pas la plupart de mon temps à attendre ?
  • comparer rapidement ces différentes versions de mon agent sur la qualité, le coût et la latence ?
• Comment identifier rapidement la cause racine des problèmes de qualité ?

En tant que scientifique ou développeur de données, vous n’êtes peut-être pas l’expert en matière réelle. Le reste de cette section décrit les outils d'évaluation des agents qui peuvent vous permettre de définir un bon résultat.

Créer un ensemble d'évaluation

Pour définir ce que signifie la qualité d’un agent, vous utilisez des métriques pour mesurer les performances de l’agent sur un jeu d’évaluation. Voir Définir « qualité » : Jeux d’évaluation.

Avec l’évaluation de l’agent, vous pouvez créer des jeux d’évaluation synthétiques et mesurer la qualité en exécutant des évaluations. L’idée est de commencer par les faits, comme un ensemble de documents, et de « revenir en arrière » en utilisant ces faits pour générer un ensemble de questions. Vous pouvez conditionner les questions générées en fournissant des instructions :

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

Les évaluations générées sont les suivantes :

• Champ de requête qui ressemble à celui ChatAgentRequest mentionné précédemment :

  {"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"}]}
  

• Liste de « contenu récupéré attendu ». Le schéma du récupérateur a été défini avec les champs content et 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"}]
  

• Liste des faits attendus. Lorsque vous comparez deux réponses, il peut être difficile de trouver de petites différences entre elles. Les faits anticipés distillent ce qui sépare une réponse correcte d’une réponse partiellement correcte d’une réponse incorrecte, et améliorent à la fois la qualité des juges d'IA ainsi que l’expérience des personnes travaillant sur l’agent.

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

• Ici, le champ source_id est SYNTHETIC_FROM_DOC. À mesure que vous générez des jeux d’évaluation plus complets, les exemples proviennent de différentes sources, de sorte que ce champ les distingue.

Pour en savoir plus sur la création de jeux d’évaluation, consultez Synthétiser les jeux d’évaluation.

Évaluer l’agent à l’aide de juges LLM

L’évaluation manuelle des performances d’un agent sur tant d’exemples générés n’est pas correctement mise à l’échelle. À grande échelle, l’utilisation de modèles de langage volumineux (LLM) en tant que juges est une solution beaucoup plus raisonnable. Pour utiliser les juges intégrés disponibles lors de l’utilisation de l’évaluation de l’agent, utilisez le code suivant :

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
)

L’agent simple a affiché un score de 68 % au total. Vos résultats peuvent différer ici en fonction de la configuration que vous utilisez. L’exécution d’une expérience pour comparer trois llMs différents pour les coûts et la qualité est aussi simple que de modifier la configuration et de réévaluer.

Envisagez de modifier la configuration du modèle pour utiliser un autre paramètre LLM, d’invite système ou de température.

Ces juges peuvent être personnalisés pour suivre les mêmes lignes directrices que les experts humains utiliseraient pour évaluer une réponse. Pour plus d’informations sur les juges LLM, consultez les juges IA intégrés (MLflow 2).

Avec l’évaluation de l’agent, vous pouvez personnaliser la façon dont vous mesurez la qualité d’un agent particulier à l’aide de métriques personnalisées. Vous pouvez considérer l’évaluation comme un test d’intégration et des métriques individuelles en tant que tests unitaires. L’exemple suivant utilise une métrique booléenne pour vérifier si l’agent a utilisé à la fois l’extraction de mots clés et le récupérateur pour une requête donnée :

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

Notez que l’agent n’utilise jamais l’extraction de mot clé. Comment résoudre ce problème ?

Déployer et surveiller l’agent

Lorsque vous êtes prêt à commencer à tester votre agent avec des utilisateurs réels, Agent Framework fournit une solution prête pour la production pour servir l’agent sur Mosaïque AI Model Service.

Le déploiement d’agents sur Model Service offre les avantages suivants :

• Model Service gère la mise à l’échelle automatique, la journalisation, le contrôle de version et le contrôle d’accès, ce qui vous permet de vous concentrer sur le développement d’agents de qualité.
• Les experts en matière peuvent utiliser l’application de révision pour interagir avec l’agent et fournir des commentaires qui peuvent être incorporés dans vos analyses et évaluations.
• Vous pouvez surveiller l’agent en exécutant des évaluations sur le trafic en direct. Bien que le trafic utilisateur n’inclut pas la vérité de base, les juges LLM (et la métrique personnalisée que vous avez créée) effectuent une évaluation non supervisée.

Le code suivant déploie les agents sur un point de terminaison de service. Pour plus d’informations, consultez Déployer un agent pour les applications IA génératives.

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
)