Erste Schritte mit Java und KI: Leitfaden zur LLM-Integration

OpenAI-API-Schlüssel erhalten

Die Beantragung Ihres OpenAI-API-Schlüssels ist einfach. Befolgen Sie diese Schritte:

1. Registrieren Sie sich oder melden Sie sich an. Gehen Sie zu OpenAI und erstellen Sie ein Konto oder melden Sie sich an, wenn Sie bereits eines haben.
2. Navigieren Sie zum Abschnitt API Keys. Suchen Sie in Ihrem Konto-Dashboard den Abschnitt API Keys.
3. Generieren Sie Ihren API-Schlüssel und speichern Sie ihn sicher. Klicken Sie auf die Schaltfläche, um einen neuen API-Schlüssel zu generieren. Bewahren Sie ihn an einem sicheren Ort auf, da Sie ihn später nicht mehr einsehen können.

Richten Sie Ihre Umgebung ein

Speichern Sie Ihren API-Schlüssel sicher als Umgebungsvariable. Je nach verwendetem Betriebssystem gehen Sie dazu wie folgt vor:

• Unter Windows navigieren Sie zu: Systemeigenschaften > Umgebungsvariablen > Benutzervariablen > OPENAI_API_KEY hinzufügen.
• Unter macOS oder Linux fügen Sie export OPENAI_API_KEY=‚Ihr-API-Schlüssel‘ zu Ihrer .bashrc- oder .zshrc-Datei hinzu.

Einfaches CLI-Beispiel: Das Hello World von Java und LLM

Beginnen wir mit einem einfachen Beispiel, das die Verwendung von Java und dem GPT-Modell von OpenAI über eine Kommandozeilenschnittstelle demonstriert. In diesem Beispiel wird der in Java integrierte HTTP-Client verwendet, um API-Anfragen an OpenAI zu stellen.

package ca.bazlur;

import java.net.http.*;
import java.net.URI;
import java.time.Duration;

public class Main {

   private static final String API_URL = "https://api.openai.com/v1/chat/completions";

   public static void main(String[] args) throws Exception {
       String apiKey = System.getenv("OPENAI_API_KEY");
       if (apiKey == null || apiKey.isBlank()) {
           System.err.println("Fehler: Umgebungsvariable OPENAI_API_KEY nicht gesetzt.");
           System.exit(1);
       }

       if (args.length == 0 || args[0].isBlank()) {
           System.err.println("Fehler: Bitte geben Sie ein Prompt ein.");
           System.exit(1);
       }

       String prompt = args[0];

       String requestBody = """
               {
                   "model": "gpt-4",
                   "messages": [{"role": "user", "content": "%s"}],
                   "temperature": 0.7,
                   "max_tokens": 150
               }
               """.formatted(prompt);


       try (HttpClient client = HttpClient.newHttpClient()) {
           HttpRequest request = HttpRequest.newBuilder()
                   .uri(URI.create(API_URL))
                   .header("Content-Type", "application/json")
                   .header("Authorization", "Bearer " + apiKey)
                   .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                   .timeout(Duration.ofSeconds(30))
                   .build();
           HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
           System.out.println("ChatGPT Response: " + response.body());
       }
   }
}

Im obigen Code haben wir den Request-Body als JSON-String erstellt und das Modell (gpt-4), die Nachricht des Benutzers, die Temperatur und die maximale Anzahl von Tokens angegeben. Der Modellparameter gibt an, welches OpenAI-Modell verwendet werden soll; gpt-4 ist eine leistungsstarke und vielseitige Option. Das Array messages enthält den Verlauf der Konversation, und der Parameter role gibt an, wer die Nachricht gesendet hat. Die Temperatur und die maximale Anzahl von Tokens sind entscheidend für die Steuerung der Ausgabe.

Der Parameter temperature, der zwischen 0 und 1 liegt, beeinflusst die Zufälligkeit des generierten Textes. Eine höhere Temperatur macht die Ausgabe kreativer und unvorhersehbarer, während eine niedrigere Temperatur zu einer konservativeren und vorhersehbareren Ausgabe führt. Wenn Sie beispielsweise mit einer Temperatur von 0,2 Erzähl mir einen Witz fragen, erhalten Sie möglicherweise einen klassischen, bekannten Witz, während eine Temperatur von 1,0 eine absurdere und originellere Antwort generieren könnte, die jedoch möglicherweise weniger kohärent ist.

Der Parameter max_tokens begrenzt die Länge des generierten Textes, was für die Kostenkontrolle und zur Vermeidung übermäßig langer Antworten entscheidend ist. Wenn Sie max_tokens auf 50 setzen, gibt das Modell eine Antwort, die 50 Token nicht überschreitet. Eine zu niedrige Einstellung kann zu einer vorzeitigen Abschneidung der Antwort führen, während eine zu hohe Einstellung zu ausführlichen oder weitschweifigen Antworten führen kann.

Anschließend haben wir einen HttpClient erstellt, um die API-Anfrage zu senden, und einen HttpRequest mit dem API-Endpunkt, den Headern (Content-Type und Authorization) und dem Request-Body erstellt. Wir haben die Anfrage mit client.send() gesendet, die Antwort abgerufen und schließlich den Antworttext in der Konsole ausgegeben.

So führen Sie den Code aus dem folgenden Beispiel aus:

1. Speichern Sie den Code als Main.java.
2. Führen Sie den Code aus: java Main.java ”Was ist die Hauptstadt von Toronto?”

Und wir erhalten die folgende Ausgabe:

{
  "id": "chatcmpl-BDTz5FwsX1rAfcjQZYP64JBWuUopl",
  "object": "chat.completion",
  "created": 1742553223,
  "model": "gpt-4-0613",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Toronto ist eine Stadt, kein Land, daher hat es keine Hauptstadt. Es ist die Hauptstadt der Provinz Ontario in Kanada.",
        "refusal": null,
        "annotations": []
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 14,
    "completion_tokens": 31,
    "total_tokens": 45,
    "prompt_tokens_details": {
      "cached_tokens": 0,
      "audio_tokens": 0
    },
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "audio_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  },
  "service_tier": "default",
  "system_fingerprint": null
}

Diese JSON-Daten enthalten Informationen wie Nutzung, das verwendete Modell, einen Zeitstempel und den tatsächlichen Nachrichteninhalt des Assistenten. Wir können sie dann mit einem JSON-Parser analysieren und die benötigten Informationen extrahieren.

Integration mit LangChain4j (OpenAI SDK)

Während das vorherige Beispiel einen direkten Ansatz für die Interaktion mit der OpenAI-API zeigt, müssen dabei HTTP-Anfragen manuell erstellt und JSON-Antworten geparst werden. Dies kann mühsam und fehleranfällig sein, insbesondere bei der Erstellung komplexer Anwendungen.

Die Java-native Bibliothek LangChain4j vereinfacht diesen Prozess. Sie bietet eine hochgradig intuitive API für die Interaktion mit LLMs wie den GPT-Modellen von OpenAI und abstrahiert die zugrunde liegenden Komplexitäten von API-Aufrufen, sodass sich Entwickler auf die Logik der Anwendung konzentrieren können.

LangChain4J OpenAI-Beispiel

Richten wir ein einfaches Maven-Projekt oder Gradle-Projekt mit mehreren Abhängigkeiten ein. So würde das in einer Maven-Datei pom.xml aussehen:

<dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j</artifactId>
        <version>1.0.0-beta2</version>
    </dependency>

    <dependency>
        <groupId>dev.langchain4j</groupId>
        <artifactId>langchain4j-open-ai</artifactId>
        <version>1.0.0-beta2</version>
    </dependency>

Oder für build.gradle:

implementation 'dev.langchain4j:langchain4j:1.0.0-beta2'
implementation 'dev.langchain4j:langchain4j-open-ai:1.0.0-beta2'

Beispiel mit LangChain4j

Erstellen wir nun eine Java-Klasse, die LangChain4j für die Interaktion mit OpenAI verwendet:

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;

public class LLMExample {
    public static void main(String[] args) {
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("OPENAI_API_KEY"))
                .modelName("gpt-4")
                .temperature(0.7)
                .maxTokens(150)
                .build();

        String response = model.chat("Was ist die Hauptstadt von Toronto?");
        System.out.println(response);
    }
}

In diesem Code haben wir eine Instanz von OpenAiChatModel mithilfe des Builder-Musters erstellt. Wir haben den API-Schlüssel, den Modellnamen, die Temperatur und die maximale Anzahl von Tokens festgelegt. Wie im vorherigen Beispiel beeinflusst der Parameter temperature die Zufälligkeit des generierten Textes, sodass dieser konservativ und vorhersehbar oder kreativer, aber weniger kohärent ist, während max_tokens als Maßnahme zur Kostenkontrolle übermäßig lange Antworten verhindert. Experimentieren Sie mit diesen Parametern, um die Ausgabe des LLM erheblich zu verändern und an Ihre spezifischen Bedürfnisse anzupassen.

Durch Aufrufen der Methode chat() für das Modell wird der Prompt des Benutzers übergeben, die Methode gibt den generierten Text zurück und schließlich wird die Antwort in der Konsole ausgegeben.

Um dieses Beispiel auszuführen, führen wir zwei Schritte aus:

1. Speichern Sie den Code als LLMExample.java im Verzeichnis src/main/java Ihres Maven/Gradle-Projekts.
2. Kompilieren und führen Sie den Code mit Maven aus: mvn compile exec:java -Dexec.mainClass=“LLMExample“

Alternativ können Sie dies mit Gradle ausführen, indem Sie den folgenden Befehl verwenden: ./gradlew run

Sie sollten eine Antwort von ChatGPT auf Ihrer Konsole sehen.

LangChain4j und andere KI-Modelle

Neben OpenAI unterstützt LangChain4j die Integration mit anderen LLMs, sodass Entwickler mit verschiedenen LLMs experimentieren und das für ihre Anforderungen am besten geeignete auswählen können. Wenn wir beispielsweise die Gemini-API von Google verwenden möchten, passen wir den Code an, um die Basis-URL und den Modellnamen wie folgt zu ändern:

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;

public class LLMGeminiExample {
   public static void main(String[] args) {
       ChatLanguageModel model = OpenAiChatModel.builder()
               .apiKey(System.getenv("GOOGLE_API_KEY"))
               .baseUrl("https://generativelanguage.googleapis.com/v1beta/openai/")
               .modelName("gemini-2.0-flash")
               .temperature(0.7)
               .maxTokens(150)
               .build();

       String response = model.chat("Was ist die Hauptstadt von Toronto?");
       System.out.println(response);
   }
}

Natürlich müssen Sie den Gemini API-Schlüssel anfordern, den Sie in Google AI Studio erhalten. Speichern Sie ihn in einer Umgebungsvariablen.

Beachten Sie auch, dass wir dasselbe OpenAI-Modell verwendet haben. Tatsächlich handelt es sich hierbei um das Standard-SDK für die meisten Modelle, damit wir es einheitlich verwenden können.

Der Quellcode für diese Java- und OpenAI-LLM-Beispiele ist auf GitHub verfügbar.

Was Sie als Nächstes mit Java, OpenAI und LLMs tun können

Nachdem Sie Ihre erste Java- und LLM-Anwendung erstellt haben, können Sie diese grundlegende Konfiguration erweitern, um tiefere Integrationen zu erkunden und komplexere KI-gestützte Java-Anwendungen zu entwickeln. Hier sind einige Ideen für weitere Erkundungen:

• Erstellen Sie einen Chatbot. Erstellen Sie einen einfachen Chatbot, der Benutzerfragen zu einem bestimmten Thema beantwortet.
• Implementieren Sie eine Textzusammenfassung. Verwenden Sie ein LLM, um lange Artikel oder Dokumente zusammenzufassen.
• Generieren Sie kreative Inhalte. Experimentieren Sie mit LLMs, um Gedichte, Geschichten oder Code zu generieren.
• Entdecken Sie verschiedene KI-Modelle. Versuchen Sie die Integration mit anderen LLMs, wie zum Beispiel Anthropic API.

Mit etwas Übung und Selbstvertrauen sind Sie bereit, fortgeschrittene Themen rund um Java und KI zu erkunden, darunter Optimierungen und praktische LLM-Implementierungen in Java.