Integrare gli strumenti del catalogo Unity con framework di intelligenza artificiale generati da terze parti

Gli strumenti dell'agente di intelligenza artificiale di Unity Catalog possono essere usati nelle librerie di intelligenza artificiale di generazione più diffuse, ad esempio LangChain, LlamaIndex, OpenAI e Anthropic. Queste integrazioni combinano la governance degli strumenti del catalogo Unity con le funzionalità dei framework di creazione di agenti di terze parti. Per esempio:

  • In LangChain le funzioni del catalogo Unity possono far parte del flusso di lavoro di un agente per eseguire attività come l'esecuzione di query o la trasformazione dei dati.
  • Nelle integrazioni OpenAI o Anthropic le funzioni vengono chiamate direttamente dal modello di intelligenza artificiale durante l'esecuzione.

Seleziona il framework nelle schede seguenti per creare uno strumento di Unity Catalog e usarlo con quel framework. Eseguire il codice in un notebook Azure Databricks o in uno script di Python.

Requirements

  • Installare Python 3.10 o versione successiva.

LangChain

Usare Azure Databricks Catalogo Unity per integrare funzioni SQL e Python come strumenti nei flussi di lavoro LangChain e LangGraph. Questa integrazione combina la governance di Unity Catalog con le funzionalità LangChain per creare potenti applicazioni basate su LLM.

In questo esempio si crea uno strumento Catalogo Unity, ne si testa la funzionalità e lo si aggiunge a un agente.

Installa le dipendenze

Installare i pacchetti di intelligenza artificiale di Unity Catalog con Databricks facoltativi e installare il pacchetto di integrazione 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()

Inizializzare il Databricks Function Client

Inizializza il client della funzione di Databricks.

from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

Definire la logica dello strumento

Creare una funzione del Catalogo Unity contenente la logica dello strumento.


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
)

Testare la funzione

Testare la funzione per verificarne il funzionamento come previsto:

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'

Eseguire il wrapping della funzione usando UCFunctionToolKit

Avvolgi la funzione usando UCFunctionToolkit per renderla accessibile alle librerie di sviluppo dell'agente. Il toolkit garantisce la coerenza tra librerie diverse e aggiunge funzionalità utili come la traccia automatica per i recuperatori.

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

Utilizzare lo strumento in un agente

Aggiungere lo strumento a un agente LangChain utilizzando la proprietà tools da UCFunctionToolkit.

Questo esempio crea un agente semplice usando l'API di AgentExecutor LangChain per semplicità. Per i carichi di lavoro di produzione, usare il flusso di lavoro di creazione dell'agente visualizzato in Creare un agente di intelligenza artificiale e distribuirlo 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

Usa Azure Databricks Unity Catalog per integrare funzioni SQL e Python come strumenti nei flussi di lavoro di LlamaIndex. Questa integrazione combina la governance del catalogo Unity con le funzionalità di LlamaIndex per indicizzare ed eseguire query su set di dati di grandi dimensioni per i moduli LLMs.

  1. Installare il pacchetto di integrazione del catalogo Unity di Databricks per LlamaIndex.

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

  2. Creare un'istanza del client di funzioni del catalogo Unity.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Creare una funzione del catalogo Unity scritta 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. Creare un'istanza della funzione Catalogo Unity come toolkit ed eseguirla per verificare che lo strumento si comporti correttamente.

    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. Usa lo strumento in un agente ReAct di LlamaIndex definendo la funzione del Catalogo Unity come parte di una raccolta di strumenti LlamaIndex. Verificare quindi che l'agente si comporti correttamente chiamando la raccolta di strumenti 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

Usare Azure Databricks Catalogo Unity per integrare funzioni SQL e Python come strumenti nei flussi di lavoro OpenAI. Questa integrazione combina la governance del catalogo unity con OpenAI per creare app di intelligenza artificiale di generazione avanzate.

  1. Installare il pacchetto di integrazione del catalogo Unity di Databricks per OpenAI.

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

  2. Creare un'istanza del client di funzioni del catalogo Unity.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Creare una funzione del catalogo Unity scritta 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. Creare un'istanza della funzione Catalogo Unity come toolkit e verificare che lo strumento si comporti correttamente eseguendo la funzione.

    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. Inviare la richiesta al modello OpenAI insieme agli strumenti.

    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. Dopo che OpenAI restituisce una risposta, richiamare la funzione del catalogo Unity per inviare la risposta a 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. Dopo aver restituito la risposta, è possibile costruire il payload della risposta per le chiamate successive a 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

Per semplificare il processo di creazione della risposta dello strumento, il ucai-openai pacchetto ha un'utilità, generate_tool_call_messages, che converte i messaggi di risposta OpenAI ChatCompletion in modo che possano essere usati per la generazione di risposte.

from unitycatalog.ai.openai.utils import generate_tool_call_messages

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

Note

Se la risposta contiene più voci di scelta, è possibile passare l'argomento choice_index quando si chiama generate_tool_call_messages per scegliere quale voce scegliere da utilizzare. Attualmente non è disponibile alcun supporto per l'elaborazione di più voci di scelta.

Antropico

Usa Unity Catalog di Azure Databricks per integrare funzioni SQL e Python come strumenti nelle chiamate LLM dell’SDK di Anthropic. Questa integrazione combina la governance del catalogo Unity con i modelli Anthropic per creare app di intelligenza artificiale di generazione avanzate.

Note

L'integrazione Anthropic richiede Databricks Runtime 15.0 e versioni successive.

  1. Installare il pacchetto di integrazione del catalogo Unity di Databricks per Anthropic.

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

  2. Creare un'istanza del client di funzioni del catalogo Unity.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Creare una funzione del catalogo Unity scritta 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. Creare un'istanza della funzione Catalogo Unity come toolkit.

    from unitycatalog.ai.anthropic.toolkit import UCFunctionToolkit

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

  5. Usare una chiamata di strumento 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. Costruire una risposta dello strumento. La risposta del modello Claude contiene un blocco di metadati di richiesta dello strumento se è necessario chiamare uno strumento.

    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)

Il unitycatalog.ai-anthropic pacchetto include un'utilità del gestore messaggi per semplificare l'analisi e la gestione di una chiamata alla funzione Catalogo Unity. L'utilità esegue le operazioni seguenti:

  1. Rileva i requisiti di chiamata dello strumento.
  2. Estrae le informazioni di chiamata dello strumento dalla query.
  3. Esegue la chiamata alla funzione Catalog di Unity.
  4. Analizza la risposta dalla funzione Catalogo Unity.
  5. Creare il formato del messaggio successivo per continuare la conversazione con Claude.

Note

L'intera cronologia delle conversazioni deve essere fornita nell'argomento conversation_history all'API generate_tool_call_messages . I modelli Claude richiedono l'inizializzazione della conversazione (la domanda di input originale dell'utente) e tutte le risposte successive generate dall'LLM, oltre ai risultati delle chiamate agli strumenti a più turni.

  • Last updated on