Unity Catalog-hulpprogramma's integreren met generatieve AI-frameworks van derden

Ai-agenthulpprogramma's voor Unity Catalog kunnen worden gebruikt in populaire GEN AI-bibliotheken zoals LangChain, LlamaIndex, OpenAI en Anthropic. Deze integraties combineren het beheer van Unity Catalog hulpmiddelen met de mogelijkheden van raamwerken voor het creëren van agenten van derden. Voorbeeld:

  • In LangChain kunnen Unity Catalog-functies deel uitmaken van de werkstroom van een agent om taken uit te voeren, zoals het opvragen of transformeren van gegevens.
  • In OpenAI- of Antropische integraties worden de functies tijdens de uitvoering rechtstreeks aangeroepen door het AI-model.

Selecteer uw framework op de volgende tabbladen om een Unity Catalog-hulpprogramma te maken en dit te gebruiken met dat framework. Voer de code uit in een Azure Databricks notebook of Python script.

Requirements

  • Installeer Python 3.10 of hoger.

LangChain

Gebruik Azure Databricks Unity Catalog om SQL- en Python-functies te integreren als hulpprogramma's in LangChain- en LangGraph-werkstromen. Deze integratie combineert het beheer van Unity Catalog met LangChain-mogelijkheden om krachtige LLM-toepassingen te bouwen.

In dit voorbeeld maakt u een Unity Catalog-hulpprogramma, test u de functionaliteit en voegt u deze toe aan een agent.

Afhankelijkheden installeren

Installeer AI-pakketten van Unity Catalog met databricks optioneel en installeer het LangChain-integratiepakket.

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

De Databricks-functieclient initialiseren

Initialiseer de Databricks-functieclient.

from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

De logica van het hulpprogramma definiëren

Maak een Unity Catalog-functie die de logica van het hulpprogramma bevat.


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
)

De functie testen

Test uw functie om te controleren of deze werkt zoals verwacht:

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'

De functie verpakken met behulp van de UCFunctionToolKit

Wikkel de functie in met behulp van de UCFunctionToolkit om deze toegankelijk te maken voor agent authoring libraries. De toolkit zorgt voor consistentie in verschillende bibliotheken en voegt nuttige functies toe, zoals automatisch traceren voor retrievers.

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

Het hulpprogramma in een agent gebruiken

Voeg het hulpprogramma toe aan een LangChain-agent met behulp van de tools eigenschap van UCFunctionToolkit.

In dit voorbeeld wordt een eenvoudige agent gemaakt met behulp van de API van AgentExecutor LangChain voor het gemak. Voor productieworkloads gebruikt u de werkstroom voor het ontwerpen van agents die wordt weergegeven in Een AI-agent ontwerpen en implementeren in 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

Gebruik Azure Databricks Unity Catalog om SQL- en Python-functies te integreren als hulpprogramma's in LlamaIndex-werkstromen. Deze integratie combineert Unity Catalog-governance met de mogelijkheden van LlamaIndex om grote gegevenssets voor LLM's te indexeren en er query's op uit te voeren.

  1. Installeer het Databricks Unity Catalog-integratiepakket voor LlamaIndex.

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

  2. Maak een exemplaar van de Unity Catalog-functieclient.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Maak een Unity Catalog-functie die is geschreven in Python.

    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
)

  4. Maak een exemplaar van de Unity Catalog-functie als een toolkit en voer deze uit om te controleren of het hulpprogramma goed werkt.

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

  5. Gebruik het hulpprogramma in een LlamaIndex ReActAgent door de functie Unity Catalog te definiëren als onderdeel van een LlamaIndex-hulpprogrammaverzameling. Controleer vervolgens of de agent zich correct gedraagt door de llamaIndex-hulpprogrammaverzameling aan te roepen.

    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

Gebruik Azure Databricks Unity Catalog om SQL- en Python-functies te integreren als hulpprogramma's in OpenAI-werkstromen. Deze integratie combineert het beheer van Unity Catalog met OpenAI om krachtige GEN AI-apps te maken.

  1. Installeer het Databricks Unity Catalog-integratiepakket voor OpenAI.

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

  2. Maak een exemplaar van de Unity Catalog-functieclient.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Maak een Unity Catalog-functie die is geschreven in Python.

    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
)

  4. Maak een exemplaar van de Unity Catalog-functie als toolkit en controleer of het hulpprogramma goed werkt door de functie uit te voeren.

    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]

  5. Dien de aanvraag in bij het OpenAI-model, samen met de hulpprogramma's.

    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)

  6. Nadat OpenAI een antwoord retourneert, roept u de aanroep van de Unity Catalog-functie aan om het antwoordantwoord terug te genereren naar 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)

  7. Zodra het antwoord is geretourneerd, kunt u de nettolading van het antwoord samenstellen voor volgende aanroepen naar 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"]
)

Nutsvoorzieningen

Om het proces van het maken van het antwoord van het hulpprogramma te vereenvoudigen, heeft het ucai-openai pakket een hulpprogramma, generate_tool_call_messageswaarmee OpenAI ChatCompletion-antwoordberichten worden geconverteerd, zodat ze kunnen worden gebruikt voor het genereren van reacties.

from unitycatalog.ai.openai.utils import generate_tool_call_messages

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

Note

Als het antwoord meerdere keuzegegevens bevat, kunt u het argument choice_index doorgeven wanneer u generate_tool_call_messages aanroept om te kiezen welke keuzevermelding u wilt gebruiken. Er is momenteel geen ondersteuning voor het verwerken van vermeldingen met meerdere keuzen.

Anthropic

Gebruik Azure Databricks Unity Catalog om SQL- en Python-functies te integreren als hulpprogramma's in Anthropic SDK LLM-aanroepen. Deze integratie combineert het beheer van Unity Catalog met antropische modellen om krachtige GEN AI-apps te maken.

Note

Voor de Anthropic-integratie is Databricks Runtime 15.0 en hoger vereist.

  1. Installeer het Databricks Unity Catalog-integratiepakket voor Antropic.

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

  2. Maak een exemplaar van de Unity Catalog-functieclient.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Maak een Unity Catalog-functie die is geschreven in Python.

    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
)

  4. Maak een exemplaar van de Unity Catalog-functie als een toolkit.

    from unitycatalog.ai.anthropic.toolkit import UCFunctionToolkit

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

  5. Gebruik een hulpmiddel-aanroep in 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)

  6. Een reactie op een hulpprogramma maken. Het antwoord van het Claude-model bevat een metagegevensblok voor hulpprogrammaaanvragen als een hulpprogramma moet worden aangeroepen.

    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)

Het unitycatalog.ai-anthropic pakket bevat een hulpprogramma voor de berichthandler om het parseren en verwerken van een aanroep naar de Unity Catalog-functie te vereenvoudigen. Het hulpprogramma doet het volgende:

  1. Detecteert de vereisten voor het aanroepen van hulpprogramma's.
  2. Extraheert informatie over het aanroepen van een tool uit de query.
  3. Voert de aanroep uit naar de Unity Catalog-functie.
  4. Parseert het antwoord van de functie Unity Catalog.
  5. Maak de volgende berichtindeling om het gesprek met Claude voort te zetten.

Note

De volledige gespreksgeschiedenis moet worden opgegeven in het conversation_history argument voor de generate_tool_call_messages API. Claude-modellen vereisen de initialisatie van het gesprek (de oorspronkelijke gebruikersinvoervraag) en alle daaropvolgende antwoorden gegenereerd door LLM, evenals de resultaten van meervoudige interacties met hulpmiddelen.

  • Last updated on