Začínáme s agenty AI Databricks

Tento kurz vás provede vytvořením agenta AI, který používá vyhledávání a nástroje společně. Datová sada se skládá z podmnožina dokumentace Databricks, která je už rozdělená na bloky dat. V tomto kurzu vytvoříte agenta, který načítá dokumenty na základě klíčových slov.

Pro zjednodušení tento kurz používá jednoduchý přístup v paměti založený na TF-IDF pro extrakci klíčových slov a vyhledávání klíčových slov v dokumentech. Ukázkový poznámkový blok obsahuje veškerý kód použitý v tomto kurzu. Realističtější příklad, který používá Mosaic AI Vector Search ke škálovatelnému indexování a vyhledávání dokumentů, najdete v příkladech ChatAgent.

Tento kurz se zabývá některými základními výzvami při vytváření generovaných aplikací umělé inteligence:

• Zjednodušení vývojového prostředí pro běžné úlohy, jako je vytváření nástrojů a ladění spouštění agentů.
• Provozní výzvy, jako jsou:
  • Konfigurace agenta pro sledování
  • Definování vstupů a výstupů předvídatelným způsobem
  • Správa verzí závislostí
  • Správa verzí a nasazení
• Měření a zlepšení kvality a spolehlivosti agenta.

Pokyny k celému procesu vývoje při vytváření agenta najdete v průvodci generováním aplikace AI.

ukázkový poznámkový blok

Tento samostatný poznámkový blok je navržen tak, aby vám rychle umožnil práci s agenty Mosaic AI s využitím ukázkového korpusu dokumentů. Je připravená ke spuštění bez nutnosti nastavení nebo dat.

Ukázka agenta AI v systému Mosaic

Pořiďte si notebook

Vytvoření agenta a nástrojů

Rozhraní AI Agent Framework pro architekturu systému Mosaic podporuje mnoho různých architektur pro vytváření obsahu. Tento příklad používá jazyk LangGraph k ilustraci konceptů, ale nejedná se o kurz JazykGraph.

Příklady jiných podporovaných architektur najdete v ChatAgent příklady.

Prvním krokem je vytvoření agenta. Musíte zadat klienta LLM a seznam nástrojů. Balíček pro Python databricks-langchain zahrnuje klienty kompatibilní s LangChain a LangGraph pro Databricks LLMs a nástroje zaregistrované v Unity Catalog.

Koncový bod musí být rozhraní API modelu typu Foundation pro volání funkcí nebo externí model pomocí brány pro AI. Viz Podporované modely.

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

Následující kód definuje funkci, která vytvoří agenta z modelu a některé nástroje, které probírají vnitřní informace o tomto kódu agenta, jsou mimo rozsah této příručky. Další informace o tom, jak vytvořit agenta LangGraph, naleznete v dokumentaci 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()

Definovat nástroje agenta

Nástroje jsou základním konceptem vytváření agentů. Poskytují možnost integrovat LLM s lidsky definovaným kódem. Po zadání výzvy a seznamu nástrojů vygeneruje LLM volající nástroj argumenty pro vyvolání tohoto nástroje. Další informace o nástrojích a jejich použití s agenty Mosaic AI naleznete v tématu nástroje agentů AI.

Prvním krokem je vytvoření nástroje pro extrakci klíčových slov na základě TF-IDF. V tomto příkladu se používá nástroj scikit-learn a Unity Catalog.

Balíček databricks-langchain nabízí pohodlný způsob práce s nástroji katalogu Unity. Následující kód ukazuje, jak implementovat a zaregistrovat nástroj pro extrakci klíčových slov.

Poznámka:

Pracovní prostor Databricks má integrovaný nástroj, system.ai.python_exec, který můžete použít k rozšíření agentů s možností spouštění skriptů Pythonu v prostředí spouštění v izolovaném prostoru (sandbox). Další užitečné integrované nástroje zahrnují externí připojení a funkce umělé inteligence.

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)

Tady je vysvětlení výše uvedeného kódu:

1. Vytvoří klienta, který používá katalog Unity v pracovním prostoru Databricks jako registr k vytváření a zjišťování nástrojů.
2. Definuje funkci Pythonu, která provádí extrakci klíčových slov TF-IDF.
3. Zaregistruje funkci Pythonu jako funkci Katalogu Unity.

Tento pracovní postup řeší několik běžných problémů. Teď máte centrální registr pro nástroje, které se dají řídit stejně jako jiné objekty v katalogu Unity. Pokud má například společnost standardní způsob výpočtu interní míry výnosnosti, můžete ji definovat jako funkci v katalogu Unity a udělit přístup všem uživatelům nebo agentům s rolí FinancialAnalyst.

Pokud chcete, aby byl tento nástroj použitelný agentem LangChain, použijte [UCFunctionToolkit](/generative-ai/agent-framework/create-custom-tool.md), který vytvoří kolekci nástrojů pro LLM k výběru:

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

Následující kód ukazuje, jak nástroj otestovat:

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

Následující kód vytvoří agenta, který používá nástroj pro extrakci klíčových slov.

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

Ve výsledném trasování můžete vidět, že LLM vybralo nástroj.

Použití trasování k ladění agentů

Trasování MLflow je výkonný nástroj pro ladění a sledování aplikací generativní AI, včetně agentů. Zaznamenává podrobné informace o provádění prostřednictvím 'spanů', které obklopují konkrétní segmenty kódu a zaznamenávají vstupy, výstupy a časová data.

Pro oblíbené knihovny, jako je LangChain, povolte automatické trasování pomocí mlflow.langchain.autolog(). Trasování můžete přizpůsobit také pomocí mlflow.start_span(). Můžete například přidat vlastní pole hodnot dat nebo popisky pro pozorovatelnost. Kód, který se spouští v kontextu toho úseku, se přidružuje k polím, která definujete. V tomto příkladu s pamětí TF-IDF zadejte název a typ rozsahu.

Další informace o trasování můžete zjistit v části Pozorovatelnost agenta pomocí trasování MLflow.

Následující příklad vytvoří nástroj pro vyhledávání s využitím jednoduchého indexu TF-IDF uloženého v paměti. Ukazuje jak automatické protokolování pro spouštění nástrojů, tak vlastní trasování rozsahu pro další pozorovatelnost:

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

Tento kód používá speciální typ rozsahu, RETRIEVER, který je vyhrazen pro nástroje retrieveru. Jiné funkce agenta AI v systému Mosaic (například AI Playground, revizní uživatelské rozhraní a vyhodnocení) používají k zobrazení výsledků získávání typ rozsahu RETRIEVER.

Nástroje retrieveru vyžadují, abyste zadali jejich schéma, abyste zajistili kompatibilitu s podřízenými funkcemi Databricks. Další informace o mlflow.models.set_retriever_schemanaleznete v tématu Určení vlastních schémat načítání.

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

Definování agenta

Dalším krokem je vyhodnocení agenta a jeho příprava na nasazení. Na vysoké úrovni to zahrnuje následující:

1. Definujte předvídatelné rozhraní API pro agenta pomocí podpisu.
2. Přidejte konfiguraci modelu, která usnadňuje konfiguraci parametrů.
3. Zaznamenejte model se závislostmi, které mu poskytují opakovatelné prostředí a umožňují nakonfigurovat jeho ověřování pro další služby.

Rozhraní ChatAgent MLflow zjednodušuje definování vstupů a výstupů agenta. Pokud ho chcete použít, definujte agenta jako podtřídu ChatAgent, implementujte ne-streamovací odvozování pomocí funkce predict a streamovací odvozování s funkcí predict_stream.

ChatAgent je nezávislá na vaší volbě architektury pro vytváření agentů, která umožňuje snadno testovat a používat různé architektury a implementace agentů – jediným požadavkem je implementace predict a predict_stream rozhraní.

Vytváření agenta pomocí ChatAgent poskytuje řadu výhod, mezi které patří:

• podpora výstupu streamování
• Úplná historie volání nástrojů: Vrátí více zpráv, včetně mezilehlých zpráv o volání nástrojů, pro lepší kvalitu a správu konverzace.
• Podpora systému s více agenty
• integrace funkcí Databricks: kompatibilita s AI Playground, vyhodnocením agenta a monitorováním agentů.
• Typovaná autorská rozhraní: Psaní kódu pro agenta pomocí typových tříd Pythonu, které umožňují využití automatického dokončování v integrovaných vývojových prostředích (IDE) a poznámkových blocích.

Další informace o vytváření ChatAgent naleznete v tématu . Použijte ChatAgent k vytváření 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)

Následující kód ukazuje, jak používat ChatAgent.

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

Konfigurace agentů s parametry

Rozhraní agenta umožňuje řídit spouštění agenta pomocí parametrů. To znamená, že můžete rychle otestovat různé konfigurace agentů, jako je přepnutí koncových bodů LLM nebo vyzkoušení různých nástrojů beze změny základního kódu.

Následující kód vytvoří konfigurační slovník, který při inicializaci modelu nastaví parametry agenta.

Další podrobnosti o parametrizaci agentů najdete v tématu Parametrizovat kód agenta pro nasazení napříč prostředími.

)

from mlflow.models import ModelConfig

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


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


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


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

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

  return agent

Zaznamenejte agenta

Po definování agenta je nyní připravený k zaznamenávání. Protokolování agenta v MLflow znamená uložení konfigurace agenta (včetně závislostí), aby ho bylo možné použít k vyhodnocení a nasazení.

Poznámka:

Při vývoji agentů v poznámkovém bloku MLflow odvodí závislosti agenta z prostředí poznámkového bloku.

Pokud chcete zaznamenat agenta z poznámkového bloku, můžete napsat veškerý kód, který definuje model v jedné buňce, a pak pomocí příkazu magic %%writefile uložit definici agenta do souboru:

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

Pokud agent vyžaduje přístup k externím prostředkům, jako je například Katalog Unity ke spuštění nástroje pro extrakci klíčových slov, musíte pro agenta nakonfigurovat ověřování, aby měl přístup k prostředkům při nasazení.

Pokud chcete zjednodušit ověřování pro prostředky Databricks, povolte automatické předávací ověřování:

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

Další informace o agentech protokolování najdete v tématu protokolování založené na kódu.

Vyhodnocení agenta

Dalším krokem je vyhodnocení agenta, abyste zjistili, jak funguje. Vyhodnocení agenta je náročné a vyvolává mnoho otázek, jako je například následující:

• Jaké jsou správné metriky k vyhodnocení kvality? Jak můžu důvěřovat výstupům těchto metrik?
• Potřebuji vyhodnotit mnoho nápadů - jak...
  • Spustit vyhodnocení rychle, aby většinu času netrávil čekáním?
  • Rychle porovnejte tyto různé verze mého agenta podle kvality, nákladů a latence.
• Jak rychle zjistím původní příčinu problémů s kvalitou?

Jako datový vědec nebo vývojář nemusíte být skutečným odborníkem na danou problematiku. Zbytek této části popisuje nástroje pro vyhodnocení agenta, které vám můžou pomoct definovat dobrý výstup.

Vytvoření testovací sady

Pokud chcete definovat, co znamená kvalita agenta, použijete metriky k měření výkonu agenta v testovací sadě. Viz v části „Definice kvality“: Sady vyhodnocení.

Pomocí agenta Evaluation můžete vytvářet syntetické sady vyhodnocení a měřit kvalitu spuštěním vyhodnocení. Cílem je začít od faktů, jako je sada dokumentů, a "pracovat zpět" pomocí těchto faktů k vygenerování sady otázek. Otázky vygenerované pomocí některých pokynů můžete podmínit:

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

Vygenerované vyhodnocení zahrnují následující:

• Pole požadavku, které vypadá jako dříve uvedené 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"}]}
  

• Seznam očekávaného načteného obsahu Schéma retrieveru bylo definováno s poli content a 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"}]
  

• Seznam očekávaných faktů. Při porovnávání dvou odpovědí může být obtížné najít malé rozdíly mezi nimi. Očekávaná fakta destilují, co odděluje správnou odpověď od částečně správné odpovědi od nesprávné odpovědi a zlepšuje kvalitu porotců umělé inteligence i zkušenosti lidí pracujících na agentech:

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

• Pole source_id, zde je to SYNTHETIC_FROM_DOC. Při vytváření ucelenějších vyhodnocovacích sad budou ukázky pocházet z různých zdrojů, takže je toto pole rozlišuje.

Další informace o vytváření zkušebních sad najdete v tématu Syntetizovat vyhodnocovací sady.

Vyhodnoťte agenta pomocí porotců LLM

Ruční vyhodnocení výkonu agenta na tolika generovaných příkladech není praktické. Ve velkém měřítku je použití LLM jako porotců mnohem vhodnějším řešením. Pokud chcete použít vestavěné soudce, které jsou k dispozici při používání Agent Evaluation, použijte následující kód:

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
)

Jednoduchý agent získal celkový počet bodů 68%. Vaše výsledky se tady můžou lišit v závislosti na použité konfiguraci. Spuštění experimentu pro porovnání tří různých LLM pro náklady a kvalitu je stejně jednoduché jako změna konfigurace a opětovné vyhodnocení.

Zvažte změnu konfigurace modelu tak, aby používala jiné nastavení LLM, systémové výzvy nebo teploty.

Tito porotci mohou být přizpůsobeni tak, aby dodržovali stejné pokyny, které by použili lidé k vyhodnocení odpovědi. Další informace o porotcích LLM najdete v tématu předdefinovaných porotců umělé inteligence.

Pomocí vyhodnocení agenta můžete přizpůsobit způsob měření kvality konkrétního agenta pomocí vlastních metrik. Hodnocení si můžete představit jako integrační test a jednotlivé metriky jako testy jednotek. Následující příklad používá logickou metriku ke kontrole, jestli agent pro daný požadavek použil extrakci klíčových slov i retriever:

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

Všimněte si, že agent nikdy nepoužívá extrakci klíčových slov. Jak můžete tento problém vyřešit?

Nasazení a monitorování agenta

Jakmile budete připraveni začít testovat svého agenta s reálnými uživateli, Agent Framework poskytuje produkčně připravené řešení pro nasazení agenta na platformě Mosaic AI Model Serving.

Nasazení agentů do služby Model Serving poskytuje následující výhody:

• Obsluha modelů spravuje automatické škálování, protokolování, správu verzí a řízení přístupu a umožňuje soustředit se na vývoj agentů pro zvýšení kvality.
• Odborníci na danou problematiku můžou pomocí aplikace Review pracovat s agentem a poskytovat zpětnou vazbu, kterou je možné začlenit do monitorování a hodnocení.
• Můžete sledovat agenta prováděním vyhodnocení na živém provozu. I když uživatelský provoz nebude zahrnovat skutečnost, LLM porotci (a vlastní metrika, kterou jste vytvořili) provádějí nesledované hodnocení.

Následující kód nasadí agenty do obslužného koncového bodu. Další informace naleznete v tématu Nasazení agenta pro generování aplikace AI.

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
)