Zuverlässiger KI-Agent in Produktion mit Java Quarkus Langchain – Teil AI as Service

Autoren

@herbertbeckman – LinkedIn
@rndtavares – LinkedIn

Teile des Artikels

1. Zuverlässiger KI-Agent in der Produktion mit Java Quarkus Langchain4j – Teil 1 – KI als Service (dieser Artikel)

2. Zuverlässiger KI-Agent in Java Quarkus Langchain4j prod – Teil 2 – Speicher (in Kürze verfügbar)

3. Zuverlässiger KI-Agent in der Entwicklung mit Java Quarkus Langchain4j – Teil 3 – RAG (bald verfügbar)

4. Vertrauenswürdiger KI-Agent in der Produktion mit Java Quarkus Langchain4j – Teil 4 – Leitplanken (in Kürze verfügbar)

Einführung

Immer wenn wir einen Boom neuer Technologien erleben, sind Unternehmen bestrebt, diese anzuwenden und aus geschäftlicher Sicht die lang erwarteten Ergebnisse zu erzielen. Es ist der Wettlauf um Innovation und der Kampf um First-Mover-Vorteile. Inmitten dieses Wettlaufs geben Unternehmen, die zuvor besorgt waren, häufig aufgrund einer Reihe von Faktoren auf, von denen einer der wichtigsten die Zuverlässigkeit eines Systems im Allgemeinen ist. Künstliche Intelligenz (KI) durchläuft derzeit eine ihrer größten Widerstandsproben und unsere Aufgabe als Softwareentwickler ist es, Unternehmen zu zeigen, dass es durchaus möglich ist, eine Reihe von Aufgaben und Prozessen mit dem bewussten und richtigen Einsatz von KI durchzuführen . In diesem Artikel werden wir in drei Teilen zeigen, welche Funktionalitäten und Prozesse ein zuverlässiger KI-Agent in der Produktion haben muss, damit ein Unternehmen die lang erwarteten Ergebnisse erzielt, und wir werden gemeinsam einige auf dem Markt verwendete Konzepte umsetzen . Wir werden auch die Schwerpunkte dieser Lösung detailliert beschreiben und bitten Sie als Entwickler, so viele Tests wie möglich durchzuführen und uns so viel Feedback wie möglich zu geben, damit wir gemeinsam dieses Verständnis weiter verbessern können.

Implementierte Funktionen

• Chatten
• Werkzeuge
• Chat-Speicher
• Retrieval-Augmented Generation (RAG)
• Leitplanken

Konzepte und Definitionen

Assistent vs. Copilot vs. Agent

Eine der ersten Fragen, die Sie möglicherweise haben, ist, wie sich ein Agent von anderen KI-Anwendungsfällen unterscheidet. Der Agent verfügt über Funktionen, die eher mit der Automatisierung verbunden sind, während die Aktivitäten der anderen auf Unterstützung und Zeitoptimierung abzielen. Im Folgenden beschreibe ich die einzelnen Anwendungsfälle ausführlicher.

Assistenten

Assistenten können uns helfen und uns viel Zeit beim Überprüfen von Informationen ersparen und eine gute Quelle für den Wissensaustausch sein. Sie sprechen ÜBER die unterschiedlichsten Themen und können nützlich sein, wenn wir eine klare Argumentation benötigen, um die Prämissen eines Arguments zu analysieren. Natürlich haben sie viel mehr Befugnisse, aber ich möchte, dass Sie sich auf das konzentrieren, was ein Assistent tut: Er spricht mit Ihnen und das ist alles. Er kann NUR über etwas sprechen, es zusammenfassen, ins Detail gehen usw. Als Beispiele haben wir: ChatGPT, Claude AI und Gemini.

Copiloten

Copiloten sind etwas leistungsfähiger als Assistenten. Sie können tatsächlich etwas tun, eine konkretere Aktion, z. B. einen Text ändern und/oder Modifikationen in Echtzeit vorschlagen, sowie Tipps während einer Änderung und/oder eines Ereignisses in einem Kontext geben. Wie bereits erwähnt, hängt dies jedoch vom Kontext ab und verfügt nicht immer über alle notwendigen Informationen, um einen guten Vorschlag zu machen. Es hängt auch von Ihrer ausdrücklichen Genehmigung ab, wodurch eine direkte Abhängigkeit vom Benutzer entsteht. Gute Beispiele sind: Github Copilot, Codium und Microsoft Copilot.

Agenten

Das Hauptziel der Agenten besteht darin, Aufgaben mit klaren Zielen auszuführen. Ihr Fokus liegt auf der Automatisierung, das heißt, sie erledigen konkrete Arbeiten tatsächlich autonom. All dies ist nur durch die Tools möglich, die wir ihnen zur Verfügung stellen. Der Agent ist nicht das LLM selbst, sondern seine Anwendung, die dieses LLM koordiniert. Verstehen Sie das LLM als das Gehirn des Systems, das Entscheidungen trifft, und seine Anwendung als die Mitglieder des Körpers dieses Gehirns. Was bringt es mir, darüber nachzudenken, mir ein Glas Wasser zu holen, wenn ich es mit der Hand nicht erreichen kann? Ihr Agent gibt LLM die Möglichkeit, etwas auf sichere, überprüfbare und vor allem zuverlässige Weise zu erledigen.

Maßnahmen ergreifen

In diesem ersten Teil des Artikels werden wir den AIService im Projekt implementieren, der nichts anderes als die Schnittstellenschicht mit unserem KI-Anbieter ist. In diesem Projekt verwenden wir das LLM von OpenAI, aber Sie können Ihren bevorzugten Anbieter hinzufügen und die Abhängigkeiten darauf basierend anpassen.

Da wir nun die Konzepte klar definiert haben und wissen, was wir hier tun werden, fahren wir mit dem Codieren fort!

Erstellen des Projekts

Erstellen Sie ein Quarkus-Projekt und wählen Sie Ihren Abhängigkeitsmanager und Erweiterungen in Quarkus aus – Beginnen Sie mit dem Codieren.

Projektabhängigkeiten

Wir werden Maven als Abhängigkeitsmanager des Projekts verwenden. Nachfolgend sind die ersten Abhängigkeiten aufgeführt, die wir hinzugefügt haben.

Mavem

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-websockets-next</artifactId>
</dependency>

<dependency>
  <groupId>io.quarkiverse.langchain4j</groupId>
  <artifactId>quarkus-langchain4j-core</artifactId>
  <version>0.20.3</version>
</dependency>

<dependency>
  <groupId>io.quarkiverse.langchain4j</groupId>
  <artifactId>quarkus-langchain4j-openai</artifactId>
  <version>0.20.3</version>
</dependency>

Projektkonfiguration

Fügen Sie die folgenden Eigenschaften zur Datei src/main/resources/application.properties hinzu:

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-websockets-next</artifactId>
</dependency>

<dependency>
  <groupId>io.quarkiverse.langchain4j</groupId>
  <artifactId>quarkus-langchain4j-core</artifactId>
  <version>0.20.3</version>
</dependency>

<dependency>
  <groupId>io.quarkiverse.langchain4j</groupId>
  <artifactId>quarkus-langchain4j-openai</artifactId>
  <version>0.20.3</version>
</dependency>

Ersetzen Sie YOUR_OPENAPI_KEY_HERE durch den Schlüssel (apiKey), den Sie auf der OpenAI-Plattform registriert haben.

TIPP: Erstellen Sie eine Umgebungsvariable in Ihrer IDE und ändern Sie dann die Eigenschaft quarkus.langchain4j.openai.api-key in:

quarkus.tls.trust-all=true
quarkus.langchain4j.timeout=60s
quarkus.langchain4j.openai.api-key=YOUR_OPENAI_API_KEY_HERE

Erstellen unseres AIService

Zuerst müssen wir unseren AIService erstellen, der die Klasse sein wird, die dafür verantwortlich ist, unserem Agenten eine „Persönlichkeit“ zu verleihen. Dazu erstellen wir im Verzeichnis src/main/java/ die Klasse namens Agent mit dem folgenden Code:

quarkus.langchain4j.openai.api-key=${OPEN_API_KEY:NAO_ENCONTREI_A_VAR}

Wie Sie unserem SystemPrompt (@SystemMessage) entnehmen können, haben wir einen auf Fußball spezialisierten Agenten erstellt.

Erstellen unseres Chats

Da wir nun unseren Agenten erstellt haben, müssen wir die Klasse erstellen, die unseren Chat mit ihm abwickelt. Dazu erstellen wir im Verzeichnis src/main/java/ die Klasse AgentWSEndpoint mit dem folgenden Code:

package <seupacote>;

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import io.quarkiverse.langchain4j.RegisterAiService;
import jakarta.enterprise.context.ApplicationScoped;

@ApplicationScoped
@RegisterAiService
public interface Agent {

    @SystemMessage("""
            Você é um agente especializado em futebol brasileiro, seu nome é FutAgentBR
            Você sabe responder sobre os principais títulos dos principais times brasileiros e da seleção brasileira
            Sua resposta precisa ser educada, você pode deve responder em Português brasileiro e de forma relevante a pergunta feita

            Quando você não souber a resposta, responda que você não sabe responder nesse momento mas saberá em futuras versões.
            """)
    String chat(@UserMessage String message);
}

Jetzt können Sie über die Quarkus-Entwickler-Benutzeroberfläche mit Ihrem Agenten sprechen, der derzeit noch als Assistent tätig ist. Hier sind einige Ausdrucke als Orientierung:

Hinzufügen unserer Tools (Funktionsaufruf)

Kommen wir nun zu den Details, die den Unterschied zwischen einem Agenten und einem Assistenten ausmachen. Wir geben unserem Agenten die Möglichkeit, Aufgaben und/oder Prozesse auszuführen, indem wir Tools hinzufügen (Funktionsaufruf). Bevor wir dies programmieren, haben wir eine kurze Grafik, die zeigt, wie der Aufruf eines Tools auf Makroebene funktioniert.

Quelle: surface.ai

Da wir nun wissen, wie ein Tool-Aufruf funktioniert, müssen wir die Klasse mit unseren Tools erstellen. Sie können auch mehrere verschiedene Klassen für jedes Tool erstellen. In diesem Beispiel erstellen wir eine „ToolBox“, also eine Toolbox, in der die Tools gruppiert sind, die unser Agent verwenden kann. Hier ist der Code:

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-websockets-next</artifactId>
</dependency>

<dependency>
  <groupId>io.quarkiverse.langchain4j</groupId>
  <artifactId>quarkus-langchain4j-core</artifactId>
  <version>0.20.3</version>
</dependency>

<dependency>
  <groupId>io.quarkiverse.langchain4j</groupId>
  <artifactId>quarkus-langchain4j-openai</artifactId>
  <version>0.20.3</version>
</dependency>

Kurz darauf haben wir unserem Agenten über die Annotation @ToolBox(AgentTools.class) eine Annotation hinzugefügt, die ihn darüber informiert, welche Tools er verwenden kann. Es sieht so aus:

quarkus.tls.trust-all=true
quarkus.langchain4j.timeout=60s
quarkus.langchain4j.openai.api-key=YOUR_OPENAI_API_KEY_HERE

Jetzt können Sie Ihren Agenten fragen, wie spät es ist, nach dem heutigen Datum, ihn bitten, zwei Zahlen zu addieren und die Quadratwurzel zu berechnen. Dies sind die Tools, die wir hier zur Veranschaulichung verwenden. Sie können diese jedoch durch einen HTTP-Aufruf, eine Hashing-Funktion, eine SQL-Abfrage usw. ersetzen. Die Möglichkeiten hier sind vielfältig.

Testen über die Quarkus DEV-Benutzeroberfläche

Hier ist ein Screenshot eines der Tests, die nach dem Hinzufügen der Tools durchgeführt wurden:

Wie Sie sehen können, haben wir für jeden Tool-Aufruf ein Protokoll, aus dem hervorgeht, dass LLM tatsächlich den Code aufgerufen hat, für dessen Ausführung wir es autorisiert haben.

Nächste Schritte

Damit ist der Beginn der Schöpfung in unserem Agenten abgeschlossen. Wir werden unserem Agenten in Teil 2 bald Speicher hinzufügen, in Teil 3 die RAG (Retrieval-Augmented Generation) und in Teil 4 die Guardrails. Ich hoffe es hat euch gefallen und bis bald.

Aber Sie können jetzt mitverfolgen und ALLEN den Code des Artikels in diesem GitHub-Repository sehen.

Das obige ist der detaillierte Inhalt vonZuverlässiger KI-Agent in Produktion mit Java Quarkus Langchain – Teil AI as Service. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!