Bemutató: Lekéréses ügynök létrehozása, kiértékelése és üzembe helyezése

Ez az oktatóanyag végigvezeti egy olyan AI-ügynök létrehozásán, amely a lekérést és az eszközöket együtt használja.

Ez egy köztes szintű oktatóanyag, amely feltételezi, hogy bizonyos ismeretekkel rendelkezik az ügynök Databricksen való létrehozásának alapjairól. Ha még nem kezdte el az ügynökök készítését, olvassa el az AI-ügynökök használatának első lépéseit.

A példajegyzetfüzet tartalmazza az oktatóanyagban használt összes kódot.

Ez az oktatóanyag a generatív AI-alkalmazások létrehozásának néhány alapvető kihívását ismerteti:

• A fejlesztési élmény egyszerűsítése olyan gyakori feladatokhoz, mint az eszközök létrehozása és az ügynökvégrehajtás hibakeresése.
• Működési kihívások, például:
  • Nyomkövetési ügynök konfigurációja
  • Bemenetek és kimenetek kiszámítható meghatározása
  • Függőségek verzióinak kezelése
  • Verziókövetés és üzembe helyezés
• Az ügynök minőségének és megbízhatóságának mérése és javítása.

Az egyszerűség kedvéért ez az oktatóanyag egy memórián belüli megközelítést használ a kulcsszavas keresés engedélyezéséhez egy adathalmazon, amely adattömbökre bontott Databricks-dokumentációt tartalmaz. A Mozaik AI-vektorkeresést skálázható indexelésre és dokumentumok keresésére használó reálisabb példaért tekintse meg ResponsesAgent a példákat.

Példajegyzetfüzet

Ez az önálló jegyzetfüzet úgy lett kialakítva, hogy gyorsan együttműködjön a Mozaik AI-ügynökökkel egy mintadokumentum-korpusz használatával. Készen áll a futtatásra, és nincs szükség beállításra vagy adatokra.

Mozaik AI-ügynök bemutatója

Jegyzetfüzet beszerzése

Ügynök és eszközök létrehozása

A Mozaik AI-ügynök keretrendszer számos különböző szerzői keretrendszert támogat. Ez a példa a LangGraph használatával szemlélteti a fogalmakat, de ez nem egy LangGraph-oktatóanyag.

További támogatott keretrendszerek példáiért lásd ResponsesAgent a példákat.

Az első lépés egy ügynök létrehozása. Meg kell adnia egy LLM-ügyfelet és egy eszközlistát. A databricks-langchain Python-csomag LangChain- és LangGraph-kompatibilis ügyfeleket tartalmaz a Databricks LLM-ekhez és a Unity Catalogban regisztrált eszközökhöz.

A végpontnak függvényhívó Foundation Model API-nak vagy AI-átjárót használó külső modellnek kell lennie. Lásd a támogatott modelleket.

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

Az alábbi kód egy olyan függvényt határoz meg, amely létrehoz egy ügynököt a modellből és néhány eszközből, és az ügynökkód belső elemeinek megvitatása kívül esik ezen a lapon. A LangGraph-ügynök felépítéséről további információt a LangGraph dokumentációjában talál.

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

Ügynökeszközök definiálása

Az eszközök alapvető fogalma az ügynökök létrehozásának. Lehetővé teszik, hogy az LLM-eket emberi kóddal integrálják. Amikor megjelenik egy parancssor és egy eszközlista, az eszközhívó LLM létrehozza az eszköz meghívásához szükséges argumentumokat. Az eszközökkel és a Mozaik AI-ügynökökkel való használatukkal kapcsolatos további információkért tekintse meg az AI-ügynökeszközöket.

Az első lépés egy kulcsszókinyerési eszköz létrehozása TF-IDF alapján. Ez a példa scikit-learn és Unity Catalog eszközt használ.

A databricks-langchain csomag kényelmes módot kínál a Unity Catalog eszközeinek használatára. Az alábbi kód bemutatja, hogyan implementálhat és regisztrálhat kulcsszóelszívó eszközt.

Megjegyzés

A Databricks-munkaterület beépített eszközzel rendelkezik, system.ai.python_execamellyel bővítheti az ügynököket a Python-szkriptek tesztkörnyezetben való futtatásával. Más hasznos beépített eszközök közé tartoznak a külső kapcsolatok és az AI-függvények.

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)

A fenti kód magyarázata:

1. Létrehoz egy ügyfelet, amely a Databricks-munkaterületen a Unity Katalógust használja "beállításjegyzékként" az eszközök létrehozásához és felderítéséhez.
2. Definiál egy Python-függvényt, amely TF-IDF kulcsszókinyeréseket hajt végre.
3. A Python-függvényt Unity Catalog-függvényként regisztrálja.

Ez a munkafolyamat számos gyakori problémát old meg. Most már rendelkezik egy központi beállításjegyzékkel az eszközökhöz, amelyek a Unity Catalog más objektumaihoz hasonlóan szabályozhatók. Ha például egy vállalat szabványos módon számítja ki a belső megtérülési rátát, a Unity Catalogban függvényként definiálhatja, és hozzáférést biztosíthat a FinancialAnalyst szerepkörrel rendelkező összes felhasználónak vagy ügynöknek.

Ahhoz, hogy ezt az eszközt egy LangChain-ügynök használhatóvá tegye, használja az UCFunctionToolkit eszközt, amely egy eszközgyűjteményt hoz létre az LLM-nek a kiválasztáshoz:

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

Az alábbi kód bemutatja, hogyan tesztelheti az eszközt:

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

Az alábbi kód létrehoz egy ügynököt, amely a kulcsszó-kinyerési eszközt használja.

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

Az eredményként kapott nyomkövetésben láthatja, hogy az LLM kiválasztotta az eszközt.

Ügynökök hibakereséséhez használjon nyomkövetéseket

Az MLflow Tracing hatékony eszköz a generatív AI-alkalmazások, köztük az ügynökök hibakeresésére és megfigyelésére. A részletes műveleti információkat spanok segítségével rögzíti, amelyek konkrét kódszegmenseket foglalnak össze, valamint rögzítik a bemeneteket, kimeneteket és időzítési adatokat.

Az olyan népszerű kódtárak esetében, mint a LangChain, engedélyezze az automatikus nyomkövetést a következővel mlflow.langchain.autolog(): . A nyomkövetés testreszabására is használható mlflow.start_span() . Hozzáadhat például egyéni adatértékmezőket vagy címkézést a megfigyelhetőség érdekében. Az adott időtartam kontextusában futó kód az Ön által definiált mezőkhöz lesz társítva. Ebben a TF-IDF memóriabeli példában adjon meg egy nevet és egy span típust.

További információ a nyomkövetésről: MLflow Tracing – GenAI megfigyelhetőség.

Az alábbi példa egy egyszerű memóriabeli TF-IDF index használatával hoz létre egy leolvasó eszközt. Bemutatja az eszközvégrehajtások automatikus naplózását és az egyéni szakaszok nyomkövetését a további megfigyelhetőség érdekében.

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

Ez a kód egy speciális span típust használ, RETRIEVERamely a retriever-eszközök számára van fenntartva. A Mozaik AI-ügynök egyéb funkciói (például az AI-játszótér, a felhasználói felület áttekintése és a kiértékelés) a RETRIEVER span típust használják a lekérési eredmények megjelenítéséhez.

A retriever-eszközöknek meg kell adniuk a sémájukat, hogy kompatibilisek legyenek az alsóbb rétegbeli Databricks-funkciókkal. További információ: mlflow.models.set_retriever_schema Egyéni lekéréses sémák megadása.

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

Az ügynök definiálása

A következő lépés az ügynök kiértékelése és az üzembe helyezés előkészítése. Magas szinten ez a következőket foglalja magában:

1. Definiáljon egy előre jelezhető API-t az ügynök számára aláírás segítségével.
2. Adjon hozzá modellkonfigurációt, amely megkönnyíti a paraméterek konfigurálását.
3. A modellt naplózza olyan függőségekkel, amelyek biztosítják a reprodukálható környezetet, és lehetővé teszik más szolgáltatásokkal való hitelesítésének konfigurálását.

Az MLflow ChatAgent interfész leegyszerűsíti az ügynök bemeneteinek és kimeneteinek meghatározását. Az ügynök használatához definiálja azt a ChatAgent alosztályaként, implementálva a nem streamelési következtetést a predict függvénnyel és a streamelési következtetést a predict_stream függvénnyel.

ChatAgent független az ügynökkészítési keretrendszer választásával szemben, lehetővé téve a különböző keretrendszerek és ügynök-implementációk egyszerű tesztelését és használatát – az egyetlen követelmény, hogy implementálja a predict és predict_stream felületeket.

Az ChatAgent használatával az ügynök megalkotása számos előnnyel jár, többek között:

• Streamelési kimenet támogatása
• Átfogó eszközhívó üzenetelőzmények: Több üzenetet ad vissza, beleértve a köztes eszközhívó üzeneteket is, a jobb minőség és beszélgetéskezelés érdekében.
• többügynök rendszer támogatása
• Databricks-funkciók integrációja: Natív kompatibilitás az AI-játszótérrel, az ügynökértékeléssel és az ügynökmonitorozással.
• Gépelt szerzői felületek: Ügynökkód írása gépelt Python-osztályok használatával, kihasználva az IDE és a jegyzetfüzet automatikus kiegészítését.

További információért arról, hogyan hozhat létre AI-ügynököket a kódban, lásd: ChatAgent.

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)

Az alábbi kód bemutatja, hogyan használható a ChatAgent.

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

Ügynökök konfigurálása paraméterekkel

Az Ügynök-keretrendszer lehetővé teszi, hogy paraméterekkel vezérelje az ügynökök végrehajtását. Ez azt jelenti, hogy gyorsan tesztelheti a különböző ügynökkonfigurációkat, például az LLM-végpontok közötti váltást vagy a különböző eszközök kipróbálását a mögöttes kód módosítása nélkül.

Az alábbi kód létrehoz egy konfigurációs szótárat, amely beállítja az ügynökparamétereket a modell inicializálása során.

Az ügynökök paraméterezésével kapcsolatos további információkért tekintse meg a környezetek közötti üzembe helyezés Parametrize-kódját.

)

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

Az ügynök rögzítése

Az ügynök definiálása után már készen áll a naplózásra. Az MLflow-ban az ügynök naplózása azt jelenti, hogy menti az ügynök konfigurációját (beleértve a függőségeket is), hogy felhasználható legyen a kiértékeléshez és az üzembe helyezéshez.

Megjegyzés

Amikor ügynököket fejleszt egy jegyzetfüzetben, az MLflow az ügynök függőségeit a jegyzetfüzet-környezetből következteti.

Ha naplózni szeretne egy ügynököt egy jegyzetfüzetből, megírhatja a modellt egyetlen cellába meghatározó összes kódot, majd a %%writefile magic paranccsal mentheti az ügynök definícióját egy fájlba:

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

Ha az ügynöknek hozzáférésre van szüksége külső erőforrásokhoz, például a Unity Cataloghoz a kulcsszókinyerési eszköz végrehajtásához, konfigurálnia kell az ügynök hitelesítését, hogy hozzáférhessen az erőforrásokhoz az üzembe helyezéskor.

A Databricks-erőforrások hitelesítésének egyszerűsítése érdekében engedélyezze az automatikus hitelesítés átengedési módját:

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

A naplózási ügynökökkel kapcsolatos további információkért lásd a kódalapú naplózást.

Az ügynök kiértékelése

A következő lépés az ügynök kiértékelése, hogy lássa, hogyan működik. Az ügynökértékelés kihívást jelent, és számos kérdést vet fel, például a következőket:

• Melyek a megfelelő metrikák a minőség kiértékeléséhez? Hogyan bízom ezeknek a metrikáknak a kimenetében?
• Sok ötletet kell kiértékelnem- hogyan...
  • futtassa gyorsan az értékelést, így az időm nagy része nem várakozással telik?
  • Gyorsan összehasonlíthatja az ügynököm különféle változatait a minőség, a költség és a késleltetés alapján?
• Hogyan azonosíthatom gyorsan a minőségi problémák kiváltó okát?

Adatelemzőként vagy fejlesztőként lehet, hogy nem Ön a tényleges téma szakértője. A szakasz további része az ügynökértékelési eszközöket ismerteti, amelyek segíthetnek a jó kimenet meghatározásában.

Kiértékelési készlet létrehozása

Annak meghatározásához, hogy mit jelent a minőség egy ügynök számára, metrikákat használhat az ügynök teljesítményének mérésére egy értékelési adathalmazon. Lásd: A „minőség” meghatározása: Kiértékelési készletek.

Az ügynökértékeléssel szintetikus kiértékelési készleteket hozhat létre, és kiértékelések futtatásával mérheti a minőséget. Az ötlet az, hogy a tényekből indulunk ki, például egy dokumentumkészletből, és "visszafelé dolgozzunk" a tényekkel, hogy kérdéseket állítsunk elő. A létrehozott kérdéseket néhány irányelv megadásával konfigurálhatja:

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

A létrehozott értékelések a következők:

• A korábban említett ChatAgentRequest mezőhöz hasonló kérelem:

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

• A "várt lekért tartalom" listája. A lekérdező sémát a content és doc_uri mezőkkel határozták meg.

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

• A várt tények listája. Ha két választ hasonlít össze, nehéz lehet kisebb különbségeket találni közöttük. A várt tények elválasztják a helyes választ a helytelen választól, és javítják az AI-bírák minőségét, valamint az ügynökön dolgozó emberek tapasztalatait:

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

• Egy source_id mező, amely itt található SYNTHETIC_FROM_DOC. A teljesebb kiértékelési csoportok létrehozásakor a minták különböző forrásokból származnak, így ez a mező megkülönbözteti őket.

A kiértékelési csoportok létrehozásáról további információt a Kiértékelési csoportok szintetizálása című témakörben talál.

Az ügynök kiértékelése LLM-bírák használatával

Az ügynök teljesítményének manuális kiértékelése sok létrehozott példán nem skálázható megfelelően. Az LLM-k bíróként való használata nagy léptékben sokkal ésszerűbb megoldás. Az Ügynökértékelés használatakor elérhető beépített bírák használatához használja a következő kódot:

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
)

Az egyszerű ügynök összesített pontszáma 68%. Az eredmények itt eltérhetnek a használt konfigurációtól függően. A költségek és a minőség szempontjából három különböző LLM összehasonlítására irányuló kísérlet futtatása olyan egyszerű, mint a konfiguráció módosítása és az újraértékelés.

Fontolja meg a modell konfigurációjának módosítását egy másik LLM, rendszerkérés vagy hőmérséklet-beállítás használatára.

Ezek a bírák testre szabhatók, hogy ugyanazokat az irányelveket kövessék, amelyeket az emberi szakértők a válasz kiértékeléséhez használnak. Az LLM-bírákról további információt a beépített AI-bírák (MLflow 2) című témakörben talál.

Az Ügynökértékelés funkcióval testre szabhatja, hogyan mérheti egy adott ügynök minőségét egyéni metrikák használatával. Az értékelésre úgy gondolhat, mint egy integrációs tesztre, az egyes metrikákra pedig egységtesztként. Az alábbi példa logikai metrikát használ annak ellenőrzésére, hogy az ügynök egy adott kéréshez a kulcsszókinyerést és a leolvasót is használta-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],
  )

Jegyezze meg, hogy az ügynök soha nem használja a kulcsszó-kivonást. Hogyan háríthatja el ezt a problémát?

Az ügynök üzembe helyezése és figyelése

Ha készen áll arra, hogy valós felhasználókkal tesztelje az ügynököt, az Agent Framework egy éles üzemre kész megoldást kínál az ügynök mozaik AI-modellkiszolgálón való kiszolgálására.

Az ügynökök modellkiszolgálón való üzembe helyezése a következő előnyöket nyújtja:

• A Modellkiszolgáló kezeli az automatikus skálázást, a naplózást, a verziókövetést és a hozzáférés-vezérlést, így a minőségi ügynökök fejlesztésére összpontosíthat.
• A téma szakértői a Felülvizsgálati alkalmazással kommunikálhatnak az ügynökkel, és visszajelzést küldhetnek, amely beépíthető a figyelési és kiértékelési folyamatba.
• Az ügynök figyelése az élő forgalom kiértékelésével lehetséges. Bár a felhasználói forgalom nem tartalmazza az alapigazságot, az LLM-bírák (és a létrehozott egyéni metrikák) nem felügyelt értékelést végeznek.

Az alábbi kód üzembe helyezi az ügynököket egy kiszolgáló végponton. További információ: Ügynök üzembe helyezése generatív AI-alkalmazásokhoz.

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
)