Skapa agentverktyg med hjälp av Unity Catalog-funktioner

Använd Unity Catalog-funktioner när din agent behöver köra fördefinierad logik, som en SQL-fråga vars parametrar agenten tillhandahåller. För andra verktyg, börja med MCP:er.

Den här guiden använder Unity Catalog AI för att skapa en liten Python-funktion, testa den och lägga till den i en agent med hjälp av ditt valda ramverk. Om du redan har en funktion, installera biblioteken i steg 1 och gå till steg 3.

Requirements

• En Azure Databricks notebook med Python 3.10 eller högre. I klassisk beräkning använder du Databricks Runtime 15.0 eller högre.
• Serverless-datorkraft aktiverad i din arbetsmiljö. Function Client använder serverlös allmän beräkning för att köra verktyg; ett SQL warehouse ensamt räcker inte.
• USE CATALOG och USE SCHEMA på funktionens överordnade katalog och schema. Att skapa en funktion kräver CREATE FUNCTION också på schemat; anrop av en befintlig funktion kräver EXECUTE på den. Se Funktionsprivilegier.
• En modell som stödjer verktygsanrop. Exemplet med LangGraph använder en Azure Databricks-modell-endpoint. Exemplen med OpenAI, Anthropic och LlamaIndex använder leverantörens API-uppgifter, som beskrivs i deras flikar.

Steg 1: Installera biblioteken

Kör installationskommandot för ditt ramverk i en anteckningsbokscell:

För källkod för paket, se Unity Catalog AI repository.

Starta sedan om Python i en separat cell:

dbutils.library.restartPython()

Steg 2: Skapa och testa en funktion

Använd DatabricksFunctionClient för att skapa och testa funktionen. Ersätt my_catalog och my_schema med en befintlig katalog och ett schema där du kan skapa funktioner. Detta exempel skapar add_numbers; välj ett annat namn om det redan finns.

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

Steg 3: Använd funktionen i din agent

Ställ function_name in på din funktions fullständiga namn och kör sedan exemplet för ditt ramverk. Var och en använder UCFunctionToolkit för att anropa funktionen direkt.

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

Detta exempel använder databricks-claude-sonnet-4-5 endpoint. Ersätt den med en verktygsanropsmodell som finns tillgänglig i din arbetsyta.

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)

Se referensen för LangChain-integration.

OpenAI

Ställ in OPENAI_API_KEY och OPENAI_MODEL miljövariabler för din anteckningsboksprocess. Använd en modell som stödjer verktygsanrop och lagra API-nyckeln i en 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.")

Hjälparen kör de begärda funktionerna och formaterar sina resultat för nästa modellanrop. Se referensen för OpenAI-integration.

Anthropic

Ställ in ANTHROPIC_API_KEY och ANTHROPIC_MODEL miljövariabler för din anteckningsboksprocess. Använd en modell som stöder verktygsanrop och lagra API-nyckeln i en 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.")

Hjälpprogrammet kör de begärda funktionerna. Lägg till dess meddelanden i samtalet innan nästa modellanrop. Se referensen för Anthropic-integration.

LlamaIndex

Detta exempel använder en OpenAI-modell. Ställ in OPENAI_API_KEY och OPENAI_MODEL miljövariabler för din Notebook-process. Använd en modell som stödjer verktygsanrop och lagra API-nyckeln i en 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)

Kör de två sista raderna i en anteckningsbokscell som stödjer await. Se referensen för LlamaIndex-integration.

Agenten anropar add_numbers och returnerar ett svar som innehåller 5. Om du använder en befintlig funktion, ändra question så att det motsvarar en uppgift som funktionen stöder.

För distribution och autentisering, se Bygg en anpassad agent och agentautentisering.

Lokal utveckling på den egna datorn

För att testa betrodda Python-funktioner, initiera klienten med execution_mode="local" och skicka den till ditt ramverks verktygslåda:

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

Lokalt läge hämtar funktionen från Unity Catalog och kör den i en lokal delprocess. Den stöder inte SQL-funktioner. Använd standardläget serverless för produktion och kör endast betrodd kod. Se Körningslägen.

För timeouts, minnesbegränsningar och serverlösa inställningar, se lokala exekveringsgränser och Function Client-miljövariabler.

Använd workspace MCP-endpointen (äldre)

För befintliga MCP-integrationer kopplas detta LangGraph-exempel till samma funktion via den äldre arbetsytans endpoint. Aktivera förhandsvisningen för hanterade MCP-servrar och använd en identitet med åtkomst till funktionen.

Kör %pip install --upgrade databricks-langchain langgraph "mcp>=1.24,<2" i en cell i en notebook och starta sedan om Python. Ersätt my_catalog/my_schema/add_numbers med din funktions sökväg.

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)

För driftsättning, se Agentautentisering. För en funktion som anropar ett externt API med http_request, se Äldre REST API-verktyg.