Zelfstudie: Een ophaalagent bouwen, evalueren en implementeren

In deze tutorial wordt u stapsgewijs begeleid bij het bouwen van een AI-agent die zowel informatieherwinning als hulpprogramma's gebruikt.

Dit is een zelfstudie op tussenliggend niveau die ervan uitgaat dat u bekend bent met de basisprincipes van het bouwen van een agent op Databricks. Zie Aan de slag met AI-agents als u nieuw bent in het bouwen van agents.

Het voorbeeldnotebook bevat alle code die in de zelfstudie wordt gebruikt.

In deze zelfstudie worden enkele van de belangrijkste uitdagingen besproken voor het bouwen van generatieve AI-toepassingen:

• Stroomlijn de ontwikkelervaring voor veelvoorkomende taken, zoals het maken van hulpprogramma's en het opsporen van fouten in agentuitvoering.
• Operationele uitdagingen zoals:
  • Agentconfiguratie bijhouden
  • Invoer en uitvoer op een voorspelbare manier definiëren
  • Versies van afhankelijkheden beheren
  • Versiebeheer en implementatie
• De kwaliteit en betrouwbaarheid van een agent meten en verbeteren.

Voor het gemak maakt deze zelfstudie gebruik van een in-memory benadering om trefwoordzoekopdrachten mogelijk te maken voor een gegevensset met gesegmenteerde Databricks-documentatie. Zie ResponsesAgent voorbeeldenvoor een realistischer voorbeeld waarin Mozaïek AI Vector Search wordt gebruikt voor schaalbare index- en zoekdocumenten.

voorbeeldnotitieblok

Dit zelfstandige notebook is ontworpen om u snel te laten werken met Mosaic AI-agents met behulp van een voorbeelddocument. Het is klaar om te worden uitgevoerd zonder dat installatie of gegevens vereist zijn.

Demo van Mozaïek AI-agent

Notitieboek ophalen

Een agent en hulpprogramma's maken

Mosaic AI Agent Framework ondersteunt veel verschillende ontwerpframeworks. In dit voorbeeld wordt LangGraph gebruikt om concepten te illustreren, maar dit is geen LangGraph-zelfstudie.

Zie ResponsesAgent voorbeeldenvoor voorbeelden van andere ondersteunde frameworks.

De eerste stap is het maken van een agent. U moet een LLM-client en een lijst met hulpprogramma's opgeven. Het python-pakket databricks-langchain bevat LangChain- en LangGraph-compatibele clients voor zowel Databricks LLMs als hulpprogramma's die zijn geregistreerd in Unity Catalog.

Het eindpunt moet een functie-aanroepende Foundation Model-API of extern model zijn met behulp van AI Gateway. Zie Ondersteunde modellen.

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

Met de volgende code wordt een functie gedefinieerd waarmee een agent wordt gemaakt op basis van het model en sommige hulpprogramma's, waarbij de interne functies van deze agentcode buiten het bereik van deze pagina vallen. Zie LangGraph-documentatievoor meer informatie over het bouwen van een LangGraph-agent.

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

Agenthulpprogramma's definiëren

Hulpmiddelen zijn een fundamenteel concept voor het bouwen van agenten. Ze bieden de mogelijkheid om LLM's te integreren met door mensen gedefinieerde code. Bij het verstrekken van een prompt en een lijst met hulpmiddelen genereert een hulpmiddelen oproepende LLM de argumenten om het hulpmiddel aan te roepen. Voor meer informatie over hulpprogramma's en hun gebruik met Mosaic AI-agents, zie AI-agenthulpprogramma's.

De eerste stap is het maken van een hulpprogramma voor trefwoordextractie op basis van TF-IDF. In dit voorbeeld wordt scikit-learn en een Unity Catalog-hulpprogramma gebruikt.

Het databricks-langchain-pakket biedt een handige manier om te werken met Unity Catalog-hulpprogramma's. De volgende code illustreert hoe u een hulpprogramma voor trefwoordextractor implementeert en registreert.

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)

Hier volgt een uitleg van de bovenstaande code:

1. Hiermee maakt u een client die gebruikmaakt van Unity Catalog in de Databricks-werkruimte als een 'register' om hulpprogramma's te maken en te detecteren.
2. Definieert een Python-functie die TF-IDF trefwoordextractie uitvoert.
3. Registreert de Python-functie als een Unity Catalog-functie.

Deze werkstroom lost verschillende veelvoorkomende problemen op. U hebt nu een centraal register voor hulpprogramma's die, zoals andere objecten in Unity Catalog, kunnen worden beheerd. Als een bedrijf bijvoorbeeld een standaardmethode heeft om de interne rentabiliteit te berekenen, kunt u deze definiëren als een functie in Unity Catalog en toegang verlenen aan alle gebruikers of agents met de rol FinancialAnalyst.

Als u dit hulpprogramma bruikbaar wilt maken door een LangChain-agent, gebruikt u de UCFunctionToolkit die een verzameling hulpprogramma's maakt die u aan de LLM kunt geven voor selectie:

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

De volgende code laat zien hoe u het hulpprogramma kunt testen:

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

Met de volgende code wordt een agent gemaakt die gebruikmaakt van het hulpprogramma voor trefwoordextractie.

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

In de resulterende tracering ziet u dat de LLM de tool heeft geselecteerd.

Traceringen gebruiken om fouten in agents op te sporen

MLflow Tracing is een krachtig hulpprogramma voor foutopsporing en het observeren van generatieve AI-toepassingen, waaronder agents. Het legt gedetailleerde informatie over bewerkingen vast via spans, die specifieke codesegmenten inkapselen en invoer, uitvoer en timinggegevens vastleggen.

Voor populaire bibliotheken zoals LangChain kunt u automatische tracering met mlflow.langchain.autolog()inschakelen. U kunt ook mlflow.start_span() gebruiken om een tracering aan te passen. U kunt bijvoorbeeld aangepaste gegevenswaardevelden of labels toevoegen voor waarneembaarheid. De code die wordt uitgevoerd in de context van die periode, wordt gekoppeld aan velden die u definieert. Geef in dit in-memory TF-IDF voorbeeld een naam en een spantype op.

Zie MLflow Tracing - regeneratieve AI-waarneembaarheid voor meer informatie over tracering.

In het volgende voorbeeld wordt een ophaalhulpmiddel gemaakt met behulp van een eenvoudige in het geheugen TF-IDF index. Het demonstreert zowel automatische logboeken voor uitvoeringen van hulpprogramma's als aangepaste spantracering voor extra waarneembaarheid:

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

Deze code maakt gebruik van een speciaal spantype, RETRIEVER, dat is gereserveerd voor retriever-hulpprogramma's. Andere functies van de Mozaïek AI-agent (zoals de AI Playground, de gebruikersinterface bekijken en evalueren) gebruiken het RETRIEVER spantype om de resultaten van het ophalen weer te geven.

Voor retriever-hulpprogramma's moet u hun schema opgeven om compatibiliteit met downstream Databricks-functies te garanderen. Zie mlflow.models.set_retriever_schemavoor meer informatie over .

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

De agent definiëren

De volgende stap bestaat uit het evalueren van de agent en het voorbereiden voor implementatie. Dit omvat op hoog niveau het volgende:

1. Definieer een voorspelbare API voor de agent met behulp van een handtekening.
2. Modelconfiguratie toevoegen, waardoor u eenvoudig parameters kunt configureren.
3. Meld het model aan met afhankelijkheden die het een reproduceerbare omgeving geven en waarmee u de verificatie voor andere services kunt configureren.

De MLflow ChatAgent interface vereenvoudigt het definiëren van agentinvoer en -uitvoer. Als u deze wilt gebruiken, definieert u uw agent als een subklasse van ChatAgent, waarbij u niet-streamingdeductie implementeert met de predict-functie en streamingdeductie met de predict_stream-functie.

ChatAgent is agnostisch voor uw keuze van het ontwerpframework voor agents, zodat u eenvoudig verschillende frameworks en agent-implementaties kunt testen en gebruiken. De enige vereiste is om de predict- en predict_stream-interfaces te implementeren.

Het ontwerpen van uw agent met behulp van ChatAgent biedt een aantal voordelen, waaronder:

• ondersteuning voor streaming-uitvoer
• Uitgebreide berichtgeschiedenis voor het aanroepen van hulpprogramma's: Meerdere berichten retourneren, inclusief tussenliggende berichten voor bellen via hulpprogramma's, voor verbeterde kwaliteit en gespreksbeheer.
• Multiagentsysteemondersteuning
• Integratie van Databricks-functies: standaard compatibiliteit met AI Playground, Agent Evaluation en Agent Monitoring.
• Getypte ontwerpinterfaces: Agentcode schrijven met behulp van getypte Python-klassen en profiteren van automatisch aanvullen van IDE en notebook.

Zie Ai-agents ontwerpen in code voor meer informatie over het ontwerpen van een ChatAgent agent.

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)

De volgende code laat zien hoe u de ChatAgentgebruikt.

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

Agents configureren met parameters

Met het Agent Framework kunt u de uitvoering van agents beheren met parameters. Dit betekent dat u snel verschillende agentconfiguraties kunt testen, zoals het schakelen tussen LLM-eindpunten of het proberen van verschillende hulpprogramma's zonder de onderliggende code te wijzigen.

Met de volgende code maakt u een configuratiewoordenlijst waarmee agentparameters worden ingesteld bij het initialiseren van het model.

Zie Parametrize-code voor implementatie in omgevingen voor meer informatie over het parameteriseren van agents.

)

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

De agent registreren

Nadat u de agent hebt gedefinieerd, is deze nu klaar om te worden geregistreerd. In MLflow betekent het vastleggen van een agent dat de configuratie van de agent (inclusief afhankelijkheden) wordt opgeslagen, zodat deze kan worden gebruikt voor evaluatie en implementatie.

Als u een agent wilt registreren vanuit een notebook, kunt u alle code schrijven die het model in één cel definieert en vervolgens de %%writefile magic-opdracht gebruiken om de definitie van de agent op te slaan in een bestand:

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

Als de agent toegang tot externe resources vereist, zoals Unity Catalog om het hulpprogramma voor trefwoordextractie uit te voeren, moet u verificatie configureren voor de agent, zodat deze toegang heeft tot de resources wanneer deze wordt geïmplementeerd.

Als u de verificatie voor Databricks-resources wilt vereenvoudigen, schakelt u automatische verificatiepassthrough in:

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

Zie codegebaseerde logboekregistratievoor meer informatie over logboekagenten.

De agent evalueren

De volgende stap is het evalueren van de agent om te zien hoe deze presteert. De evaluatie van agents is lastig en brengt veel vragen met zich mee, zoals:

• Wat zijn de juiste metrische gegevens om de kwaliteit te evalueren? Hoe vertrouw ik de uitvoer van deze metrische gegevens?
• Ik moet veel ideeën evalueren - hoe kan ik...
  • voer evaluatie snel uit, zodat de meeste tijd niet wordt besteed aan wachten?
  • vergelijkt u deze verschillende versies van mijn agent snel op kwaliteit, kosten en latentie?
• Hoe kan ik snel de hoofdoorzaak van kwaliteitsproblemen identificeren?

Als data scientist of ontwikkelaar bent u misschien niet de echte expert op het gebied van onderwerp. In de rest van deze sectie worden de agents evaluatietools beschreven waarmee u een goed resultaat kunt definiëren.

Een evaluatieset maken

Als u wilt definiëren wat kwaliteit voor een agent betekent, gebruikt u metrische gegevens om de prestaties van de agent in een evaluatieset te meten. Zie "kwaliteit" definiëren: evaluatiesets.

Met Agent Evaluation kunt u synthetische evaluatiesets maken en kwaliteit meten door evaluaties uit te voeren. Het idee is om te beginnen met de feiten, zoals een set documenten, en 'achteruit werken' door deze feiten te gebruiken om een reeks vragen te genereren. U kunt de vragen bepalen die worden gegenereerd door enkele richtlijnen op te geven:

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

De gegenereerde evaluaties omvatten het volgende:

• Een aanvraagveld dat lijkt op de eerder genoemde ChatAgentRequest:

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

• Een lijst met 'verwachte opgehaalde inhoud'. Het retriever-schema is gedefinieerd met content en doc_uri velden.

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

• Een lijst met verwachte feiten. Wanneer u twee antwoorden vergelijkt, kan het lastig zijn om kleine verschillen tussen deze antwoorden te vinden. Verwachte feiten destilleren wat een juist antwoord scheidt van een gedeeltelijk juist antwoord van een onjuist antwoord en verbeteren zowel de kwaliteit van de AI-rechters als de ervaring van de mensen die aan de agent werken:

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

• Een source_id veld dat hier SYNTHETIC_FROM_DOCis. Naarmate u completere evaluatiesets bouwt, komen de voorbeelden uit verschillende bronnen, zodat dit veld deze onderscheidt.

Zie Synthese van evaluatiesetsvoor meer informatie over het maken van evaluatiesets.

Evalueer de agent met LLM-rechters

Het handmatig evalueren van de prestaties van een agent op zo veel gegenereerde voorbeelden kan niet goed worden geschaald. Op schaal is het gebruik van LLM's als rechters een veel redelijkere oplossing. Als u de ingebouwde beoordelaars wilt gebruiken die beschikbaar zijn bij het uitvoeren van een agentevaluatie, gebruikt u de volgende code:

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
)

De eenvoudige agent scoorde 68% in totaal. Uw resultaten kunnen hier verschillen, afhankelijk van de configuratie die u gebruikt. Het uitvoeren van een experiment om drie verschillende LLM's voor kosten en kwaliteit te vergelijken, is net zo eenvoudig als het wijzigen van de configuratie en het opnieuw evalueren.

Overweeg om de modelconfiguratie te wijzigen om een andere LLM- of systeemprompt of temperatuurinstelling te gebruiken.

Deze rechters kunnen worden aangepast om dezelfde richtlijnen te volgen die menselijke experts zouden gebruiken om een antwoord te evalueren. Zie Ingebouwde AI-rechters (MLflow 2) voor meer informatie over LLM-rechters.

Met agentevaluatie kunt u de manier aanpassen waarop u de kwaliteit van een bepaalde agent meet met behulp van aangepaste metrische gegevens. U kunt de evaluatie beschouwen als een integratietest en afzonderlijke metrische gegevens als eenheidstests. In het volgende voorbeeld wordt een Booleaanse metrische waarde gebruikt om te controleren of de agent zowel de trefwoordextractie als de retriever voor een bepaalde aanvraag heeft gebruikt:

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

Houd er rekening mee dat de agent nooit gebruikmaakt van de trefwoordextractie. Hoe kunt u dit probleem oplossen?

De agent uitrollen en bewaken

Wanneer u klaar bent om te beginnen met het testen van uw agent met echte gebruikers, biedt Agent Framework een oplossing die gereed is voor productie voor de agent op Mosaic AI Model Serving.

Het implementeren van agents in Model Serving biedt de volgende voordelen:

• Model Serving beheert automatisch schalen, logboekregistratie, versiebeheer en toegangsbeheer, zodat u zich kunt richten op het ontwikkelen van kwaliteitsagents.
• Deskundigen kunnen de beoordelings-app gebruiken om met de agent te communiceren en feedback te geven die kan worden opgenomen in uw bewaking en evaluaties.
• U kunt de agent monitoren door evaluaties uit te voeren op live verkeer. Hoewel gebruikersverkeer de grondwaar niet bevat, beoordelen LLM (en de aangepaste metrische gegevens die u hebt gemaakt) een evaluatie zonder supervisie uitvoeren.

Met de volgende code worden de agents uitgerold naar een bedienings-eindpunt. Zie Een agent implementeren voor generatieve AI-toepassingen voor meer informatie.

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
)