KI-Agenten befähigen ihre eigenen Werkzeuge zu entwickeln

Große Sprachmodelle (LLMs): Über die Texterzeugung hinaus

Was sind LLMs? Large Language Models (LLMs) sind Computerprogramme, die Ähnlichkeiten „lernen“ und menschenähnlichen Text erzeugen. Sie werden anhand großer Mengen schriftlichen Materials - Bücher, Websites und Artikel - trainiert, damit sie die bestmöglichen Wörter vorhersagen können, die in einem Satz folgen. Dieses Training hilft ihnen, auf Fragen zu antworten, Gespräche zu führen und neue Texte zu erstellen, die oft so klingen, als wären sie von einem Menschen geschrieben worden.

Grenzen der Texterstellung: Auch wenn die LLMs immer besser darin werden, Texte zu produzieren, gehen die meisten Aufgaben in der IT-Welt über die einfache Texterstellung hinaus. Fachleute verbringen viel Zeit damit, zu recherchieren, Anwendungen zu öffnen und zu benutzen, Ideen zu entwerfen und umzusetzen und Funktionen zu testen. Diese Aufgaben sind auf programmatische und visuelle Schnittstellen - d.h. Werkzeuge - angewiesen, nicht nur auf die Textausgabe.

Das "Erdbeer"-Beispiel: Eine einfache Veranschaulichung der LLM-Beschränkungen

Selbst leistungsstarke LLMs können über scheinbar triviale Probleme stolpern, wenn sie sich ausschließlich auf statistische Muster verlassen. Betrachten Sie das folgende Beispiel:

Aufforderung: Wie viele e's sind in dem Wort „Erdbeere“?

LLM-Antwort: In dem Wort „Erdbeere“ sind zwei „2“ enthalten.

Die Antwort des LLM ist falsch, sie zeigt, dass eine rein probabilistische Texterstellung zu Fehlern führen kann. Ohne Zugang zu externen Werkzeugen oder Methoden, um die Antwort zu überprüfen, können Modelle, welche rein auf wahrscheinlichkeiten basieren, selten das richtige Ergebnis auf komplexe Aufgaben oder Fragestellung liefern.

Erweiterung der LLM-Funktionalität mit Werkzeugen

Moderne LLMs können teilweise vordefinierte Werkzeuge aufrufen, um genauere Informationen zu erhalten und bestimmte Aufgaben durchzuführen. Eine Liste der verfügbaren Werkzeuge wird der Benutzeranfrage hinzugefügt, und das LLM kann sie bei Bedarf aufrufen. Die Werkzeuge können LLMs in folgenden 2 Bereichen verbessern:

1. Deterministische Gewissheit: Viele Aufgaben innerhalb der Arbeitsabläufe und Aufgaben von Unternehmen sollten immer das gleiche Ergebnis liefern. Die Verwendung von klassisch programmierten Tools garantiert Konsistenz - anstatt sich auf eine wahrscheinlichkeitsgesteuerte Vermutung des LLMs zu verlassen.

2. Externe Anwendungen und APIs: LLMs können über Werkzeuge APIs aufrufen, wie Jira-Tickets lesen, kommentieren, erstellen, Dateien ändern und Code schreiben oder testen. Durch die Interaktion mit diesen Werkzeugen geht ein LLM über die Texterstellung hinaus.

   
   

Ein Beispiel für ein Zeichenzählungswerkzeug

Zurück zu unserem Erdbeer-Beispiel. Wir könnten ein Werkzeug wie das folgende programmieren, um ein Zeichen in einer gegebenen Zeichenkette zu zählen:

from crewai.tools import tool
@tool("countCharacters")
def countCharacters(sentence: str, characterToCount: str) -> str:
    """
    Counts the number of times the specified character appears in the given sentence.
    Args:
        sentence (str): The sentence to analyze.
        characterToCount (str): The character to count.

    Returns:
        str: The count of the specified character in the sentence.
    """
    try:
        if len(characterToCount) != 1:
            return "Error: characterToCount should be a single character."
        count = sentence.count(characterToCount)
        return f"The character '{characterToCount}' appears {count} times in the given sentence."
    except Exception as e:
        return f"An error occurred while tool execution: {str(e)}"

Indem wir dieses Werkzeug in die Eingabeaufforderung für das LLM einbeziehen, kann das Modell erkennen, wann es zu verwenden ist, und somit genauere Antworten liefern. Dieser Prozess erfordert jedoch immer noch einen erheblichen manuellen Aufwand und kann mühsam sein.

Glücklicherweise sind ein Großteil der Dokumentation und der Richtlinien für diese Schnittstellen im Internet oder in privaten Unternehmensnetzwerken öffentlich zugänglich, und moderne LLMs sind bereits in der Lage im Internet und auf privaten Wissenverwaltungsystemen zu suchen und Code zu generieren.

Unser Framework geht noch einen Schritt weiter, indem es Agenten die Möglichkeit gibt während des sogenannten "reasoning" Prozesse ihre eigenen Tools zu erstellen und diese zu verwenden - was ihnen weit mehr als nur die Generierung von Text ermöglicht.

Folgende DemoLauf wurde bisher nur auf englisch durchgeführt. Im Aufgabenverwaltungstool Jira ist folgende Aufgabe hinterlegt:

DP-7: For my llm execution it would be create to have a terraform template ready to run whenever i need to have a fast executing LLM. 

So add a terraform file in git repository 

git@github.com:agentsphere/infra.git

 to start a GCP Compute instance with one H100 GPU instance

Mit einigen Jira-Variablen in der Umgebung (wie url und Zugangsdaten) können wir unser Tools-Verzeichnis während der folgenden Aufforderung beobachten:

„Bitte lösen Sie die Jira-Aufgabe 'DP-7' für mich. Erstellen Sie einen PR mit Ihren Änderungen und kommentieren Sie die Aufgabe, wenn Sie fertig sind."

original: "Please solve Jira Task 'DP-7' for me. create a PR with your changes, comment on the task when you are done"

...und das LLM hat alle geeigneten Werkzeuge erstellt und eingesetzt, um diese Aufgabe automatisch durchzuführen.

Kommentar in Jira:

"Added 1 PR to git@github.com:agentsphere/infra.git repo containing the added gcp compute instance."

Pullrequest in Github:

Selbst Commit und Branch name sehen soweit gut aus.

Das sieht eher nach der Arbeit aus, die IT-Fachleute tatsächlich tun.