Agenthulpprogramma's maken met Unity Catalog-functies

Gebruik Unity Catalog-functies wanneer je agent vooraf gedefinieerde logica moet uitvoeren, zoals een SQL-query waarvan de agent de parameters levert. Voor andere tools, begin met MCP's.

Deze gids gebruikt Unity Catalog AI om een kleine Python-functie te maken, deze te testen en toe te voegen aan een agent met behulp van het framework van jouw keuze. Als je al een functie hebt, installeer dan de bibliotheken in stap 1 en ga naar stap 3.

Requirements

• Een Azure Databricks notebook met Python 3.10 of hoger. Op klassieke compute gebruik je Databricks Runtime 15.0 of hoger.
• Serverless compute ingeschakeld in je werkruimte. De Function Client gebruikt serverless algemene compute om tools uit te voeren; een SQL-warehouse alleen is niet voldoende.
• USE CATALOG en USE SCHEMA voor de oudercatalogus en het schema van de functie. Het creëren van een functie vereist ook CREATE FUNCTION op het schema; het aanroepen van een bestaande functie vereist EXECUTE op die functie. Zie Functieprivileges.
• Een model dat tool calling ondersteunt. Het voorbeeld van LangGraph gebruikt een Azure Databricks model endpoint. De voorbeelden van OpenAI, Anthropic en LlamaIndex gebruiken provider-API-inloggegevens, zoals beschreven in hun tabbladen.

Stap 1: Installeer de bibliotheken

Voer het installatiecommando voor je framework uit in een notebookcel:

Voor pakketbroncode, zie de Unity Catalog AI-repository.

Vervolgens start je Python opnieuw in een aparte cel:

dbutils.library.restartPython()

Stap 2: Maak een functie aan en test deze

Gebruik DatabricksFunctionClient om de functie te maken en te testen. Vervang my_catalog en my_schema door een bestaande catalogus en een bestaand schema waar je functies kunt aanmaken. Dit voorbeeld creëert add_numbers; kies een andere naam als die al bestaat.

from unitycatalog.ai.core.databricks import DatabricksFunctionClient

client = DatabricksFunctionClient()
CATALOG = "my_catalog"
SCHEMA = "my_schema"


def add_numbers(number_1: float, number_2: float) -> float:
    """Add two numbers.

    Args:
        number_1: The first number to add.
        number_2: The second number to add.

    Returns:
        The sum of the two numbers.
    """
    return number_1 + number_2


client.create_python_function(func=add_numbers, catalog=CATALOG, schema=SCHEMA)

result = client.execute_function(
    function_name=f"{CATALOG}.{SCHEMA}.add_numbers",
    parameters={"number_1": 2.0, "number_2": 3.0},
)
if result.error:
    raise RuntimeError(result.error)
print(result.value)  # 5.0

Stap 3: Gebruik de functie in je agent

Stel function_name in op de volledige naam van je functie en voer vervolgens het voorbeeld uit voor je framework. Elk gebruikt UCFunctionToolkit om de functie direct aan te roepen.

from unitycatalog.ai.core.databricks import DatabricksFunctionClient

function_name = "my_catalog.my_schema.add_numbers"
client = DatabricksFunctionClient()
question = "Use the tool to add 2.0 and 3.0."

LangGraph

Dit voorbeeld gebruikt het databricks-claude-sonnet-4-5 eindpunt. Vervang het door een tool-calling-model dat beschikbaar is in je workspace.

from databricks_langchain import ChatDatabricks, UCFunctionToolkit
from langgraph.prebuilt import create_react_agent

toolkit = UCFunctionToolkit(function_names=[function_name], client=client)
agent = create_react_agent(
    ChatDatabricks(endpoint="databricks-claude-sonnet-4-5"),
    tools=toolkit.tools,
)
result = agent.invoke({"messages": [{"role": "user", "content": question}]})
print(result["messages"][-1].content)

Zie de referentie voor LangChain-integratie.

OpenAI

Stel de OPENAI_API_KEY en OPENAI_MODEL omgevingsvariabelen in voor je notebookproces. Gebruik een model dat tool-aanroepen ondersteunt en sla de API-sleutel op in een Azure Databricks secret.

import os
from openai import OpenAI
from unitycatalog.ai.openai.toolkit import UCFunctionToolkit
from unitycatalog.ai.openai.utils import generate_tool_call_messages

toolkit = UCFunctionToolkit(function_names=[function_name], client=client)
model_client = OpenAI()
messages = [{"role": "user", "content": question}]

for _ in range(10):
    response = model_client.chat.completions.create(
        model=os.environ["OPENAI_MODEL"],
        messages=messages,
        tools=toolkit.tools,
    )
    if not response.choices[0].message.tool_calls:
        print(response.choices[0].message.content)
        break
    messages.extend(generate_tool_call_messages(response=response, client=client))
else:
    raise RuntimeError("The agent reached the tool-calling limit.")

De helper voert de gevraagde functies uit en formatteert zijn resultaten voor de volgende modelaanroep. Zie de OpenAI-integratiereferentie.

Anthropic

Stel de ANTHROPIC_API_KEY en ANTHROPIC_MODEL omgevingsvariabelen in voor je notebookproces. Gebruik een model dat tool-aanroepen ondersteunt en sla de API-sleutel op in een Azure Databricks secret.

import os
from anthropic import Anthropic
from unitycatalog.ai.anthropic.toolkit import UCFunctionToolkit
from unitycatalog.ai.anthropic.utils import generate_tool_call_messages

toolkit = UCFunctionToolkit(function_names=[function_name], client=client)
model_client = Anthropic()
messages = [{"role": "user", "content": question}]

for _ in range(10):
    response = model_client.messages.create(
        model=os.environ["ANTHROPIC_MODEL"],
        max_tokens=1024,
        tools=toolkit.tools,
        messages=messages,
    )
    if response.stop_reason != "tool_use":
        print("\n".join(block.text for block in response.content if block.type == "text"))
        break
    messages.extend(
        generate_tool_call_messages(
            response=response, client=client, conversation_history=[],
        )
    )
else:
    raise RuntimeError("The agent reached the tool-calling limit.")

De helper voert de gevraagde functies uit. Voeg de berichten ervan toe aan het gesprek vóór de volgende modelcall. Zie de referentie voor Anthropic integratie.

LlamaIndex

Dit voorbeeld gebruikt een OpenAI-model. Stel de OPENAI_API_KEY en OPENAI_MODEL omgevingsvariabelen in voor je notebook-proces. Gebruik een model dat tool-aanroepen ondersteunt en sla de API-sleutel op in een Azure Databricks secret.

import os
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai import OpenAI
from unitycatalog.ai.llama_index.toolkit import UCFunctionToolkit

toolkit = UCFunctionToolkit(function_names=[function_name], client=client)
agent = FunctionAgent(
    tools=toolkit.tools,
    llm=OpenAI(model=os.environ["OPENAI_MODEL"]),
)
result = await agent.run(user_msg=question)
print(result)

Voer de laatste twee regels uit in een notebookcel die await ondersteunt. Zie de LlamaIndex-integratiereferentie.

De agent roept add_numbers en geeft een antwoord terug met 5. Als je een bestaande functie gebruikt, verander question dan naar een taak die door die functie wordt ondersteund.

Voor implementatie en authenticatie, zie Bouw een aangepaste agent en agentauthenticatie.

Lokaal ontwikkelen

Voor het testen van vertrouwde Python-functies, initialiseer je de client met execution_mode="local" en geef je deze door aan de toolkit van je framework:

client = DatabricksFunctionClient(execution_mode="local")
toolkit = UCFunctionToolkit(function_names=[function_name], client=client)

Lokale modus haalt de functie op uit Unity Catalog en voert deze uit in een lokaal subproces. Het ondersteunt geen SQL-functies. Gebruik de standaard serverless modus voor productie en voer alleen vertrouwde code uit. Zie Uitvoeringsmodi.

Voor timeouts, geheugenlimieten en serverloze instellingen, zie de lokale uitvoeringslimieten en Function Client-omgevingsvariabelen.

Gebruik het MCP-eindpunt voor de werkruimte (legacy)

Voor bestaande MCP-integraties verbindt dit LangGraph-voorbeeld met dezelfde functie via het legacy workspace-endpoint. Schakel de Managed MCP Servers preview in en gebruik een identiteit met toegang tot de functie.

Voer %pip install --upgrade databricks-langchain langgraph "mcp>=1.24,<2" uit in een notebookcel en start dan Python opnieuw op. Vervang my_catalog/my_schema/add_numbers door het pad van je functie.

from databricks.sdk import WorkspaceClient
from databricks_langchain import (
    ChatDatabricks,
    DatabricksMCPServer,
    DatabricksMultiServerMCPClient,
)
from langchain_core.messages import convert_to_openai_messages
from langgraph.prebuilt import create_react_agent

workspace_client = WorkspaceClient()
function_path = "my_catalog/my_schema/add_numbers"
mcp_client = DatabricksMultiServerMCPClient([
    DatabricksMCPServer(
        name="uc-functions",
        url=f"{workspace_client.config.host}/api/2.0/mcp/functions/{function_path}",
        workspace_client=workspace_client,
    ),
])
agent = create_react_agent(
    ChatDatabricks(endpoint="databricks-claude-sonnet-4-5"),
    tools=await mcp_client.get_tools(),
    prompt=lambda state: convert_to_openai_messages(state["messages"]),
)
result = await agent.ainvoke({
    "messages": [{"role": "user", "content": "Use the tool to add 2.0 and 3.0."}],
})
print(result["messages"][-1].content)

Voor uitrol, zie Agent-authenticatie. Voor een functie die een externe API aanroept met http_request, zie Legacy REST API-tools.