チュートリアル: 取得エージェントをビルド、評価、デプロイする

2025-04-06

このチュートリアルでは、取得とツールを一緒に使用する AI エージェントを構築する手順について説明します。

これは、Databricks でのエージェントの構築の基本を理解していることを前提とする中級レベルのチュートリアルです。エージェントの構築を初めて使用する場合は、「 AI エージェントの概要」を参照してください。

サンプルノートブックには、このチュートリアルで使用されるすべてのコードが含まれています。

このチュートリアルでは、ジェネレーティブ AI アプリケーションの構築に関する主要な課題について説明します。

ツールの作成やエージェントの実行のデバッグなど、一般的なタスクの開発エクスペリエンスを合理化します。
次のような運用上の課題:
- エージェント構成の追跡
- 予測可能な方法で入力と出力を定義する
- 依存関係のバージョンの管理
- バージョン管理とデプロイ
エージェントの品質と信頼性の測定と向上。

わかりやすくするために、このチュートリアルではメモリ内アプローチを使用して、チャンクされた Databricks ドキュメントを含むデータセットに対するキーワード検索を有効にします。モザイク AI ベクター検索を使用してドキュメントのインデックス作成と検索をスケーラブルに行うより現実的な例については、 ChatAgent 例を参照してください。

ノートブックの例

このスタンドアロンノートブックは、サンプルドキュメントコーパスを使用して Mosaic AI エージェントをすばやく操作できるように設計されています。セットアップやデータを必要とせず、実行する準備ができました。

モザイクAIエージェントデモ

ノートブックを入手

エージェントとツールを作成する

Mosaic AI Agent Framework では、さまざまなオーサリングフレームワークがサポートされています。この例では、LangGraph を使用して概念を説明していますが、これは LangGraph チュートリアルではありません。

サポートされているその他のフレームワークの例については、 ChatAgent 例を参照してください。

最初の手順では、エージェントを作成します。 LLM クライアントとツールの一覧を指定する必要があります。 databricks-langchain Python パッケージには、Databricks LLM と Unity カタログに登録されているツールの両方に対応する LangChain と LangGraph 互換のクライアントが含まれています。

エンドポイントは、AI ゲートウェイを使用した関数呼び出しの Foundation Model API または外部モデルである必要があります。「サポートされているモデル」を参照してください。

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

次のコードでは、モデルと一部のツールからエージェントを作成する関数を定義します。このエージェントコードの内部については、このガイドでは説明していません。 LangGraph エージェントを構築する方法の詳細については、 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()

エージェントツールを定義する

ツールは、エージェントを構築するための基本的な概念です。ユーザー定義のコードと LLM を統合する機能を提供します。プロンプトとツールの一覧が表示されると、ツールを呼び出す LLM によって、ツールを呼び出す引数が生成されます。 Mosaic AI エージェントでのツールの使用方法の詳細については、AI エージェントツールを参照してください。

最初の手順では、 TF-IDF に基づいてキーワード抽出ツールを作成します。この例では、scikit-learn と Unity カタログツールを使用します。

databricks-langchain パッケージは、Unity カタログツールを操作するための便利な方法を提供します。次のコードは、キーワード抽出ツールを実装して登録する方法を示しています。

注

Databricks ワークスペースには、サンドボックス実行環境で Python スクリプトを実行する機能を持つエージェントを拡張するために使用できる、 system.ai.python_exec組み込みのツールがあります。その他の便利な組み込みツールには、外部接続と AI 関数が含まれます。

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)

上記のコードの説明を次に示します。

Databricks ワークスペースの Unity カタログを "レジストリ" として使用してツールを作成および検出するクライアントを作成します。
キーワード抽出を実行する Python 関数 TF-IDF 定義します。
Python 関数を Unity カタログ関数として登録します。

このワークフローは、いくつかの一般的な問題を解決します。これで、Unity カタログ内の他のオブジェクトと同様に管理できるツールの中央レジストリが作成されました。たとえば、企業が内部利益率を計算する標準的な方法がある場合は、Unity カタログで関数として定義し、 FinancialAnalyst ロールを持つすべてのユーザーまたはエージェントにアクセス権を付与できます。

このツールを LangChain エージェントで使用できるようにするには、 UCFunctionToolkit を使用します。UCFunctionToolkit を使用して、選択のために LLM に提供するツールのコレクションを作成します。

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

次のコードは、ツールをテストする方法を示しています。

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

次のコードでは、キーワード抽出ツールを使用するエージェントを作成します。

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

結果のトレースでは、LLM によってツールが選択されていることがわかります。

ツールの選択を示すノートブックの MLflow トレース出力。

トレースを使用してエージェントをデバッグする

MLflow Tracing は、エージェントを含む生成 AI アプリケーションをデバッグおよび監視するための強力なツールです。特定のコードセグメントをカプセル化し、入力、出力、タイミングデータを記録するスパンを介して詳細な実行情報をキャプチャします。

LangChain などの一般的なライブラリでは、 mlflow.langchain.autolog()を使用して自動トレースを有効にします。 mlflow.start_span()を使用してトレースをカスタマイズすることもできます。たとえば、ユーザー設定のデータ値フィールドを追加したり、可観測性のためにラベル付けしたりできます。そのスパンのコンテキストで実行されるコードは、定義したフィールドに関連付けられます。このメモリ内 TF-IDF 例では、名前とスパンの種類を指定します。

トレースの詳細については、「 MLflow トレース - 生成 AI の可観測性」を参照してください。

次の例では、単純なインメモリ TF-IDF インデックスを使用して取得ツールを作成します。ツールの実行に対する自動ログ記録と、追加の可観測性のためのカスタムスパントレースの両方を示します。

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

このコードでは、取得ツール用に予約されている特殊なスパン型 ( RETRIEVER) を使用します。その他のモザイク AI エージェント機能 (AI プレイグラウンド、レビュー UI、評価など) では、 RETRIEVER スパンの種類を使用して検索結果を表示します。

取得ツールでは、ダウンストリーム Databricks 機能との互換性を確保するために、スキーマを指定する必要があります。 mlflow.models.set_retriever_schemaの詳細については、「カスタム取得スキーマの指定」を参照してください。

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

メタデータを示す取得結果。

エージェントを定義する

次の手順では、エージェントを評価し、デプロイ用に準備します。大まかに言えば、これには次のものが含まれます。

署名を使用して、エージェントの予測可能な API を定義します。
モデル構成を追加すると、パラメーターを簡単に構成できます。
再現可能な環境を提供し、他のサービスに対する認証を構成できる依存関係を持つモデルをログに記録します。

MLflow ChatAgent インターフェイスは、エージェントの入力と出力の定義を簡略化します。これを使用するには、 ChatAgentのサブクラスとしてエージェントを定義し、 predict 関数を使用して非ストリーミング推論を実装し、 predict_stream 関数を使用したストリーミング推論を実装します。

ChatAgent は、エージェント作成フレームワークの選択に依存しないため、さまざまなフレームワークとエージェントの実装を簡単にテストして使用できます。唯一の要件は、 predict インターフェイスと predict_stream インターフェイスを実装することです。

ChatAgentを使用してエージェントを作成すると、次のような多くの利点があります。

ストリーミング出力のサポート
包括的なツール呼び出しメッセージ履歴: 品質と会話管理を向上させるために、中間ツール呼び出しメッセージを含む複数のメッセージを返します。
マルチエージェントシステムのサポート
Databricks 機能の統合: AI プレイグラウンド、エージェント評価、エージェント監視との互換性が適用済みです。
型指定された作成インターフェイス: IDE とノートブックオートコンプリートの恩恵を受け、型指定された Python クラスを使用してエージェントコードを記述します。

ChatAgentの作成の詳細については、「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)

次のコードは、 ChatAgentの使用方法を示しています。

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

パラメーターを使用してエージェントを構成する

Agent Framework を使用すると、パラメーターを使用してエージェントの実行を制御できます。つまり、LLM エンドポイントの切り替えや、基になるコードを変更せずにさまざまなツールを試すなど、さまざまなエージェント構成をすばやくテストできます。

次のコードでは、モデルの初期化時にエージェントパラメーターを設定する構成ディクショナリを作成します。

エージェントのパラメーター化の詳細については、複数の環境にデプロイするためのエージェントコードのパラメーター化に関するページを参照してください。

)

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

エージェントをログに記録する

エージェントを定義した後、ログに記録する準備ができました。 MLflow では、エージェントのログ記録は、エージェントの構成 (依存関係を含む) を保存して、評価とデプロイに使用できることを意味します。

注

ノートブックでエージェントを開発する場合、MLflow はノートブック環境からエージェントの依存関係を推論します。

ノートブックからエージェントをログに記録するには、モデルを定義するすべてのコードを 1 つのセルに記述し、 %%writefile マジックコマンドを使用してエージェントの定義をファイルに保存します。

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

エージェントがキーワード抽出ツールを実行するために Unity カタログなどの外部リソースにアクセスする必要がある場合は、デプロイ時にリソースにアクセスできるようにエージェントの認証を構成する必要があります。

Databricks リソースの認証を簡略化するには、自動認証パススルーを有効にします。

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

エージェントのログ記録の詳細については、コードベースのログ記録に関するページを参照してください。

エージェントを評価する

次の手順では、エージェントを評価して、そのパフォーマンスを確認します。エージェントの評価は困難であり、次のような多くの質問が発生します。

品質を評価するための適切なメトリックは何ですか? これらのメトリックの出力を信頼するにはどうすればよいですか?
私は多くのアイデアを評価する必要があります - どのように私...
- 評価をすばやく実行して、ほとんどの時間を待つことに費やさないようにすることはできますか？
- これらの異なるバージョンのエージェントを品質、コスト、待機時間で迅速に比較するにはどうすればいいですか？
品質の問題の根本原因をすばやく特定するにはどうすればよいですか?

データサイエンティストまたは開発者は、実際の主題の専門家ではない可能性があります。このセクションの残りの部分では、適切な出力を定義するのに役立つエージェント評価ツールについて説明します。

評価セットを作成する

エージェントの品質の意味を定義するには、メトリックを使用して、評価セットに対するエージェントのパフォーマンスを測定します。「品質」の定義: 評価セットを参照してください。

エージェント評価を使用すると、評価を実行して合成評価セットを作成し、品質を測定できます。その考え方は、一連のドキュメントのようにファクトから始め、それらのファクトを使用して一連の質問を生成して "後方に作業" することです。生成される質問は、いくつかのガイドラインを提供することで条件を設定できます。

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

生成される評価には、次のものが含まれます。

前に説明した 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"}]}

"予期される取得されたコンテンツ" の一覧。取得元スキーマは、 content フィールドと 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"}]

予想されるファクトの一覧。 2 つの応答を比較すると、それらの間の小さな違いを見つけるのが難しい場合があります。予想される事実は、正しい回答と部分的に正しい回答を間違った答えから分離し、AI のジャッジの品質とエージェントで作業する人々の経験の両方を向上させます。
```
["The command must import the MLflow module.","The command must set the registry URI to \"databricks\"."]
```
ここでは SYNTHETIC_FROM_DOC に設定されている source_id フィールド。より完全な評価セットを構築すると、サンプルはさまざまなソースから取得されるため、このフィールドではそれらを区別します。

評価セットの作成の詳細については、「評価セットの合成」を参照してください。

LLM ジャッジを使用してエージェントを評価する

生成される多くの例でエージェントのパフォーマンスを手動で評価すると、スケーリングがうまく行われません。大規模な場合、LLM をジャッジとして使用することは、はるかに合理的な解決策です。エージェント評価を使用するときに使用できる組み込みのジャッジを使用するには、次のコードを使用します。

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
)

MLflow 実験 -- 評価結果。

全体的に 68% のスコアが付いている単純なエージェント。ここでの結果は、使用する構成によって異なる場合があります。 3 つの異なる LLM を比較してコストと品質を比較する実験を実行することは、構成を変更して再評価するのと同じくらい簡単です。

別の LLM、システムプロンプト、または温度設定を使用するようにモデル構成を変更することを検討してください。

これらのジャッジは、人間の専門家が応答を評価するために使用するのと同じガイドラインに従ってカスタマイズできます。 LLM ジャッジの詳細については、組み込みの AI ジャッジ (MLflow 2) を参照してください。

エージェント評価を使用すると、カスタムメトリックを使用して特定のエージェントの品質を測定する方法をカスタマイズできます。評価は統合テストのように、個々のメトリックは単体テストと考えることができます。次の例では、ブール値メトリックを使用して、エージェントが特定の要求に対してキーワード抽出と取得の両方を使用したかどうかを確認します。

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

エージェントはキーワード抽出を使用しません。この問題を解決するにはどうすればよいですか?

カスタムメトリック出力を示す評価結果。

エージェントを展開し監視する

実際のユーザーを使用してエージェントのテストを開始する準備ができたら、Agent Framework は、Mosaic AI Model Serving でエージェントを提供するための実稼働対応ソリューションを提供します。

エージェントを Model Serving にデプロイすると、次の利点があります。

Model Serving は、自動スケーリング、ログ記録、バージョン管理、アクセス制御を管理し、品質エージェントの開発に集中できるようにします。
主題の専門家は、レビューアプリを使用してエージェントと対話し、監視と評価に組み込むことができるフィードバックを提供できます。
ライブトラフィックで評価を実行することで、エージェントを監視できます。ユーザートラフィックには正解データは含まれませんが、LLM ジャッジ (および作成したカスタムメトリック) によって教師なし評価が行われます。

次のコードでは、エージェントをサービスエンドポイントにデプロイします。詳細については、「生成 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
)