OpenAI mit den Databricks Unity Catalog-Tools integrieren

Verwenden Sie databricks Unity Catalog, um SQL- und Python-Funktionen als Tools in OpenAI-Workflows zu integrieren. Diese Integration kombiniert die Governance des Unity-Katalogs mit OpenAI, um leistungsstarke KI-Apps der Generation zu erstellen.

Anforderungen

• Installieren Sie Python 3.10 oder höher.

Integrieren von Unity-Katalogtools in OpenAI

Führen Sie den folgenden Code in einem Notizbuch oder Python-Skript aus, um ein Unity Catalog-Tool zu erstellen und beim Aufrufen eines OpenAI-Modells zu verwenden.

1. Installieren Sie das Integrationspaket "Databricks Unity Catalog" für OpenAI.

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

2. Erstellen Sie eine Instanz des Unity Catalog-Funktionsclients.

   from unitycatalog.ai.core.base import get_uc_function_client
   
   client = get_uc_function_client()
   

3. Erstellen Sie eine Unity Catalog-Funktion, die in Python geschrieben wurde.

   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. Erstellen Sie eine Instanz des Unity-Katalogs als Toolkit, und stellen Sie sicher, dass sich das Tool ordnungsgemäß verhält, indem Sie die Funktion ausführen.

   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. Übermitteln Sie die Anforderung zusammen mit den Tools an das OpenAI-Modell.

   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. Nachdem OpenAI eine Antwort zurückgegeben hat, rufen Sie den Unity Catalog-Funktionsaufruf auf, um die Antwortantwort zurück zu OpenAI zu generieren.

   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. Nachdem die Antwort zurückgegeben wurde, können Sie die Antwortnutzlast für nachfolgende Aufrufe an OpenAI erstellen.

   # 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"]
   )
   

Versorgungsdienste

Um das Erstellen der Toolantwort zu vereinfachen, verfügt das ucai-openai Paket über ein Dienstprogramm, generate_tool_call_messagesdas OpenAI ChatCompletion-Antwortnachrichten konvertiert, sodass sie für die Antwortgenerierung verwendet werden können.

from unitycatalog.ai.openai.utils import generate_tool_call_messages

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