Integracenástrojůch

Nástroje pro AI agenty v katalogu Unity lze používat v oblíbených knihovnách pro generativní AI, jako jsou LangChain, LlamaIndex, OpenAI a Anthropic. Tyto integrace kombinují zásady správného řízení nástroje Unity Catalog s možnostmi architektur pro vytváření agentů třetích stran. Příklad:

Funkce katalogu Unity v jazyce LangChain můžou být součástí pracovního postupu agenta k provádění úloh, jako je dotazování nebo transformace dat.
V integrací OpenAI nebo Anthropic se funkce během provádění volají přímo modelem AI.

Vyberte svoji architekturu na následujících kartách, abyste vytvořili nástroj Katalogu Unity a použili ho s danou architekturou. Spusťte kód v poznámkovém bloku Azure Databricks nebo Python skriptu.

Požadavky

Nainstalujte Python 3.10 nebo novější.

LangChain

Pomocí Azure Databricks Katalogu Unity můžete integrovat funkce SQL a Python jako nástroje v pracovních postupech LangChain a LangGraph. Tato integrace kombinuje zásady správného řízení katalogu Unity s funkcemi LangChain k vytváření výkonných aplikací založených na LLM.

V tomto příkladu vytvoříte nástroj Katalogu Unity, otestujete jeho funkce a přidáte ho do agenta.

Nainstalujte závislosti

Nainstalujte balíčky AI katalogu Unity s volitelným nástrojem Databricks a nainstalujte integrační balíček LangChain.

# Install the Unity Catalog AI integration package with the Databricks extra
%pip install unitycatalog-langchain[databricks]

# Install Databricks Langchain integration package
%pip install databricks-langchain
dbutils.library.restartPython()

Inicializace klienta funkce Databricks

Inicializuje klienta funkce Databricks.

from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

Definování logiky nástroje

Vytvořte funkci Katalogu Unity obsahující logiku nástroje.


CATALOG = "my_catalog"
SCHEMA = "my_schema"

def add_numbers(number_1: float, number_2: float) -> float:
  """
  A function that accepts two floating point numbers adds them,
  and returns the resulting sum as a float.

  Args:
    number_1 (float): The first of the two numbers to add.
    number_2 (float): The second of the two numbers to add.

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

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

Testování funkce

Otestujte funkci a zkontrolujte, jestli funguje podle očekávání:

result = client.execute_function(
  function_name=f"{CATALOG}.{SCHEMA}.add_numbers",
  parameters={"number_1": 36939.0, "number_2": 8922.4}
)

result.value # OUTPUT: '45861.4'

Zabalte funkci pomocí UCFunctionToolKit

Zabalte funkci pomocí UCFunctionToolkit, aby byla dostupná knihovnám pro tvorbu agentů. Sada nástrojů zajišťuje konzistenci napříč různými knihovnami a přidává užitečné funkce, jako je automatické trasování pro načítáče.

from databricks_langchain import UCFunctionToolkit

# Create a toolkit with the Unity Catalog function
func_name = f"{CATALOG}.{SCHEMA}.add_numbers"
toolkit = UCFunctionToolkit(function_names=[func_name])

tools = toolkit.tools

Použití nástroje v agentu

Přidejte nástroj do agenta LangChain použitím vlastnosti tools z UCFunctionToolkit.

V tomto příkladu autoři z důvodu jednoduchosti používají jednoduchého agenta využívajícího AgentExecutor rozhraní API jazyka LangChain. V případě produkčních úloh použijte pracovní postup vytváření agentů, který je vidět v tématu Vytvoření agenta AI, a nasaďte ho v Databricks Apps.

from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain.prompts import ChatPromptTemplate
from databricks_langchain import (
  ChatDatabricks,
  UCFunctionToolkit,
)
import mlflow

# Initialize the LLM (replace with your LLM of choice, if desired)
LLM_ENDPOINT_NAME = "databricks-meta-llama-3-3-70b-instruct"
llm = ChatDatabricks(endpoint=LLM_ENDPOINT_NAME, temperature=0.1)

# Define the prompt
prompt = ChatPromptTemplate.from_messages(
  [
    (
      "system",
      "You are a helpful assistant. Make sure to use tools for additional functionality.",
    ),
    ("placeholder", "{chat_history}"),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
  ]
)

# Enable automatic tracing
mlflow.langchain.autolog()

# Define the agent, specifying the tools from the toolkit above
agent = create_tool_calling_agent(llm, tools, prompt)

# Create the agent executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
agent_executor.invoke({"input": "What is 36939.0 + 8922.4?"})

LlamaIndex

Pomocí katalogu Azure Databricks Unity můžete integrovat funkce SQL a Python jako nástroje v pracovních postupech LlamaIndex. Tato integrace kombinuje zásady správného řízení katalogu Unity s funkcemi LlamaIndex pro indexování a dotazování velkých datových sad pro LLM.

Nainstalujte integrační balíček katalogu Databricks Unity pro LlamaIndex.

%pip install unitycatalog-llamaindex[databricks]
dbutils.library.restartPython()

Vytvořte instanci klienta funkcí katalogu Unity.

from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

Vytvořte funkci katalogu Unity napsanou v Pythonu.

CATALOG = "your_catalog"
SCHEMA = "your_schema"

func_name = f"{CATALOG}.{SCHEMA}.code_function"

def code_function(code: str) -> str:
  """
  Runs Python code.

  Args:
    code (str): The Python code to run.
  Returns:
    str: The result of running the Python code.
  """
  import sys
  from io import StringIO
  stdout = StringIO()
  sys.stdout = stdout
  exec(code)
  return stdout.getvalue()

client.create_python_function(
  func=code_function,
  catalog=CATALOG,
  schema=SCHEMA,
  replace=True
)

Vytvořte instanci funkce Katalogu Unity jako sadu nástrojů a spusťte ji, abyste ověřili, že se nástroj chová správně.

from unitycatalog.ai.llama_index.toolkit import UCFunctionToolkit
import mlflow

# Enable traces
mlflow.llama_index.autolog()

# Create a UCFunctionToolkit that includes the UC function
toolkit = UCFunctionToolkit(function_names=[func_name])

# Fetch the tools stored in the toolkit
tools = toolkit.tools
python_exec_tool = tools[0]

# Run the tool directly
result = python_exec_tool.call(code="print(1 + 1)")
print(result)  # Outputs: {"format": "SCALAR", "value": "2\n"}

Použijte nástroj v LlamaIndex ReActAgent definováním funkce Unity Catalog jako součást kolekce nástrojů LlamaIndex. Ověřte, že se agent chová správně, tím, že zavoláte soubor nástrojů LlamaIndex.

from llama_index.llms.openai import OpenAI
from llama_index.core.agent import ReActAgent

llm = OpenAI()

agent = ReActAgent.from_tools(tools, llm=llm, verbose=True)

agent.chat("Please run the following python code: `print(1 + 1)`")

OpenAI

Pomocí katalogu Azure Databricks Unity můžete integrovat funkce SQL a Python jako nástroje v pracovních postupech OpenAI. Tato integrace kombinuje správu katalogu Unity s OpenAI a tím vytváří výkonné generativní AI aplikace.

Nainstalujte integrační balíček Katalogu Unity Databricks pro OpenAI.

%pip install unitycatalog-openai[databricks]
%pip install mlflow -U
dbutils.library.restartPython()

Vytvořte instanci klienta funkcí katalogu Unity.

from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

Vytvořte funkci katalogu Unity napsanou v Pythonu.

CATALOG = "your_catalog"
SCHEMA = "your_schema"

func_name = f"{CATALOG}.{SCHEMA}.code_function"

def code_function(code: str) -> str:
  """
  Runs Python code.

  Args:
    code (str): The python code to run.
  Returns:
    str: The result of running the Python code.
  """
  import sys
  from io import StringIO
  stdout = StringIO()
  sys.stdout = stdout
  exec(code)
  return stdout.getvalue()

client.create_python_function(
  func=code_function,
  catalog=CATALOG,
  schema=SCHEMA,
  replace=True
)

Vytvořte instanci funkce Katalogu Unity jako sadu nástrojů a ověřte, že se nástroj chová správně spuštěním funkce.

from unitycatalog.ai.openai.toolkit import UCFunctionToolkit
import mlflow

# Enable tracing
mlflow.openai.autolog()

# Create a UCFunctionToolkit that includes the UC function
toolkit = UCFunctionToolkit(function_names=[func_name])

# Fetch the tools stored in the toolkit
tools = toolkit.tools
client.execute_function = tools[0]

Odešlete žádost do modelu OpenAI spolu s nástroji.

import openai

messages = [
  {
    "role": "system",
    "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user.",
  },
  {"role": "user", "content": "What is the result of 2**10?"},
]
response = openai.chat.completions.create(
  model="gpt-4o-mini",
  messages=messages,
  tools=tools,
)
# check the model response
print(response)

Jakmile OpenAI vrátí odpověď, vyvolejte volání funkce Katalogu Unity a vygenerujte odpověď zpět do OpenAI.

import json

# OpenAI sends only a single request per tool call
tool_call = response.choices[0].message.tool_calls[0]
# Extract arguments that the Unity Catalog function needs to run
arguments = json.loads(tool_call.function.arguments)

# Run the function based on the arguments
result = client.execute_function(func_name, arguments)
print(result.value)

Jakmile se odpověď vrátí, můžete vytvořit datovou část odpovědi pro následná volání OpenAI.

# Create a message containing the result of the function call
function_call_result_message = {
  "role": "tool",
  "content": json.dumps({"content": result.value}),
  "tool_call_id": tool_call.id,
}
assistant_message = response.choices[0].message.to_dict()
completion_payload = {
  "model": "gpt-4o-mini",
  "messages": [*messages, assistant_message, function_call_result_message],
}

# Generate final response
openai.chat.completions.create(
  model=completion_payload["model"], messages=completion_payload["messages"]
)

Utilities

Pro zjednodušení procesu vytváření odpovědi nástroje ucai-openai má balíček nástroj, generate_tool_call_messages, který převádí zprávy z OpenAI ChatCompletion tak, aby byly použitelné pro generování odpovědí.

from unitycatalog.ai.openai.utils import generate_tool_call_messages

messages = generate_tool_call_messages(response=response, client=client)
print(messages)

Note

Pokud odpověď obsahuje více položek voleb, můžete při volání generate_tool_call_messages předat argument choice_index a zvolit, kterou položku výběru chcete použít. V současné době není podporováno zpracování více položek výběru.

Anthropic

Pomocí katalogu Azure Databricks Unity můžete integrovat funkce SQL a Python jako nástroje ve voláních LLM sady Anthropic SDK. Tato integrace spojuje správu katalogu Unity s modely Anthropic a vytváří výkonné generativní AI aplikace.

Note

Integrace Anthropic vyžaduje Databricks Runtime ve verzi 15.0 a novější.

Nainstalujte integrační balíček Katalogu Unity Databricks pro Anthropic.

%pip install unitycatalog-anthropic[databricks]
dbutils.library.restartPython()

Vytvořte instanci klienta funkcí katalogu Unity.

from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

Vytvořte funkci katalogu Unity napsanou v Pythonu.

CATALOG = "your_catalog"
SCHEMA = "your_schema"

func_name = f"{CATALOG}.{SCHEMA}.weather_function"

def weather_function(location: str) -> str:
  """
  Fetches the current weather from a given location in degrees Celsius.

  Args:
    location (str): The location to fetch the current weather from.
  Returns:
    str: The current temperature for the location provided in Celsius.
  """
  return f"The current temperature for {location} is 24.5 celsius"

client.create_python_function(
  func=weather_function,
  catalog=CATALOG,
  schema=SCHEMA,
  replace=True
)

Vytvořte instanci funkce Katalogu Unity jako sadu nástrojů.

from unitycatalog.ai.anthropic.toolkit import UCFunctionToolkit

# Create an instance of the toolkit
toolkit = UCFunctionToolkit(function_names=[func_name], client=client)

Použijte volání nástroje v Anthropic.

import anthropic

# Initialize the Anthropic client with your API key
anthropic_client = anthropic.Anthropic(api_key="YOUR_ANTHROPIC_API_KEY")

# User's question
question = [{"role": "user", "content": "What's the weather in New York City?"}]

# Make the initial call to Anthropic
response = anthropic_client.messages.create(
  model="claude-3-5-sonnet-20240620",  # Specify the model
  max_tokens=1024,  # Use 'max_tokens' instead of 'max_tokens_to_sample'
  tools=toolkit.tools,
  messages=question  # Provide the conversation history
)

# Print the response content
print(response)

Vytvořte reakci nástroje. Odpověď z modelu Clauda obsahuje blok metadat požadavku nástroje, pokud je potřeba nástroj použít.

from unitycatalog.ai.anthropic.utils import generate_tool_call_messages

# Call the UC function and construct the required formatted response
tool_messages = generate_tool_call_messages(
  response=response,
  client=client,
  conversation_history=question
)

# Continue the conversation with Anthropic
tool_response = anthropic_client.messages.create(
  model="claude-3-5-sonnet-20240620",
  max_tokens=1024,
  tools=toolkit.tools,
  messages=tool_messages,
)

print(tool_response)

Balíček unitycatalog.ai-anthropic obsahuje nástroj obslužné rutiny zpráv, který zjednodušuje analýzu a zpracování volání funkce Unity Catalog. Nástroj provede následující:

Detekuje požadavky na volání nástrojů.
Z dotazu extrahuje informace o volání nástroje.
Provede volání funkce Unity Catalog.
Parsuje odpověď z funkce Unity Catalog.
Vytvořte další formát zprávy a pokračujte v konverzaci s Claudem.

Note

V argumentu conversation_historygenerate_tool_call_messages rozhraní API musí být uvedená celá historie konverzací. Modely Claude vyžadují inicializaci konverzace (původní otázka uživatelského vstupu) a všechny následné odpovědi generované modelem LLM, stejně jako výsledky vícestupňového volání nástroje.

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-06-30

Integracenástrojůch

Požadavky

LangChain

Nainstalujte závislosti

Inicializace klienta funkce Databricks

Definování logiky nástroje

Testování funkce

Zabalte funkci pomocí UCFunctionToolKit

Použití nástroje v agentu

LlamaIndex

OpenAI

Utilities

Anthropic

Váš názor

Další materiály