Erstellen eines KI-Agents und seiner Tools

Dieser Artikel zeigt Ihnen, wie Sie mit dem Mosaic AI Agent Framework KI-Agenten und -Tools erstellen können.

Lernen Sie, wie Sie mit dem KI-Playground schnell Prototypen von Tool-Anruf-Agenten erstellen und diese in das Mosaic AI Agent Framework exportieren können.

Anforderungen

• Verstehen Sie die Konzepte von KI-Agents und -Tools, wie unter Was sind zusammengesetztes KI-System und KI-Agenten ? beschrieben
• Databricks empfiehlt, bei der Entwicklung von Agenten die aktuelle Version des MLflow-Python-Clients zu installieren. Informationen zu den mlflow Versionsanforderungen finden Sie unter Authentifizierung für abhängige Ressourcen.

Erstellen von KI-Agententools

KI-Agenten verwenden Werkzeuge, um neben der Spracherzeugung weitere Aktionen durchzuführen, z. B. um strukturierte oder unstrukturierte Daten abzurufen, Code auszuführen oder mit Remote-Diensten zu kommunizieren (z. B. eine E-Mail oder eine Slack-Nachricht zu senden).

Um einem Agenten mit Mosaic AI Agent Framework Tools zur Verfügung zu stellen, können Sie eine beliebige Kombination der folgenden Methoden verwenden:

1. Erstellen oder verwenden Sie vorhandene Unity Catalog-Funktionen als Tools, um die Suche, Verwaltung und gemeinsame Nutzung von Tools zu erleichtern.
2. Definieren Sie Tools lokal als Python-Funktionen im Agentcode.

Beide Ansätze funktionieren unabhängig davon, ob Ihr Agent in benutzerdefiniertem Python-Code geschrieben wurde oder ob Sie eine Bibliothek wie LangGraph zur Erstellung von Agenten verwenden.

Wenn Sie Tools definieren, müssen Sie sicherstellen, dass das Werkzeug, seine Parameter und sein Rückgabewert gut dokumentiert sind, damit der LLM-Agent das Tool optimal nutzen kann.

Erstellen von Agent-Tools mit Unity-Katalogfunktionen

In diesen Beispielen werden KI-Agent-Tools mithilfe von Unity Catalog-Funktionen erstellt, die in einer Notebook-Umgebung oder in einem SQL-Editor geschrieben wurden.

Führen Sie den folgenden Code in einer Notebook-Zelle aus. Es verwendet die %sql Notebook-Magie, um eine Unity Catalog-Funktion namens python_exec zu erstellen.

Ein LLM kann dieses Tool verwenden, um Python-Code auszuführen, der von einem Benutzer bereitgestellt wird.

%sql
CREATE OR REPLACE FUNCTION
main.default.python_exec (
 code STRING COMMENT 'Python code to execute. Remember to print the final result to stdout.'
)
RETURNS STRING
LANGUAGE PYTHON
DETERMINISTIC
COMMENT 'Executes Python code in the sandboxed environment and returns its stdout. The runtime is stateless and you can not read output of the previous tool executions. i.e. No such variables "rows", "observation" defined. Calling another tool inside a Python code is NOT allowed. Use standard python libraries only.'
AS $$
 import sys
 from io import StringIO
 sys_stdout = sys.stdout
 redirected_output = StringIO()
 sys.stdout = redirected_output
 exec(code)
 sys.stdout = sys_stdout
 return redirected_output.getvalue()
$$

Führen Sie den folgenden Code im SQL-Editor aus.

Es erstellt eine Unity Catalog-Funktion mit dem Namen lookup_customer_info, die ein LLM verwenden könnte, um strukturierte Daten aus einer hypothetischen customer_data Tabelle abzurufen:

CREATE OR REPLACE FUNCTION main.default.lookup_customer_info(
  customer_name STRING COMMENT 'Name of the customer whose info to look up'
)
RETURNS STRING
COMMENT 'Returns metadata about a particular customer given the customer name, including the customer email and ID. The
customer ID can be used for other queries.'
RETURN SELECT CONCAT(
    'Customer ID: ', customer_id, ', ',
    'Customer Email: ', customer_email
  )
  FROM main.default.customer_data
  WHERE customer_name = customer_name
  LIMIT 1;

Prototyp von Tool-Anruf-Agenten im KI-Playground

Nachdem Sie die Unity-Katalogfunktionen erstellt haben, können Sie den KI-Playground verwenden, um sie einem LLM zuzuweisen und den Agent zu testen. Der KI-Playground bietet einen Sandkasten zum Erproben der Prototypen von Tool-Anruf-Agents.

Wenn Sie mit dem KI-Agenten zufrieden sind, können Sie ihn exportieren, um ihn in Python weiterzuentwickeln, oder ihn unverändert als Model Serving-Endpunkt bereitstellen.

So erstellen Sie einen Prototyp eines Endpunkts für Toolaufrufe.

1. Wählen Sie im Playground ein Modell mit der Bezeichnung für Funktionsaufrufe aus.

   

2. Wählen Sie Tools aus, und geben Sie im Dropdownmenü Ihre Unity-Katalog-Funktionsnamen an:

   

3. Chatten Sie, um die aktuelle Kombination aus LLM, Tools und Systemsansagen zu testen und Variationen auszuprobieren.

   

Exportieren und Bereitstellen von KI-Playground-Agenten

Nachdem Sie Tools hinzugefügt und den Agenten getestet haben, exportieren Sie den Playground-Agenten in Python-Notizbücher:

1. Klicken Sie auf Agent-Code exportieren, um Python-Notebooks zu generieren, die Ihnen beim Entwickeln und Bereitstellen des KI-Agenten helfen.

   Nach dem Exportieren des Agentcodes werden drei Dateien in Ihrem Arbeitsbereich gespeichert:

   • agent Notebook: Enthält Python-Code, der Ihren Agent mithilfe von LangChain definiert.
   • driver Notebook: Enthält Python-Code zum Protokollieren, Ablaufverfolgen, Registrieren und Bereitstellen des KI-Agents mithilfe von Mosaik AI Agent Framework.
   • config.yml: Enthält Konfigurationsinformationen zu Ihrem Agenten, einschließlich Tooldefinitionen.

2. Öffnen Sie das agent Notebook, um den LangChain-Code anzuzeigen, der Ihren Agent definiert, verwenden Sie dieses Notizbuch, um den Agent programmgesteuert zu testen und zu durchlaufen, z. B. das Definieren weiterer Tools oder das Anpassen der Parameter des Agenten.

   Hinweis

   Der exportierte Code hat möglicherweise ein anderes Verhalten als Ihre KI-Playgroundsitzung. Databricks empfiehlt, die exportierten Notebooks zum Durchlaufen und Debuggen weiter auszuführen, die Agentenqualität auszuwerten und dann den Agenten für die Freigabe für andere bereitzustellen.

3. Wenn Sie mit den Ergebnissen des Agenten zufrieden sind, können Sie das driver Notebook ausführen, um den Agenten zu protokollieren und auf einem Model Serving-Endpunkt bereitzustellen.

Definieren eines Agents im Code

Neben der Generierung von Agentencode aus KI-Playground können Sie einen Agenten auch selbst in Code definieren, entweder mit Frameworks wie LangChain oder mit Python-Code. Um einen Agenten mit Agent Framework einzusetzen, muss seine Eingabe einem der unterstützten Eingabe- und Ausgabeformate entsprechen.

Verwenden von Parametern zum Konfigurieren des Agenten

Im Agent Framework können Sie Parameter verwenden, um zu steuern, wie Agents ausgeführt werden. Auf diese Weise können Sie schnell durch unterschiedliche Merkmale Ihres Agents iterieren, ohne den Code zu ändern. Parameter sind Schlüsselwertpaare, die Sie in einem Python-Wörterbuch oder einer .yaml Datei definieren.

Um den Code zu konfigurieren, erstellen Sie ein ModelConfig, einen Satz von Schlüsselwertparametern. ModelConfig ist entweder ein Python-Wörterbuch oder eine .yaml Datei. Sie können z. B. während der Entwicklung ein Wörterbuch verwenden und dann in eine .yaml Datei für die Produktionsbereitstellung und CI/CD konvertieren. Ausführliche Informationen zu ModelConfig finden Sie in der MLflow-Dokumentation.

Unten ist ein Beispiel ModelConfig angegeben.

llm_parameters:
  max_tokens: 500
  temperature: 0.01
model_serving_endpoint: databricks-dbrx-instruct
vector_search_index: ml.docs.databricks_docs_index
prompt_template: 'You are a hello world bot. Respond with a reply to the user''s
  question that indicates your prompt template came from a YAML file. Your response
  must use the word "YAML" somewhere. User''s question: {question}'
prompt_template_input_vars:
- question

Verwenden Sie eine der folgenden Optionen, um die Konfiguration aus Ihrem Code aufzurufen:

# Example for loading from a .yml file
config_file = "configs/hello_world_config.yml"
model_config = mlflow.models.ModelConfig(development_config=config_file)

# Example of using a dictionary
config_dict = {
    "prompt_template": "You are a hello world bot. Respond with a reply to the user's question that is fun and interesting to the user. User's question: {question}",
    "prompt_template_input_vars": ["question"],
    "model_serving_endpoint": "databricks-dbrx-instruct",
    "llm_parameters": {"temperature": 0.01, "max_tokens": 500},
}

model_config = mlflow.models.ModelConfig(development_config=config_dict)

# Use model_config.get() to retrieve a parameter value
value = model_config.get('sample_param')

Unterstützte Eingabeformate

Im Folgenden werden Eingabeformate für Ihren Agenten unterstützt.

• (Empfohlen) Abfragen mithilfe des OpenAI-Chatabschlussschemas. Es sollte ein Array von Objekten als messages Parameter aufweisen. Dieses Format eignet sich am besten für RAG-Anwendungen.

  question = {
      "messages": [
          {
              "role": "user",
              "content": "What is Retrieval-Augmented Generation?",
          },
          {
              "role": "assistant",
              "content": "RAG, or Retrieval Augmented Generation, is a generative AI design pattern that combines a large language model (LLM) with external knowledge retrieval. This approach allows for real-time data connection to generative AI applications, improving their accuracy and quality by providing context from your data to the LLM during inference. Databricks offers integrated tools that support various RAG scenarios, such as unstructured data, structured data, tools & function calling, and agents.",
          },
          {
              "role": "user",
              "content": "How to build RAG for unstructured data",
          },
      ]
  }
  

• SplitChatMessagesRequest. Empfohlen für Multi-Turn-Chatanwendungen, insbesondere, wenn Sie die aktuelle Abfrage und den Verlauf separat verwalten möchten.

  question = {
      "query": "What is MLflow",
      "history": [
          {
              "role": "user",
              "content": "What is Retrieval-augmented Generation?"
          },
          {
              "role": "assistant",
              "content": "RAG is"
          }
      ]
  }
  

Für LangChain empfiehlt Databricks, Ihre Kette in LangChain Expression Language zu schreiben. In Ihrem Kettendefinitionscode können Sie eine itemgetter verwenden, um die Nachrichten oder query oder history Objekte abzurufen, je nachdem, welches Eingabeformat Sie verwenden.

Unterstützte Ausgabeformate

Ihr Agent muss einem der folgenden unterstützten Ausgabeformate entsprechen:

• (Recommended) ChatCompletionResponse. Dieses Format wird für Kunden mit OpenAI-Antwortformatinteroperabilität empfohlen.
• StringObjectResponse Dieses Format ist am schlichtesten und am einfachsten zu interpretieren.

Verwenden Sie für LangChain StringResponseOutputParser() oder ChatCompletionsOutputParser() aus MLflow als letzten Kettenschritt. Dadurch wird die LangChain AI-Nachricht in ein agentkompatibles Format formatiert.

  from mlflow.langchain.output_parsers import StringResponseOutputParser, ChatCompletionsOutputParser

  chain = (
      {
          "user_query": itemgetter("messages")
          | RunnableLambda(extract_user_query_string),
          "chat_history": itemgetter("messages") | RunnableLambda(extract_chat_history),
      }
      | RunnableLambda(fake_model)
      | StringResponseOutputParser() # use this for StringObjectResponse
      # ChatCompletionsOutputParser() # or use this for ChatCompletionResponse
  )

Wenn Sie PyFunc verwenden, empfiehlt Databricks die Verwendung von Typhinweisen, um die predict() Funktion mit Eingabe- und Ausgabedatenklassen zu kommentieren, die Unterklassen von Klassen sind, die in mlflow.models.rag_signatures definiert sind.

Sie können ein Ausgabeobjekt aus der Datenklasse innerhalb von predict() erstellen, um sicherzustellen, dass das Format befolgt wird. Das zurückgegebene Objekt muss in eine Wörterbuchdarstellung umgewandelt werden, um sicherzustellen, dass es serialisiert werden kann.

  from mlflow.models.rag_signatures import ChatCompletionRequest, ChatCompletionResponse, ChainCompletionChoice, Message

  class RAGModel(PythonModel):
    ...
      def predict(self, context, model_input: ChatCompletionRequest) -> ChatCompletionResponse:
        ...
        return asdict(ChatCompletionResponse(
            choices=[ChainCompletionChoice(message=Message(content=text))]
        ))

Beispielnotebooks

Diese Notizbücher erstellen eine einfache "Hello, world"-Kette, um zu veranschaulichen, wie eine Kettenanwendung in Databricks erstellt wird. Im ersten Beispiel wird eine einfache Kette erstellt. Das zweite Beispielnotizbuch veranschaulicht, wie Sie Parameter verwenden, um Codeänderungen während der Entwicklung zu minimieren.

Einfaches Kettennotizbuch

Notebook abrufen

Einfaches Kettentreibernotizbuch

Notebook abrufen

Parametrisiertes Kettennotizbuch

Notebook abrufen

Parametrisiertes Kettentreibernotizbuch

Notebook abrufen

Nächste Schritte

• KI-Agents protokollieren.
• Hinzufügen einer Ablaufverfolgung zu einem KI-Agenten.
• Bereitstellen eines KI-Agenten.