Java SDK

Use the official OpenAI Java SDK with GonkaGate. Works with Java 8+ and all major build tools.

Official SDK

We recommend using the official OpenAI Java SDK, which provides full API compatibility.

Installation

Add the SDK to your project:

Gradle (Kotlin DSL)

build.gradle.kts

implementation("com.openai:openai-java:4.7.1")

Maven

pom.xml

<dependency>
    <groupId>com.openai</groupId>
    <artifactId>openai-java</artifactId>
    <version>4.7.1</version>
</dependency>

Configuration

Configure the client to use GonkaGate's API endpoint:

Config.java

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .apiKey("gp-your-api-key")
    .baseUrl("https://api.gonkagate.com/v1")
    .build();

Basic Usage

Make your first chat completion request:

BasicUsage.java

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.ChatModel;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public class BasicUsage {
    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.builder()
            .apiKey("gp-your-api-key")
            .baseUrl("https://api.gonkagate.com/v1")
            .build();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .addSystemMessage("You are a helpful assistant.")
            .addUserMessage("Hello, how are you?")
            .model("Qwen/Qwen3-235B-A22B-Instruct-2507-FP8")
            .temperature(0.7)
            .maxTokens(1000)
            .build();

        ChatCompletion completion = client.chat().completions().create(params);

        System.out.println(completion.choices().get(0).message().content());
    }
}

Streaming

Stream responses for real-time output:

Streaming.java

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.StreamResponse;
import com.openai.models.chat.completions.ChatCompletionChunk;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public class Streaming {
    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.builder()
            .apiKey("gp-your-api-key")
            .baseUrl("https://api.gonkagate.com/v1")
            .build();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .addUserMessage("Write a poem about AI")
            .model("Qwen/Qwen3-235B-A22B-Instruct-2507-FP8")
            .build();

        try (StreamResponse<ChatCompletionChunk> stream =
                client.chat().completions().createStreaming(params)) {

            stream.stream()
                .flatMap(chunk -> chunk.choices().stream())
                .flatMap(choice -> choice.delta().content().stream())
                .forEach(System.out::print);
        }

        System.out.println("\nStream finished");
    }
}

Error Handling

Handle common API errors gracefully:

ErrorHandling.java

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.errors.OpenAIException;
import com.openai.errors.RateLimitException;
import com.openai.errors.UnauthorizedException;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public class ErrorHandling {
    public static void main(String[] args) {
        OpenAIClient client = OpenAIOkHttpClient.builder()
            .apiKey("gp-your-api-key")
            .baseUrl("https://api.gonkagate.com/v1")
            .build();

        try {
            ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
                .addUserMessage("Hello!")
                .model("Qwen/Qwen3-235B-A22B-Instruct-2507-FP8")
                .build();

            ChatCompletion completion = client.chat().completions().create(params);
            System.out.println(completion.choices().get(0).message().content());

        } catch (UnauthorizedException e) {
            System.err.println("Invalid API key: " + e.getMessage());
        } catch (RateLimitException e) {
            System.err.println("Rate limited. Please retry after some time.");
        } catch (OpenAIException e) {
            if (e.statusCode() == 402) {
                System.err.println("Insufficient balance. Please add funds.");
            } else {
                System.err.println("API error: " + e.getMessage());
            }
        }
    }
}

Async Usage

Use CompletableFuture for non-blocking requests:

AsyncUsage.java

import com.openai.client.OpenAIClientAsync;
import com.openai.client.okhttp.OpenAIOkHttpClientAsync;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import java.util.concurrent.CompletableFuture;

public class AsyncUsage {
    public static void main(String[] args) {
        OpenAIClientAsync client = OpenAIOkHttpClientAsync.builder()
            .apiKey("gp-your-api-key")
            .baseUrl("https://api.gonkagate.com/v1")
            .build();

        ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
            .addUserMessage("Hello!")
            .model("Qwen/Qwen3-235B-A22B-Instruct-2507-FP8")
            .build();

        CompletableFuture<ChatCompletion> future =
            client.chat().completions().create(params);

        future.thenAccept(completion -> {
            System.out.println(completion.choices().get(0).message().content());
        }).exceptionally(e -> {
            System.err.println("Error: " + e.getMessage());
            return null;
        }).join();
    }
}