Kom igång med Databricks AI-agenter

Den här handledningen går igenom hur du bygger en AI-agent som använder hämtning och verktyg tillsammans. Datamängden består av en delmängd av Databricks-dokumentationen som redan är uppdelad i segment. I den här självstudien skapar du en agent som hämtar dokument baserat på nyckelord.

För enkelhetens skull använder den här självstudien en enkel minnesintern metod som baseras på TF-IDF- för extrahering av nyckelord och nyckelordssökning i dokumenten. Den exempelanteckningsbok innehåller all kod som används i handledningen. Ett mer realistiskt exempel som använder Mosaic AI Vector Search för att skalbart indexeras och söka i dokument finns i ChatAgent exempel.

Den här handledningen beskriver några av de viktigaste utmaningarna med att skapa generativa AI-applikationer.

• Effektivisera utvecklingsupplevelsen för vanliga uppgifter som att skapa verktyg och felsöka agentkörning.
• Operativa utmaningar som:
  • Spårningsagentkonfiguration
  • Definiera indata och utdata på ett förutsägbart sätt
  • Hantera versioner av beroenden
  • Versionskontroll och distribution
• Mäta och förbättra agentens kvalitet och tillförlitlighet.

Se Navigera i den generativa AI-appguiden för en guide till hela utvecklingsprocessen för att skapa en agent.

Exempelanteckningsbok

Den här fristående anteckningsboken är utformad så att du snabbt kan börja arbeta med Mosaic AI-agenter med hjälp av en exempeldokumentkorpus. Den är redo att köras utan installation eller data som krävs.

Demo av Mosaic AI-agent

Hämta anteckningsbok

Skapa en agent och verktyg

Mosaic AI Agent Framework stöder många olika redigeringsramverk. I det här exemplet används LangGraph för att illustrera begrepp, men det här är inte en LangGraph-självstudie.

Exempel på andra ramverk som stöds finns i ChatAgent exempel.

Det första steget är att skapa en agent. Du måste ange en LLM-klient och en lista över verktyg. databricks-langchain Python-paketet innehåller LangChain- och LangGraph-kompatibla klienter för både Databricks LLMs och verktyg som registrerats i Unity Catalog.

Ändpunkten måste vara ett funktionsanrop av ett Foundation Model API eller en extern modell som använder AI Gateway. Se Modeller som stöds.

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

Följande kod definierar en funktion som skapar en agent från modellen och vissa verktyg, och att diskutera de interna funktionerna i den här agentkoden ligger utanför omfånget för den här guiden. Mer information om hur du skapar en LangGraph-agent finns i LangGraph-dokumentation.

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

Definiera agentverktyg

Verktyg är ett grundläggande begrepp för byggagenter. De ger möjlighet att integrera LLM:er med mänskligt definierad kod. När en uppmaning och en lista över verktyg tillhandahålls genererar en verktygsanropande LLM argumenten för att anropa verktyget. Mer information om verktyg och hur du använder dem med Mosaic AI-agenter finns i AI-agentverktyg.

Det första steget är att skapa ett extraheringsverktyg för nyckelord baserat på TF-IDF. I det här exemplet används scikit-learn och ett Unity Catalog-verktyg.

databricks-langchain-paketet är ett bekvämt sätt att arbeta med Unity Catalog-verktyg. Följande kod visar hur du implementerar och registrerar ett nyckelordsextraktorverktyg.

Anmärkning

Databricks-arbetsytan har ett inbyggt verktyg, system.ai.python_exec, som du kan använda för att utöka agenters möjlighet att köra Python-skript i en sandlådsmiljö för körning. Andra användbara inbyggda verktyg är externa anslutningar och AI-funktioner.

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)

Här är en förklaring av koden ovan:

1. Skapar en klient som använder Unity Catalog på Databricks-arbetsytan som ett "register" för att skapa och identifiera verktyg.
2. Definierar en Python-funktion som utför TF-IDF extrahering av nyckelord.
3. Registrerar Python-funktionen som en Unity Catalog-funktion.

Det här arbetsflödet löser flera vanliga problem. Nu har du ett centralt register för verktyg som, precis som andra objekt i Unity Catalog, kan styras. Om ett företag till exempel har ett standardsätt för att beräkna intern avkastningshastighet kan du definiera det som en funktion i Unity Catalog och bevilja åtkomst till alla användare eller agenter med rollen FinancialAnalyst.

För att göra det här verktyget användbart för en LangChain-agent, använd [UCFunctionToolkit](/generative-ai/agent-framework/create-custom-tool.md] som skapar en samling verktyg så att LLM kan välja:

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

Följande kod visar hur du testar verktyget:

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

Följande kod skapar en agent som använder nyckelordsextraheringsverktyget.

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

I det resulterande spåret kan du se att LLM valde verktyget.

Använda spårningar för att felsöka agenter

MLflow Tracing är ett kraftfullt verktyg för att felsöka och observera generativa AI-program, inklusive agenter. Den samlar in detaljerad körningsinformation via spänner, som kapslar in specifika kodsegment och registrera indata, utdata samt tiddata.

För populära bibliotek som LangChain aktiverar du automatisk spårning med mlflow.langchain.autolog(). Du kan också använda mlflow.start_span() för att anpassa en spårning. Du kan till exempel lägga till anpassade datavärdefält eller etiketter för observerbarhet. Koden som körs i kontexten för det intervallet associeras med fält som du definierar. I det här minnesinterna TF-IDF-exemplet, ge det ett namn och en spantyp.

Mer information om spårning finns i Agentobservabilitet med MLflow Tracing.

I följande exempel skapas ett hämtningsverktyg med hjälp av ett enkelt minnesinternt TF-IDF index. Den visar både automatisk loggning för verktygskörningar och anpassad spanspårning för ytterligare observerbarhet:

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

Den här koden använder en särskild span-typ, RETRIEVER, som är reserverad för hämtningsverktyg. Andra mosaic AI-agentfunktioner (till exempel AI Playground, granska användargränssnittet och utvärderingen) använder RETRIEVER spännviddstyp för att visa hämtningsresultatet.

Hämtarverktyg kräver att du anger deras schema för att säkerställa kompatibilitet med nedströms Databricks-funktioner. Mer information om mlflow.models.set_retriever_schemafinns i Ange anpassade hämtningsscheman.

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

Definiera agenten

Nästa steg är att utvärdera agenten och förbereda den för distribution. På hög nivå innebär detta följande:

1. Definiera ett förutsägbart API för agenten med hjälp av en signatur.
2. Lägg till modellkonfiguration, vilket gör det enkelt att konfigurera parametrar.
3. Logga modellen med beroenden som ger den en reproducerbar miljö och gör att du kan konfigurera dess autentisering till andra tjänster.

MLflow-ChatAgent-gränssnittet förenklar definitionen av agentindata och utdata. Om du vill använda den definierar du din agent som en underklass av ChatAgentoch implementerar slutsatsdragning utan direktuppspelning med funktionen predict och strömningsslutsats med funktionen predict_stream.

ChatAgent är oberoende för ditt val av agentredigeringsramverk, så att du enkelt kan testa och använda olika ramverk och agentimplementeringar – det enda kravet är att implementera predict- och predict_stream-gränssnitten.

Att redigera din agent med hjälp av ChatAgent ger ett antal fördelar, bland annat:

• Stöd för streamingutdata
• Omfattande meddelandehistorik för verktygssamtal: Returnera flera meddelanden, inklusive mellanliggande verktygssamtalsmeddelanden, för bättre kvalitet och konversationshantering.
• systemstöd för flera agenter
• Databricks-funktionsintegrering: out-of-the-box-kompatibilitet med AI Playground, agentutvärdering och agentövervakning.
• Typed authoring interfaces: Skriv agentkod med typade Python-klasser och dra nytta av IDE och notebook-autocomplete.

Mer information om hur du redigerar en ChatAgent finns i Använda ChatAgent för att skapa agenter.

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)

Följande kod visar hur du använder ChatAgent.

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

Konfigurera agenter med parametrar

Med Agent Framework kan du styra agentkörningen med parametrar. Det innebär att du snabbt kan testa olika agentkonfigurationer, till exempel byta LLM-slutpunkter eller prova olika verktyg utan att ändra den underliggande koden.

Följande kod skapar en konfigurationsordlista som anger agentparametrar när modellen initieras.

Mer information om hur du parameteriserar agenter finns i Parametrize-agentkod för distribution mellan miljöer.

)

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

Logga agenten

När du har definierat agenten är den nu redo att loggas. I MLflow innebär loggning av en agent att agentens konfiguration (inklusive beroenden) sparas så att den kan användas för utvärdering och distribution.

Anmärkning

När du utvecklar agenter i en notebook-fil härleder MLflow agentens beroenden från notebook-miljön.

Om du vill logga en agent från en notebook-fil kan du skriva all kod som definierar modellen i en enda cell och sedan använda det %%writefile magiska kommandot för att spara agentens definition i en fil:

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

Om agenten kräver åtkomst till externa resurser, till exempel Unity Catalog för att köra nyckelordsextraheringsverktyget, måste du konfigurera autentisering för agenten så att den kan komma åt resurserna när den distribueras.

För att förenkla autentiseringen för Databricks-resurser, aktivera automatisk autentiseringspassering:

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

Mer information om loggningsagenter finns i Kodbaserad loggning.

Utvärdera agenten

Nästa steg är att utvärdera agenten för att se hur den fungerar. Agentutvärdering är utmanande och väcker många frågor, till exempel följande:

• Vilka är rätt mått för att utvärdera kvalitet? Hur litar jag på utdata från dessa mått?
• Jag behöver utvärdera många idéer - hur gör jag ...
  • kör utvärderingen snabbt så att större delen av min tid inte ägnas åt att vänta?
  • Jämför snabbt dessa olika versioner av min agent utifrån kvalitet, kostnad och svarstid.
• Hur identifierar jag snabbt rotorsaken till eventuella kvalitetsproblem?

Som dataexpert eller utvecklare kanske du inte är den faktiska ämnesexperten. Resten av det här avsnittet beskriver verktyg för agentutvärdering som kan hjälpa dig att definiera bra utdata.

Skapa en utvärderingsuppsättning

För att definiera vad kvalitet betyder för en agent använder du mått för att mäta agentens prestanda på en utvärderingsuppsättning. Se Definiera "kvalitet": Utvärderingsset.

Med Agentutvärdering kan du skapa syntetiska utvärderingsuppsättningar och mäta kvalitet genom att köra utvärderingar. Tanken är att börja med fakta, som en uppsättning dokument, och "arbeta bakåt" genom att använda dessa fakta för att generera en uppsättning frågor. Du kan villkora de frågor som genereras genom att tillhandahålla några riktlinjer:

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

Bland de genererade utvärderingarna finns följande:

• Ett begärandefält som ser ut som det ChatAgentRequest som nämnts tidigare:

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

• En lista över "förväntat hämtat innehåll". Hämtarschemat definierades med fälten content och 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"}]
  

• En lista över förväntade fakta. När du jämför två svar kan det vara svårt att hitta små skillnader mellan dem. Förväntade fakta destillerar vad som skiljer ett korrekt svar från ett delvis korrekt svar från ett felaktigt svar och förbättrar både AI-bedömarnas kvalitet, liksom upplevelsen av de personer som arbetar med agenten.

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

• Ett source_id fält som här är SYNTHETIC_FROM_DOC. När du skapar mer kompletta utvärderingsuppsättningar kommer exemplen från olika källor, så det här fältet skiljer dem åt.

Mer information om hur du skapar utvärderingsuppsättningar finns i Syntetisera utvärderingsuppsättningar.

Utvärdera agenten med hjälp av LLM-domare

Att manuellt utvärdera en agents prestanda på så många genererade exempel kommer inte att skala bra. I stor skala är det mycket mer rimligt att använda LLM:er som domare. Använd följande kod för att använda de inbyggda domare som är tillgängliga när du använder agentutvärdering:

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
)

Den enkla agenten fick totalt 68%. Dina resultat kan variera här beroende på vilken konfiguration du använder. Att köra ett experiment för att jämföra tre olika LLM:er för kostnad och kvalitet är lika enkelt som att ändra konfigurationen och utvärdera igen.

Överväg att ändra modellkonfigurationen så att den använder en annan LLM-inställning, systemprompt eller temperaturinställning.

Dessa domare kan anpassas för att följa samma riktlinjer som mänskliga experter skulle använda för att utvärdera ett svar. För mer information om domare med LLM, se inbyggda AI-domare .

Med Agentutvärdering kan du anpassa hur du mäter kvaliteten på en viss agent med hjälp av anpassade mått. Du kan se utvärderingen som ett integrationstest och enskilda mått som enhetstester. I följande exempel används ett booleskt mått för att kontrollera om agenten använde både nyckelordsextraheringen och hämtaren för en viss begäran:

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

Observera att agenten aldrig använder nyckelordsextraheringen. Hur kan du åtgärda det här problemet?

Distribuera och övervaka agenten

När du är redo att börja testa din agent med riktiga användare tillhandahåller Agent Framework en produktionsklar lösning för att betjäna agenten på Mosaic AI Model Serving.

När du distribuerar agenter till Modellservern får du följande fördelar:

• Modellservern hanterar automatisk skalning, loggning, versionskontroll och åtkomstkontroll, så att du kan fokusera på att utveckla kvalitetsagenter.
• Ämnesexperter kan använda granskningsappen för att interagera med agenten och ge feedback som kan införlivas i dina övervaknings- och utvärderingar.
• Du kan övervaka agenten genom att göra utvärderingar av trafik i realtid. Även om användartrafiken inte innehåller grundsanningen utför LLM-domare (och det anpassade mått som du skapade) en oövervakad utvärdering.

Följande kod distribuerar agenterna till en serverslutpunkt. För mer information, se Distribuera en agent för generativ AI-applikation.

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
)