Informe-se com Databricks AI agentes
Este site tutorial orienta o senhor na criação de um agente AI que usa recuperação e ferramentas em conjunto. O site dataset consiste em um subconjunto da documentação da Databricks que já está dividido em partes. Neste tutorial, o senhor cria um agente que recupera documentos com base em palavras-chave.
Para simplificar, este tutorial usa uma abordagem simples na memória com base no TF-IDF para extração de palavras-chave e pesquisa de palavras-chave nos documentos. O Notebook de exemplo inclui todo o código usado no site tutorial. Para ver um exemplo mais realista que usa o Mosaic AI Vector Search para indexar e pesquisar documentos em escala, consulte os exemplosChatAgent.
Este site tutorial aborda alguns dos principais desafios da criação de aplicativos AI generativos:
-
Simplificando a experiência de desenvolvimento para tarefas comuns, como a criação de ferramentas e a execução de agentes de depuração.
-
Desafios operacionais, como:
- acompanhamento da configuração do agente
- Definindo entradas e saídas de forma previsível
- Gerenciando versões de dependências
- Controle e implantação de versões
-
Medir e melhorar a qualidade e a confiabilidade de um agente.
Consulte Navigate the generative AI app guia para obter um guia sobre todo o processo de desenvolvimento de um agente.
Exemplo de notebook
Este Notebook autônomo foi criado para que o senhor comece a trabalhar rapidamente com os agentes do Mosaic AI usando um corpus de documentos de amostra. Ele está pronto para ser executado, sem necessidade de configuração ou dados.
Mosaic AI demonstração do agente
Crie um agente e ferramentas
O Mosaic AI Agent Framework é compatível com muitas estruturas de criação diferentes. Este exemplo usa o LangGraph para ilustrar conceitos, mas este não é um tutorial sobre o LangGraph.
Para ver exemplos de outras estruturas compatíveis, consulte ChatAgent examples.
A primeira etapa é criar um agente. O senhor deve especificar um cliente LLM e uma lista de ferramentas. O pacote databricks-langchain Python inclui clientes compatíveis com LangChain e LangGraph para LLMs da Databricks e ferramentas registradas no Unity Catalog.
O endpoint deve ser um modelo de fundação de chamada de função API ou um modelo externo usando o gateway AI. Consulte Modelos compatíveis.
from databricks_langchain import ChatDatabricks
llm = ChatDatabricks(endpoint="databricks-meta-llama-3-3-70b-instruct")
O código a seguir define uma função que cria um agente a partir do modelo e de algumas ferramentas; discutir os aspectos internos desse código de agente está fora do escopo deste guia. Para obter mais informações sobre como criar um agente LangGraph, consulte a documentação do 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()
Defina as ferramentas do agente
As ferramentas são um conceito fundamental para agentes de construção. Eles fornecem a capacidade de integrar LLMs com código definido por humanos. Quando é fornecido um prompt e uma lista de ferramentas, um LLM de chamada de ferramenta gera os argumentos para invocar a ferramenta. Para obter mais informações sobre ferramentas e como usá-las com agentes Mosaic AI, consulte AI agent tools.
A primeira etapa é criar uma ferramenta de extração de palavras-chave baseada no TF-IDF. Este exemplo usa o scikit-learn e uma ferramenta do Unity Catalog.
O pacote databricks-langchain oferece uma maneira conveniente de trabalhar com as ferramentas do Unity Catalog. O código a seguir ilustra como implementar e registrar uma ferramenta de extração de palavras-chave.
O Databricks workspace tem uma ferramenta integrada, system.ai.python_exec, que o senhor pode usar para estender os agentes com a capacidade de executar scripts Python em um ambiente de execução em sandbox. Outras ferramentas úteis de integração incluem conexões externas e funções do siteAI.
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)
Aqui está uma explicação do código acima:
- Cria um cliente que usa Unity Catalog no Databricks workspace como um "registro" para criar e descobrir ferramentas.
- Define uma função Python que executa a extração de palavras-chave TF-IDF.
- registrar a função Python como uma função Unity Catalog.
Esse fluxo de trabalho resolve vários problemas comuns. Agora o senhor tem um registro central para ferramentas que, assim como outros objetos no Unity Catalog, podem ser controlados. Por exemplo, se uma empresa tem uma forma padrão de calcular a taxa interna de retorno, o senhor pode defini-la como uma função no Unity Catalog e conceder acesso a todos os usuários ou agentes com a função FinancialAnalyst.
Para tornar essa ferramenta utilizável por um agente LangChain, use o UCFunctionToolkit, que cria uma coleção de ferramentas a serem fornecidas ao LLM para seleção:
# 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)
O código a seguir mostra como testar a ferramenta:
uc_toolkit.tools[0].invoke({ "text": "The quick brown fox jumped over the lazy brown dog." })
O código a seguir cria um agente que usa a ferramenta de extração de palavras-chave.
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'?"}]})
No rastreamento resultante, o senhor pode ver que o LLM selecionou a ferramenta.
Use rastreamentos para depurar agentes
MLflow O rastreamento é uma ferramenta poderosa para depuração e observação de aplicativos generativos AI, incluindo agentes. Ele captura informações detalhadas sobre a execução por meio de vãos, que encapsulam segmentos de código específicos e registram entradas, saídas e dados de tempo.
Para bibliotecas populares como LangChain, ative o rastreamento automático com mlflow.langchain.autolog(). Você também pode usar mlflow.start_span() para personalizar um rastreamento. Por exemplo, o senhor pode adicionar campos de valor de dados personalizados ou rótulo para observabilidade. O código que é executado no contexto desse intervalo é associado aos campos que o senhor define. Neste exemplo de TF-IDF na memória, dê a ele um nome e um tipo de extensão.
Para saber mais sobre o rastreamento, consulte Observabilidade do agente com o MLflow Tracing.
O exemplo a seguir cria uma ferramenta de recuperação usando um índice TF-IDF simples na memória. Ele demonstra o registro automático para execuções de ferramentas e o rastreamento de abrangência personalizado para maior observabilidade:
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
Esse código usa um tipo de extensão especial, RETRIEVER, que é reservado para ferramentas de recuperação. Outros recursos do agente Mosaic AI (como o AI Playground, a UI de revisão e a avaliação) usam o tipo de intervalo RETRIEVER para exibir os resultados da recuperação.
As ferramentas de recuperação exigem que o senhor especifique o esquema delas para garantir a compatibilidade com o recurso Databricks downstream. Para obter mais informações sobre mlflow.models.set_retriever_schema, consulte Especificar esquemas de retriever personalizados.
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?")]})
Defina o agente
A próxima etapa é avaliar o agente e prepará-lo para implantação. Em um alto nível, isso envolve o seguinte:
- Defina uma API previsível para o agente usando uma assinatura.
- Adicione a configuração do modelo, o que facilita a configuração dos parâmetros.
- registre o modelo com dependências que proporcionam um ambiente reproduzível e permitem que o senhor configure sua autenticação em outro serviço.
A interface MLflow ChatAgent simplifica a definição das entradas e saídas do agente. Para usá-lo, defina seu agente como uma subclasse de ChatAgent, implementando a inferência de não transmissão com a função predict e a inferência de transmissão com a função predict_stream.
ChatAgent é independente de sua escolha de estrutura de criação de agentes, permitindo que você teste e use facilmente diferentes estruturas e implementações de agentes. O único requisito é implementar as interfaces predict e predict_stream.
Criar seu agente usando ChatAgent oferece vários benefícios, incluindo:
- suporte de saída de transmissão
- Histórico abrangente de mensagens de tool-calling : Retorna várias mensagens, inclusive mensagens intermediárias de chamadas de ferramentas, para melhorar a qualidade e o gerenciamento de conversas.
- Suporte a sistemas multiagentes
- Databricks integração de recursos: Compatibilidade imediata com AI Playground, avaliação de agentes e monitoramento de agentes.
- Interfaces de criação digitadas : Escreva o código do agente usando classes Python digitadas, beneficiando-se do preenchimento automático do IDE e do Notebook.
Para obter mais informações sobre a criação de um ChatAgent, consulte Use ChatAgent to author agents.
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)
O código a seguir mostra como usar o ChatAgent.
AGENT = DocsAgent(agent=agent)
AGENT.predict(
{
"messages": [
{"role": "user", "content": "What is DLT in Databricks?"},
]
}
)
Configurar agentes com parâmetros
O Agent Framework permite controlar a execução do agente com parâmetros. Isso significa que o senhor pode testar rapidamente diferentes configurações de agente, como alternar o endpoint LLM ou experimentar diferentes ferramentas sem alterar o código subjacente.
O código a seguir cria um dicionário de configuração que define os parâmetros do agente ao inicializar o modelo.
Para obter mais detalhes sobre a parametrização de agentes, consulte Parametrizar o código do agente para implantação em ambientes.
)
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
registrar o agente
Depois de definir o agente, ele está pronto para ser registrado. No MLflow, registrar um agente significa salvar a configuração do agente (incluindo dependências) para que ele possa ser usado para avaliação e implantação.
Ao desenvolver agentes em um Notebook, o site MLflow infere as dependências do agente a partir do ambiente do Notebook.
Para log um agente de um Notebook, o senhor pode escrever todo o código que define o modelo em uma única célula e, em seguida, usar o comando mágico %%writefile para salvar a definição do agente em um arquivo:
%%writefile agent.py
...
<Code that defines the agent>
Se o agente precisar de acesso a um recurso externo, como Unity Catalog para executar a ferramenta de extração de palavras-chave, o senhor deverá configurar a autenticação para o agente para que ele possa acessar o recurso quando for implantado.
Para simplificar a autenticação para Databricks recurso, ative a passagem automática de autenticação:
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,
)
Para saber mais sobre agentes de registro, consulte Registro baseado em código.
Avalie o agente
A próxima etapa é avaliar o agente para ver como ele funciona. A avaliação de agentes é desafiadora e levanta muitas questões, como as seguintes:
-
Quais são as métricas corretas para avaliar a qualidade? Como posso confiar nos resultados dessas métricas?
-
Preciso avaliar muitas ideias - como faço para...
- avaliação de execução rapidamente para que a maior parte do meu tempo não seja gasto esperando?
- compara rapidamente essas diferentes versões do meu agente em termos de qualidade, custo e latência?
-
Como identifico rapidamente a causa raiz de qualquer problema de qualidade?
Como cientista de dados ou desenvolvedor, o senhor pode não ser o verdadeiro especialista no assunto. O restante desta seção descreve as ferramentas de avaliação de agentes que podem ajudar você a definir uma boa saída.
Crie um conjunto de avaliação
Para definir o que significa qualidade para um agente, o senhor usa métricas para medir o desempenho do agente em um conjunto de avaliação. Consulte Definir “qualidade”: conjuntos de avaliação.
Com a Avaliação de Agentes, você pode criar conjuntos de avaliação sintéticos e medir a qualidade executando avaliações. A ideia é começar com os fatos, como um conjunto de documentos, e "trabalhar para trás" usando esses fatos para gerar um conjunto de perguntas. Você pode condicionar as perguntas geradas fornecendo algumas diretrizes:
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,
)
As avaliações geradas incluem o seguinte:
-
Um campo de solicitação que se parece com o
ChatAgentRequestmencionado anteriormente:Python{"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"}]} -
Uma lista de “conteúdo recuperado esperado”. O esquema do recuperador foi definido com os campos
contentedoc_uri.Python[{"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"}] -
Uma lista de fatos esperados. Quando você compara duas respostas, pode ser difícil encontrar pequenas diferenças entre elas. Os fatos esperados destilam o que separa uma resposta correta de uma resposta parcialmente correta de uma resposta incorreta e melhoram tanto a qualidade dos juízes do AI quanto a experiência das pessoas que trabalham no agente:
Python["The command must import the MLflow module.","The command must set the registry URI to \"databricks\"."] -
Um campo source_id que aqui é
SYNTHETIC_FROM_DOC. À medida que você cria conjuntos de avaliação mais completos, as amostras virão de várias fontes diferentes, portanto, esse campo as distingue.
Para saber mais sobre a criação de conjuntos de avaliação, consulte Sintetizar conjuntos de avaliação.
Avaliar o agente usando juízes LLM
Avaliar manualmente o desempenho de um agente em tantos exemplos gerados não é uma boa ideia. Em escala, usar LLMs como juízes é uma solução muito mais razoável. Para usar os juízes integrados que estão disponíveis ao usar a Avaliação de agentes, use o seguinte código:
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
)
O agente simples obteve uma pontuação geral de 68%. Seus resultados podem ser diferentes aqui, dependendo da configuração que você usa. Executar um experimento para comparar três LLMs diferentes em termos de custo e qualidade é tão simples quanto alterar a configuração e reavaliar.
Considere a possibilidade de alterar a configuração do modelo para usar um LLM, prompt do sistema ou configuração de temperatura diferentes.
Esses juízes podem ser personalizados para seguir as mesmas diretrizes que especialistas humanos usariam para avaliar uma resposta. Para obter mais informações sobre os juízes do site LLM, consulte integrada AI judges.
Com a Avaliação de agentes, o senhor pode personalizar a maneira como mede a qualidade de um agente específico usando métricas personalizadas. O senhor pode pensar na avaliação como um teste de integração e nas métricas individuais como testes de unidade. O exemplo a seguir usa um Boolean métricas para verificar se o agente usou tanto a extração de palavras-chave quanto o retriever para uma determinada solicitação:
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],
)
Observe que o agente nunca usa a extração de palavras-chave. Como você pode corrigir esse problema?
implantado e monitorado o agente
Quando o senhor estiver pronto para começar a testar seu agente com usuários reais, o Agent Framework oferece soluções prontas para produção para servir o agente em Mosaic AI Model Serving.
O uso de agentes implantados para atender ao modelo oferece os seguintes benefícios:
- servindo modelo gerenciar autoscale, logging, controle de versão e controle de acesso, permitindo que o senhor se concentre no desenvolvimento de agentes de qualidade.
- Os especialistas no assunto podem usar o Review App para interagir com o agente e fornecer feedback que pode ser incorporado ao monitoramento e às avaliações.
- Você pode monitorar o agente executando avaliações do tráfego ao vivo. Embora o tráfego de usuários não inclua a verdade básica, os juízes do LLM (e as métricas personalizadas que o senhor criou) realizam uma avaliação não supervisionada.
O código a seguir implanta os agentes em um servidor endpoint. Para obter mais informações, consulte implantado um agente para aplicativos generativos 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
)