Esercitazione: Costruire, valutare e implementare un agente di ricerca

Questa esercitazione illustra come creare un agente di intelligenza artificiale che usa insieme il recupero e gli strumenti.

Si tratta di un'esercitazione di livello intermedio che presuppone una certa familiarità con le nozioni di base della creazione di un agente in Databricks. Se sei nuovo nella creazione di agenti, consulta Introduzione agli agenti di intelligenza artificiale.

Il notebook di esempio include tutto il codice usato nell'esercitazione.

Questa esercitazione illustra alcune delle sfide principali della creazione di applicazioni di intelligenza artificiale generative:

• Semplificando l'esperienza di sviluppo per attività comuni, ad esempio la creazione di strumenti e l'esecuzione dell'agente di debug.
• Problemi operativi, ad esempio:
  • Configurazione dell'agente di rilevamento
  • Definizione di input e output in modo prevedibile
  • Gestione delle versioni delle dipendenze
  • Controllo della versione e distribuzione
• Misurazione e miglioramento della qualità e dell'affidabilità di un agente.

Per semplicità, questa esercitazione usa un approccio in memoria per abilitare la ricerca di parole chiave su un set di dati contenente la documentazione di Databricks in blocchi. Per un esempio più realistico che usa la ricerca vettoriale di Mosaic AI per indicizzare e cercare documenti in modo scalabile, consulta ResponsesAgent esempi.

Notebook di esempio

Questo notebook autonomo è progettato per farti lavorare rapidamente con gli agenti di Mosaic AI utilizzando un corpus di documenti di esempio. È pronto per l'esecuzione senza installazione o dati necessari.

Demo dell'agente di Intelligenza Artificiale Mosaic

Prendi il notebook

Creare un agente e strumenti

Mosaic AI Agent Framework supporta molti framework di creazione diversi. Questo esempio usa LangGraph per illustrare i concetti, ma questa non è un'esercitazione LangGraph.

Per esempi di altri framework supportati, vedere esempi ResponsesAgent.

Il primo passaggio consiste nel creare un agente. È necessario specificare un client LLM e un elenco di strumenti. Il pacchetto Python databricks-langchain include client compatibili con LangChain e LangGraph sia per i LLM di Databricks che per gli strumenti registrati in Unity Catalog.

L'endpoint deve essere un'API che richiama funzioni di un modello base o un modello esterno utilizzando l'AI Gateway. Consulta Modelli supportati.

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

Il codice seguente definisce una funzione che crea un agente dal modello e alcuni strumenti, che illustrano gli elementi interni di questo codice agente non rientrano nell'ambito di questa pagina. Per altre informazioni su come creare un agente LangGraph, vedere la documentazione di 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()

Definire gli strumenti dell'agente

Gli strumenti sono un concetto fondamentale per la creazione di agenti. Offrono la possibilità di integrare LLMs con codice definito dall'utente. Quando viene fornito un prompt e un elenco di strumenti, un LLM che chiama lo strumento genera gli argomenti per richiamare lo strumento. Per altre informazioni sugli strumenti e sull'uso con gli agenti di Mosaic AI, vedere strumenti dell'agente di intelligenza artificiale.

Il primo passaggio consiste nel creare uno strumento di estrazione di parole chiave basato su TF-IDF. Questo esempio usa scikit-learn e uno strumento catalogo Unity.

Il pacchetto databricks-langchain offre un modo pratico per usare gli strumenti del catalogo Unity. Il codice seguente illustra come implementare e registrare uno strumento di estrazione di parole chiave.

Nota

L'area di lavoro di Databricks include uno strumento predefinito, system.ai.python_exec, che è possibile usare per estendere gli agenti con la possibilità di eseguire script Python in un ambiente in modalità sandbox. Altri strumenti predefiniti utili includono connessioni esterne e funzioni di intelligenza artificiale .

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)

Ecco una spiegazione del codice precedente:

1. Crea un client che usa Unity Catalog nell'area di lavoro di Databricks come "registro" per creare e individuare gli strumenti.
2. Definisce una funzione Python che esegue l'estrazione di parole chiave TF-IDF.
3. Registra la funzione Python come funzione del catalogo Unity.

Questo flusso di lavoro risolve diversi problemi comuni. È ora disponibile un registro centrale per gli strumenti che, come altri oggetti nel catalogo unity, possono essere regolati. Ad esempio, se un'azienda ha un modo standard per calcolare il tasso di rendimento interno, è possibile definirla come funzione in Unity Catalog e concedere l'accesso a tutti gli utenti o gli agenti con il ruolo FinancialAnalyst.

Per rendere utilizzabile questo strumento da un agente LangChain, usare UCFunctionToolkit che crea una raccolta di strumenti da assegnare all'LLM per la selezione:

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

Il codice seguente illustra come testare lo strumento:

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

Il codice seguente crea un agente che usa lo strumento di estrazione delle parole chiave.

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

Nella traccia risultante è possibile vedere che l'LLM ha selezionato lo strumento.

Usare le tracce per eseguire il debug degli agenti

MLflow Tracing è uno strumento potente per il debug e l'osservazione di applicazioni di intelligenza artificiale generative, inclusi gli agenti. Acquisisce informazioni dettagliate sulle operazioni attraverso intervalli, che incapsulano segmenti di codice specifici e registrano input, output e dati di intervallo.

Per le librerie più popolari come LangChain, abilitare il tracciamento automatico con mlflow.langchain.autolog(). È anche possibile usare mlflow.start_span() per personalizzare una traccia. Ad esempio, è possibile aggiungere campi di valore dati personalizzati o etichettatura per l'osservabilità. Il codice eseguito nel contesto di tale intervallo viene associato ai campi definiti dall'utente. In questo esempio di TF-IDF in memoria, assegnagli un nome e un tipo di intervallo.

Per altre informazioni sulla traccia, vedere MLflow Tracing - GenAI observability (Traccia MLflow - Osservabilità genAI).

Nell'esempio seguente viene creato uno strumento retriever usando un semplice indice di TF-IDF in memoria. Illustra sia la registrazione automatica per le esecuzioni degli strumenti che il tracciamento delle operazioni personalizzato per un'osservabilità aggiuntiva:

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

Questo codice usa un tipo di intervallo speciale, RETRIEVER, che è riservato agli strumenti di recupero. Altre funzionalità dell'agente Mosaic AI (come l'AI Playground, l'interfaccia utente di revisione e la valutazione) utilizzano il tipo di intervallo RETRIEVER per mostrare i risultati del recupero.

Gli strumenti retriever richiedono di specificare il relativo schema per garantire la compatibilità con le funzionalità di Databricks downstream. Per altre informazioni su mlflow.models.set_retriever_schema, vedere Specificare schemi di recupero personalizzati.

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

Definire l'agente

Il passaggio successivo consiste nel valutare l'agente e prepararlo per la distribuzione. A livello generale, questo implica quanto segue:

1. Definire un'API prevedibile per l'agente usando una firma.
2. Aggiungere la configurazione del modello, semplificando la configurazione dei parametri.
3. Registrare il modello con le dipendenze che forniscono un ambiente riproducibile e consentono di configurarne l'autenticazione per altri servizi.

L'interfaccia ChatAgent MLflow semplifica la definizione degli input e degli output dell'agente. Per usarlo, definire l'agente come sottoclasse di ChatAgent, implementando l'inferenza non-streaming con la funzione predict e l'inferenza streaming con la funzione predict_stream.

ChatAgent è indipendente dalla scelta del framework di creazione dell'agente, consentendo di testare e usare facilmente framework e implementazioni dell'agente diversi. L'unico requisito consiste nell'implementare le interfacce predict e predict_stream.

La creazione dell'agente tramite ChatAgent offre numerosi vantaggi, tra cui:

• supporto per lo streaming dell'output
• cronologia completa dei messaggi relativi alla chiamata degli strumenti: restituzione di più messaggi, inclusi quelli intermedi relativi alla chiamata degli strumenti, per migliorare la qualità e la gestione delle conversazioni.
• Supporto per il sistema multi-agente
• integrazione delle funzionalità di Databricks: compatibilità pronta all'uso con AI Playground, Valutazione agente e Monitoraggio agente.
• interfacce di authoring tipizzate: scrivere codice dell'agente usando classi Python tipizzate, traendo vantaggio dall'IDE e dal completamento automatico nei notebook.

Per altre informazioni sulla creazione di un controllo ChatAgent , vedere Creare agenti di intelligenza artificiale nel codice.

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)

Nel codice seguente viene illustrato come usare il ChatAgent.

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

Configurare gli agenti con parametri

Agent Framework consente di controllare l'esecuzione dell'agente con parametri. Ciò significa che è possibile testare rapidamente diverse configurazioni dell'agente, ad esempio cambiare endpoint LLM o provare strumenti diversi senza modificare il codice sottostante.

Il codice seguente crea un dizionario di configurazione che imposta i parametri dell'agente durante l'inizializzazione del modello.

Per altri dettagli sulla parametrizzazione degli agenti, vedere Parametrizzare il codice per la distribuzione in ambienti diversi.

)

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

Registrare l'agente

Dopo aver definito l'agente, quest'ultimo è pronto per essere registrato. In MLflow, la registrazione di un agente significa salvare la configurazione dell'agente (incluse le dipendenze) in modo che possa essere usata per la valutazione e la distribuzione.

Nota

Quando si sviluppano agenti in un notebook, MLflow deduce le dipendenze dell'agente dall'ambiente notebook.

Per registrare un agente da un notebook, è possibile scrivere tutto il codice che definisce il modello in una singola cella, quindi usare il comando magic %%writefile per salvare la definizione dell'agente in un file:

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

Se l'agente richiede l'accesso a risorse esterne, ad esempio Unity Catalog per eseguire lo strumento di estrazione delle parole chiave, è necessario configurare l'autenticazione per l'agente in modo che possa accedere alle risorse quando viene distribuito.

Per semplificare l'autenticazione per le risorse di Databricks, abilitare pass-through di autenticazione automatica:

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

Per altre informazioni sugli agenti di registrazione, vedere registrazione basata su codice.

Valutare l'agente

Il passaggio successivo consiste nel valutare l'agente per verificare le prestazioni. La valutazione dell'agente è complessa e genera molte domande, ad esempio le seguenti:

• Quali sono le metriche corrette per valutare la qualità? Come considerare attendibili gli output di queste metriche?
• Devo valutare molte idee - come faccio a...
  • eseguire rapidamente la valutazione in modo che la maggior parte del tempo non venga impiegato in attesa?
  • confrontare rapidamente queste diverse versioni del mio agente per qualità, costo e latenza?
• Come posso identificare rapidamente la causa radice di eventuali problemi di qualità?

In qualità di data scientist o sviluppatore, si potrebbe non essere l'esperto effettivo in materia. Nella parte restante di questa sezione vengono descritti gli strumenti di valutazione dell'agente che consentono di definire un output ottimale.

Creare un set di valutazione

Per definire cosa significhi qualità per un agente, si utilizzano le metriche per misurare le prestazioni dell'agente in un set di valutazione. Consultare Definizione di "qualità": set di valutazione.

Con Agent Evaluation è possibile creare set di valutazione sintetici e misurare la qualità eseguendo valutazioni. L'idea è iniziare dai fatti, come un insieme di documenti, e "lavorare indietro" usando questi fatti per generare una serie di domande. È possibile modificare le domande generate fornendo alcune linee guida:

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

Le valutazioni generate includono quanto segue:

• Campo della richiesta simile al ChatAgentRequest indicato in precedenza:

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

• Elenco di "contenuto recuperato previsto". Lo schema del retriever è stato definito con campi 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"}]
  

• Elenco dei fatti previsti. Quando si confrontano due risposte, può essere difficile trovare piccole differenze tra di esse. I fatti previsti separano una risposta corretta da una risposta parzialmente corretta da una risposta errata e migliorano sia la qualità dei giudici di intelligenza artificiale che l'esperienza delle persone che lavorano sull'agente:

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

• Il campo source_id che qui è SYNTHETIC_FROM_DOC. Man mano che si creano set di valutazione più completi, gli esempi provengono da diverse origini, quindi questo campo li distingue.

Per altre informazioni sulla creazione di set di valutazione, vedere Sintetizzare i set di valutazione.

Valutare l'agente usando i giudici LLM

La valutazione manuale delle prestazioni di un agente su così tanti esempi generati non funziona correttamente. Su larga scala, l'uso di LLMs come giudici è una soluzione molto più ragionevole. Per usare i giudici predefiniti disponibili quando si usa Agent Evaluation, usare il codice seguente:

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
)

Il punteggio complessivo ottenuto dall'agente semplice è stato del 68%. I risultati possono variare in questo caso a seconda della configurazione usata. Eseguire un esperimento per confrontare tre diversi LLM in termini di costi e qualità è facile come modificare la configurazione e rivalutare.

Valutare la possibilità di modificare la configurazione del modello in modo da usare un'impostazione LLM, richiesta di sistema o temperatura diversa.

Questi giudici possono essere personalizzati per seguire le stesse linee guida usate dagli esperti umani per valutare una risposta. Per altre informazioni sui giudici LLM, vedere Giudici di intelligenza artificiale predefiniti (MLflow 2).For more information about LLM judges, see Built-in AI judges (MLflow 2).

Con Agent Evaluation è possibile personalizzare il modo in cui si misura la qualità di un determinato agente usando metriche personalizzate. È possibile considerare la valutazione come un test di integrazione e le singole metriche come unit test. L'esempio seguente usa una metrica booleana per verificare se l'agente usa sia l'estrazione di parole chiave che il retriever per una determinata richiesta:

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

Si noti che l'agente non usa mai l'estrazione di parole chiave. Come è possibile risolvere questo problema?

Distribuire e monitorare l'agente

Quando si è pronti per iniziare a testare l'agente con utenti reali, Agent Framework offre una soluzione pronta per la produzione per la gestione dell'agente in Mosaic AI Model Serving.

La distribuzione degli agenti in Model Serving offre i vantaggi seguenti:

• Model Serving gestisce la scalabilità automatica, la registrazione, il controllo della versione e il controllo di accesso, consentendo di concentrarsi sullo sviluppo di agenti di qualità.
• Gli esperti in materia possono usare l'app di revisione per interagire con l'agente e fornire commenti e suggerimenti che possono essere incorporati nel monitoraggio e nelle valutazioni.
• È possibile monitorare l'agente eseguendo valutazioni sul traffico live. Anche se il traffico utente non include la verità sul terreno, i giudici LLM (e la metrica personalizzata creata) eseguono una valutazione non supervisionata.

Il codice seguente distribuisce gli agenti in un endpoint di gestione. Per altre informazioni, vedere Distribuire un agente per le applicazioni di intelligenza artificiale generative.

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
)