Intégrer des outils de catalogue Unity à des infrastructures d’IA générative tierces

Les outils d’agent IA du catalogue Unity peuvent être utilisés dans des bibliothèques IA de génération populaires telles que LangChain, LlamaIndex, OpenAI et Anthropic. Ces intégrations combinent la gouvernance des outils de catalogue Unity avec les fonctionnalités des frameworks de création d’agents tiers. Par exemple:

  • Dans LangChain, les fonctions catalogue Unity peuvent faire partie du flux de travail d’un agent pour effectuer des tâches telles que l’interrogation ou la transformation de données.
  • Dans les intégrations OpenAI ou Anthropic, les fonctions sont appelées directement par le modèle IA pendant l’exécution.

Sélectionnez votre infrastructure dans les onglets suivants pour créer un outil de catalogue Unity et l’utiliser avec cette infrastructure. Exécutez le code dans un bloc-notes Azure Databricks ou un script Python.

Requirements

  • Installez Python 3.10 ou version ultérieure.

LangChain

Utilisez Azure Databricks catalogue Unity pour intégrer des fonctions SQL et Python en tant qu’outils dans les flux de travail LangChain et LangGraph. Cette intégration combine la gouvernance du catalogue Unity avec les fonctionnalités LangChain pour créer des applications LLM puissantes.

Dans cet exemple, vous créez un outil de catalogue Unity, testez ses fonctionnalités et ajoutez-le à un agent.

Installer des dépendances

Installez les packages UNITY Catalog AI avec databricks facultatif et installez le package d’intégration 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()

Initialiser le client de fonction Databricks

Initialisez le client de fonction Databricks.

from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

Définir la logique de l’outil

Créez une fonction de catalogue Unity contenant la logique de l’outil.


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
)

Tester la fonction

Testez votre fonction pour vérifier qu’elle fonctionne comme prévu :

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'

Encapsuler la fonction à l’aide de l’UCFunctionToolKit

Encapsulez la fonction en utilisant le UCFunctionToolkit pour la rendre accessible aux bibliothèques de création d’agents. Le kit de ressources garantit la cohérence entre différentes bibliothèques et ajoute des fonctionnalités utiles telles que le suivi automatique pour les récupérateurs.

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

Utiliser l’outil dans un agent

Ajoutez l’outil à un agent LangChain à l’aide de la propriété tools à partir de UCFunctionToolkit.

Cet exemple crée un agent simple à l’aide de l’API AgentExecutor LangChain pour plus de simplicité. Pour les charges de travail de production, utilisez le flux de travail de création d’agent vu dans Créer un agent IA et déployez-le sur 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

Utilisez Azure Databricks catalogue Unity pour intégrer des fonctions SQL et Python en tant qu’outils dans les flux de travail LlamaIndex. Cette intégration combine la gouvernance de Unity Catalog avec les fonctionnalités de LlamaIndex pour indexer et interroger des jeux de données volumineux dans les LLM.

  1. Installez le package d’intégration databricks Unity Catalog pour LlamaIndex.

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

  2. Créez une instance du client de fonctions de catalogue Unity.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Créez une fonction de catalogue Unity écrite en 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. Créez une instance de la fonction Catalogue Unity en tant que kit de ressources et exécutez-la pour vérifier que l’outil se comporte correctement.

    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. Utilisez l’outil dans un LlamaIndex ReActAgent en définissant la fonction Catalogue Unity dans le cadre d’une collection d’outils LlamaIndex. Vérifiez ensuite que l’agent se comporte correctement en appelant la collection d’outils 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

Utilisez Unity Catalog d’Azure Databricks pour intégrer des fonctions SQL et Python comme outils dans les flux de travail OpenAI. Cette intégration combine la gouvernance du catalogue Unity avec OpenAI pour créer des applications IA de génération puissantes.

  1. Installez le package d’intégration databricks Unity Catalog pour OpenAI.

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

  2. Créez une instance du client de fonctions de catalogue Unity.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Créez une fonction de catalogue Unity écrite en 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. Créez une instance de la fonction Catalogue Unity en tant que kit de ressources et vérifiez que l’outil se comporte correctement en exécutant la fonction.

    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. Envoyez la demande au modèle OpenAI avec les outils.

    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. Une fois qu'OpenAI a retourné une réponse, appelez la fonction Unity Catalog pour retourner la réponse à 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. Une fois la réponse retournée, vous pouvez construire la charge utile de réponse pour les appels suivants à 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"]
)

Services publics

Pour simplifier le processus d’élaboration de la réponse de l’outil, le ucai-openai package a un utilitaire, generate_tool_call_messagesqui convertit les messages de réponse OpenAI ChatCompletion afin qu’ils puissent être utilisés pour la génération de réponse.

from unitycatalog.ai.openai.utils import generate_tool_call_messages

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

Note

Si la réponse contient plusieurs entrées de choix, vous pouvez passer l’argument choice_index lors de l’appel de generate_tool_call_messages pour choisir l’entrée de choix à utiliser. Il n’existe actuellement aucune prise en charge du traitement des entrées à choix multiples.

Anthropic

Utilisez Azure Databricks Unity Catalog pour intégrer des fonctions SQL et Python comme outils dans les appels LLM au SDK Anthropic. Cette intégration combine la gouvernance du catalogue Unity avec des modèles anthropices pour créer des applications IA de génération puissantes.

Note

L’intégration Anthropic nécessite Databricks Runtime 15.0 et versions ultérieures.

  1. Installez le package d’intégration databricks Unity Catalog pour Anthropic.

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

  2. Créez une instance du client de fonctions de catalogue Unity.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Créez une fonction de catalogue Unity écrite en 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. Créez une instance de la fonction Catalogue Unity en tant que kit de ressources.

    from unitycatalog.ai.anthropic.toolkit import UCFunctionToolkit

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

  5. Utilisez un appel d’outil dans 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. Créez une réponse d’outil. La réponse du modèle Claude contient un bloc de métadonnées de demande d’outil si un outil doit être appelé.

    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)

Le unitycatalog.ai-anthropic package inclut un utilitaire de gestionnaire de messages pour simplifier l’analyse et la gestion d’un appel à la fonction Catalogue Unity. L’utilitaire effectue les opérations suivantes :

  1. Détecte les exigences d’appel d’outils.
  2. Extrait les informations d’appel de l’outil à partir de la requête.
  3. Exécute l’appel à la fonction Unity Catalog.
  4. Analyse la réponse de la fonction Catalogue Unity.
  5. Créez le format de message suivant pour poursuivre la conversation avec Claude.

Note

L’ensemble de l’historique des conversations doit être fourni dans l’argument conversation_history de l’API generate_tool_call_messages . Les modèles Claude nécessitent l’initialisation de la conversation (la question d’entrée utilisateur d’origine) ainsi que toutes les réponses LLM générées par la suite et les résultats des appels d'outils multitours.

  • Last updated on