Wie man die ChatGPT API in Java nutzen kann

OpenAI’s GPT-3 bzw. ChatGPT ist ein leistungsstarkes Sprachmodell, das menschenähnlichen Text generieren kann. In diesem Artikel zeigen wir Ihnen, wie Sie dieses innovative Sprachmodell in Ihren Java-Anwendungen nutzen können. Mit GPT-3 können Sie menschenähnlichen Text generieren, der für verschiedene Anwendungsfälle wie Chatbots, autonome Schreibassistenten und vieles mehr verwendet werden kann. Wir werden Ihnen die Schritte zeigen, die erforderlich sind, um GPT-3 mithilfe von Java und der OpenAI API zu integrieren, damit Sie dieses leistungsstarke Werkzeug in Ihren Projekten effektiv einsetzen können.

Voraussetzungen für GPT-3 / ChatGPT in Java

Bevor du dich in die Integration der ChatGPT-API in Java stürzt, melde dich auf der Plattform von OpenAI an, um deinen API-Schlüssel zu erhalten. Dieser Schlüssel dient als Authentifizierungsmechanismus für deine Anfragen. Sobald du dich registriert hast, greife auf dein OpenAI-Dashboard zu. Hier findest du deinen API-Schlüssel und verwaltest andere Einstellungen in Bezug auf dein OpenAI-Konto. Navigiere innerhalb deines Dashboards zum API-Bereich. Hier erstellst du deinen einzigartigen API-Schlüssel. Dieser Schlüssel ist eine vertrauliche Anmeldeinformation, die sorgfältig behandelt werden sollte, da sie Zugang zum leistungsstarken Sprachmodell von OpenAI gewährt. Kopiere deinen API-Schlüssel in die Zwischenablage. Dieser Schlüssel wird in deinen Java-Code integriert, um Anfragen an die ChatGPT-API zu authentifizieren.

ChatGPT API Integration in Java

Verwende diesen Code, um die ChatGPT-API in Java zu nutzen:

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;

public class ChatGPT {

    public static String generateChatGPTResponse(String userPrompt) {
        String apiURL = "https://api.openai.com/v1/chat/completions";
        String apiKey = "DEIN_API_SCHLÜSSEL";
        String LLMname = "gpt-3.5-turbo";

        try {
            // URL-Objekt erstellen
            URL url = new URL(apiURL);
            // Verbindung öffnen
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

            // Anforderungsmethode auf POST setzen
            connection.setRequestMethod("POST");
            // Anforderungsheader setzen
            connection.setRequestProperty("Authorization", "Bearer " + apiKey);
            connection.setRequestProperty("Content-Type", "application/json");

            // Anforderungskörper erstellen
            String requestBody = "{\"model\": \"" + LLMname + "\", \"messages\": [{\"role\": \"user\", \"content\": \"" + userPrompt + "\"}]}";

            // Ein-/Ausgabeströme aktivieren
            connection.setDoOutput(true);
            // Anforderungskörper schreiben
            try (OutputStreamWriter writer = new OutputStreamWriter(connection.getOutputStream())) {
                writer.write(requestBody);
                writer.flush();
            }

            // Antwort lesen
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
                StringBuilder response = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                return getLLMResponse(response.toString());
            }
        } catch (IOException e) {
            throw new RuntimeException("Fehler beim Interagieren mit der ChatGPT-API: " + e.getMessage(), e);
        }
    }

    private static String getLLMResponse(String response) {
        int firstChar = response.indexOf("content") + 11;
        int lastChar = response.indexOf("\"", firstChar);
        return response.substring(firstChar, lastChar);
    }

    public static void main(String[] args) {
        String userPrompt = "Hallo Robot, das ist mein erster API-Call. Erzähle mir einen Witz!";
        String chatGPTResponse = generateChatGPTResponse(userPrompt);
        System.out.println(chatGPTResponse);
    }
}

Erklärung des Codes

Konfiguration der Java-Klassen

Importieren Sie die erforderlichen Java-Klassen für die Verarbeitung von HTTP-Verbindungen und Ein-/Ausgabeoperationen. Erstellen Sie eine Klasse namens ChatGPT, die den Integrationscode enthält.

Definition der ChatGPT-Methode

Innerhalb der Klasse ChatGPT definieren Sie die Methode chatGPT. Diese Methode nimmt eine Benutzeranfrage als Eingabe entgegen und gibt die Antwort von ChatGPT zurück. Sie verarbeitet die HTTP-Verbindung, sendet Anfragen an den ChatGPT-API-Endpunkt und verarbeitet die JSON-formatierte Antwort.

Konfiguration der Parameter

Geben Sie wichtige Parameter wie die API-Endpunkt-URL, Ihren OpenAI-API-Schlüssel, den Sie in Schritt 1 erhalten haben, und das ChatGPT-Modell, das Sie verwenden möchten (z.B. gpt-3.5-turbo), an.

Verarbeitung des HTTP-POST-Anforderungs (API)

Erstellen Sie eine HTTP-POST-Anforderung, öffnen Sie eine Verbindung, richten Sie Anforderungsheader ein und definieren Sie den Anforderungskörper mit einem JSON-String, der das Modell und die Benutzeranfrage enthält.

Verarbeitung der Antwort

Rufen Sie die Antwort von ChatGPT ab und verarbeiten Sie sie. Extrahieren Sie den relevanten Inhalt aus dem JSON-Format.

Ausführung der Hauptmethode

Testen Sie den Code, indem Sie die chatGPT-Methode mit einer Beispielanfrage aufrufen. Die Antwort wird in der Konsole angezeigt.

Fazit

In diesem Artikel haben wir den Prozess zur Integration der ChatGPT-API in Java-Anwendungen erläutert. Durch das Erstellen einer Klasse namens ChatGPT und die Definition der Methode chatGPT konnten wir eine Verbindung zum ChatGPT-API-Endpunkt herstellen und Benutzeranfragen verarbeiten. Indem wir wichtige Parameter wie die API-Endpunkt-URL und den OpenAI-API-Schlüssel konfiguriert haben, konnten wir die Anfragen an die API senden und die erhaltenen Antworten verarbeiten. Dies ermöglicht es Entwicklern, die leistungsstarken Funktionen von ChatGPT in ihren Java-Anwendungen zu nutzen und menschenähnlichen Text zu generieren.