Mengintegrasikan alat Unity Catalog dengan kerangka kerja AI generatif pihak ketiga

Alat agen AI Unity Catalog dapat digunakan di pustaka AI gen populer seperti LangChain, LlamaIndex, OpenAI, dan Anthropic. Integrasi ini menggabungkan tata kelola alat Katalog Unity dengan kemampuan kerangka kerja penulisan agen pihak ketiga. Contohnya:

  • Di LangChain, fungsi Unity Catalog dapat menjadi bagian dari alur kerja agen untuk melakukan tugas seperti mengkueri atau mengubah data.
  • Dalam integrasi OpenAI atau Antropis, fungsi dipanggil langsung oleh model AI selama eksekusi.

Pilih kerangka kerja Anda di tab berikut untuk membuat alat Katalog Unity dan menggunakannya dengan kerangka kerja tersebut. Jalankan kode dalam buku catatan Azure Databricks atau skrip Python.

Persyaratan

  • Instal Python 3.10 atau lebih tinggi.

LangChain

Gunakan Azure Databricks Unity Catalog untuk mengintegrasikan fungsi SQL dan Python sebagai alat di alur kerja LangChain dan LangGraph. Integrasi ini menggabungkan tata kelola Unity Catalog dengan kemampuan LangChain untuk membangun aplikasi berbasis LLM yang kuat.

Dalam contoh ini, Anda membuat alat Unity Catalog, menguji fungsionalitasnya, dan menambahkannya ke agen.

Pasang dependensi

Instal paket AI Unity Catalog dengan Databricks opsional dan instal paket integrasi 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()

Menginisialisasi Klien Fungsi Databricks

Mulai menginisialisasi Klien Fungsi Databricks.

from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

Menentukan logika alat

Buat fungsi Unity Catalog yang berisi logika alat.


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
)

Uji fungsi

Uji fungsi Anda untuk memeriksanya berfungsi seperti yang diharapkan:

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'

Membungkus fungsi menggunakan UCFunctionToolKit

Bungkus fungsi menggunakan UCFunctionToolkit untuk membuatnya dapat diakses oleh perpustakaan untuk penulisan agen. Toolkit memastikan konsistensi di berbagai pustaka dan menambahkan fitur bermanfaat seperti pelacakan otomatis untuk retriever.

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

Menggunakan alat di dalam agen

Tambahkan alat ke agen LangChain dengan menggunakan properti tools dari UCFunctionToolkit.

Contoh ini menulis agen sederhana menggunakan API LangChain AgentExecutor untuk kesederhanaan. Untuk beban kerja produksi, gunakan alur kerja penulisan agen yang terlihat di Penulis agen AI dan sebarkan di Aplikasi Databricks.

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

Gunakan Azure Databricks Unity Catalog untuk mengintegrasikan fungsi SQL dan Python sebagai alat dalam alur kerja LlamaIndex. Integrasi ini menggabungkan tata kelola Unity Catalog dengan kemampuan LlamaIndex untuk mengindeks dan mengkueri himpunan data besar untuk LLM.

  1. Instal paket integrasi Databricks Unity Catalog untuk LlamaIndex.

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

  2. Buat instans klien fungsi Katalog Unity.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Buat fungsi Katalog Unity yang ditulis dalam 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. Buat instans fungsi Unity Catalog sebagai toolkit, dan jalankan untuk memverifikasi bahwa alat berperilaku dengan benar.

    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. Gunakan alat dalam LlamaIndex ReActAgent dengan menentukan fungsi Unity Catalog sebagai bagian dari koleksi alat LlamaIndex. Kemudian verifikasi bahwa agen berperilaku baik dengan memanggil koleksi alat 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

Gunakan Azure Databricks Unity Catalog untuk mengintegrasikan fungsi SQL dan Python sebagai alat dalam alur kerja OpenAI. Integrasi ini menggabungkan tata kelola Unity Catalog dengan OpenAI untuk membuat aplikasi AI gen yang kuat.

  1. Instal paket integrasi Databricks Unity Catalog untuk OpenAI.

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

  2. Buat instans klien fungsi Katalog Unity.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Buat fungsi Katalog Unity yang ditulis dalam 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. Buat instans fungsi Katalog Unity sebagai perangkat alat dan verifikasi bahwa alat berfungsi dengan benar dengan menjalankan fungsi.

    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. Kirim permintaan ke model OpenAI bersama dengan alat.

    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. Setelah OpenAI mengembalikan respons, panggil panggilan fungsi Unity Catalog untuk menghasilkan jawaban respons kembali ke 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. Setelah jawaban dikembalikan, Anda dapat membuat payload respons untuk panggilan berikutnya ke 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"]
)

Utilitas

Untuk menyederhanakan proses pembuatan respons alat, ucai-openai paket memiliki utilitas, generate_tool_call_messages, yang mengonversi pesan respons OpenAI ChatCompletion sehingga dapat digunakan untuk pembuatan respons.

from unitycatalog.ai.openai.utils import generate_tool_call_messages

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

Note

Jika respons berisi beberapa entri pilihan, Anda dapat meneruskan argumen choice_index saat memanggil generate_tool_call_messages untuk memilih entri pilihan mana yang akan digunakan. Saat ini tidak ada dukungan untuk memproses entri pilihan ganda.

Anthropic

Gunakan Azure Databricks Unity Catalog untuk mengintegrasikan fungsi SQL dan Python sebagai alat dalam panggilan LLM SDK Anthropic. Integrasi ini menggabungkan tata kelola Unity Catalog dengan model Antropik untuk membuat aplikasi AI gen yang kuat.

Note

Integrasi Anthropic memerlukan Databricks Runtime 15.0 ke atas.

  1. Instal paket integrasi Databricks Unity Catalog untuk Anthropic.

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

  2. Buat instans klien fungsi Katalog Unity.

    from unitycatalog.ai.core.base import get_uc_function_client

client = get_uc_function_client()

  3. Buat fungsi Katalog Unity yang ditulis dalam 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. Buat instans fungsi Katalog Unity sebagai toolkit.

    from unitycatalog.ai.anthropic.toolkit import UCFunctionToolkit

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

  5. Gunakan panggilan alat di 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. Membangun respons alat. Respons dari model Claude berisi blok metadata permintaan alat jika alat perlu dipanggil.

    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)

Paket unitycatalog.ai-anthropic ini mencakup utilitas handler pesan untuk menyederhanakan penguraian dan penanganan panggilan ke fungsi Unity Catalog. Utilitas melakukan hal berikut:

  1. Mendeteksi persyaratan panggilan alat.
  2. Mengekstrak informasi panggilan perangkat dari kueri.
  3. Melakukan panggilan ke fungsi Unity Catalog.
  4. Mengurai respons dari fungsi Unity Catalog.
  5. Buat format pesan berikutnya untuk melanjutkan percakapan dengan Claude.

Note

Seluruh riwayat percakapan harus disediakan dalam conversation_history argumen ke generate_tool_call_messages API. Model Claude memerlukan pemulaan percakapan (pertanyaan asli dari pengguna) dan semua tanggapan yang dihasilkan berikutnya oleh LLM serta hasil dari panggilan alat multi-giliran.

  • Last updated on