Java

api14 के साथ आधिकारिक openai-java लाइब्रेरी इस्तेमाल करें। क्लाइंट बिल्डर पर baseUrl सेट करें और मॉडल id (उदाहरण के लिए openai/gpt-5-mini) सामान्य स्ट्रिंग के रूप में पास करें।

इंस्टॉल करें

Gradle:

implementation("com.openai:openai-java:4.+")

Maven:

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

फिर अपने एनवायरनमेंट में API14_API_KEY=sk-api14-... सेट करें।

कॉन्फ़िगर करें

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

OpenAIClient client = OpenAIOkHttpClient.builder()
    .baseUrl("https://api14.com/api/v1")
    .apiKey(System.getenv("API14_API_KEY"))
    .build();

OpenAIOkHttpClient.fromEnv() इसके बजाय OPENAI_BASE_URL और OPENAI_API_KEY पढ़ता है, इसलिए आप कोड बदले बिना एनवायरनमेंट बदल सकते हैं:

export OPENAI_BASE_URL="https://api14.com/api/v1"
export OPENAI_API_KEY="sk-api14-..."

चैट

import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .model("openai/gpt-5-mini")
    .addUserMessage("Explain vector databases in two sentences.")
    .build();

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

स्ट्रीमिंग

import com.openai.core.http.StreamResponse;
import com.openai.models.chat.completions.ChatCompletionChunk;

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .model("anthropic/claude-sonnet-4.5")
    .addUserMessage("Write a haiku about APIs.")
    .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);
}

देखें स्ट्रीमिंग।

टूल कॉलिंग

टूल को एक क्लास के रूप में वर्णित करें; SDK उसका JSON Schema बनाता है और आर्गुमेंट को वापस उसी में पार्स करता है:

import com.fasterxml.jackson.annotation.JsonClassDescription;
import com.openai.models.chat.completions.*;
import java.util.Collection;

@JsonClassDescription("Current weather for a city")
static class GetWeather {
    public String city;
}

ChatCompletionCreateParams.Builder builder = ChatCompletionCreateParams.builder()
    .model("openai/gpt-5-mini")
    .addTool(GetWeather.class)
    .addUserMessage("What's the weather in Istanbul?");

while (true) {
    ChatCompletionMessage message = client.chat().completions().create(builder.build())
        .choices().get(0).message();
    builder.addMessage(message);
    if (message.toolCalls().map(Collection::isEmpty).orElse(true)) {
        message.content().ifPresent(System.out::println);
        break;
    }
    for (ChatCompletionMessageToolCall call : message.toolCalls().get()) {
        GetWeather args = call.asFunction().function().arguments(GetWeather.class);
        builder.addMessage(ChatCompletionToolMessageParam.builder()
            .toolCallId(call.asFunction().id())
            .contentAsJson(getWeather(args.city)) // आपका फ़ंक्शन
            .build());
    }
}

बिल्डर पूरी बातचीत रखता है: हर लूप टूल कॉल के साथ असिस्टेंट मैसेज जोड़ता है, फिर हर कॉल के लिए एक tool मैसेज, और सब कुछ दोबारा भेजता है। टूल क्लास के फ़ील्ड schema की properties बन जाते हैं; मॉडल को फ़ील्ड का अर्थ बताने के लिए उस पर @JsonPropertyDescription जोड़ें। प्रोडक्शन कोड में इटरेशन की संख्या सीमित करें ताकि बार-बार टूल कॉल करने वाला मॉडल अनंत लूप में न फँसे। देखें टूल कॉलिंग।

स्ट्रक्चर्ड आउटपुट

responseFormat को एक क्लास पास करें; SDK उससे strict JSON Schema बनाता है और हर choice की सामग्री को एक इंस्टेंस में पार्स करता है। ऐसा मॉडल इस्तेमाल करें जिसके supported_parameters में structured_outputs या response_format हो:

static class Person {
    public String name;
    public int born;
    public String city;
}

StructuredChatCompletionCreateParams<Person> params = ChatCompletionCreateParams.builder()
    .model("openai/gpt-5-mini")
    .responseFormat(Person.class)
    .addUserMessage("Extract: Ada Lovelace, born 1815 in London.")
    .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(person -> System.out.println(person.name + " " + person.born));

देखें स्ट्रक्चर्ड आउटपुट।

इमेज इनपुट

import java.util.List;

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .model("google/gemini-2.5-flash")
    .addUserMessageOfArrayOfContentParts(List.of(
        ChatCompletionContentPart.ofText(ChatCompletionContentPartText.builder()
            .text("What is in this picture?").build()),
        ChatCompletionContentPart.ofImageUrl(ChatCompletionContentPartImage.builder()
            .imageUrl(ChatCompletionContentPartImage.ImageUrl.builder()
                .url("https://example.com/photo.jpg") // या data:image/png;base64,... URL
                .build())
            .build())))
    .build();

देखें विज़न और फ़ाइलें।

अतिरिक्त पैरामीटर

जिन गेटवे फ़ील्ड के लिए टाइप्ड सेटर नहीं है (reasoning, provider, models) वे putAdditionalBodyProperty से जाते हैं:

import com.openai.core.JsonValue;
import java.util.Map;

ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
    .model("anthropic/claude-sonnet-4.5")
    .addUserMessage("Prove there are infinitely many primes.")
    .putAdditionalBodyProperty("reasoning", JsonValue.from(Map.of("effort", "high")))
    .build();

त्रुटियाँ

गैर-2xx प्रतिक्रियाएँ OpenAIServiceException की उपक्लास throw करती हैं, जो स्टेटस और हेडर उपलब्ध कराती हैं:

import com.openai.errors.OpenAIServiceException;

try {
    client.chat().completions().create(params);
} catch (OpenAIServiceException e) {
    if (e.statusCode() == 402) {
        System.err.println("Balance too low, add funds (insufficient_balance)");
    } else if (e.statusCode() == 429) {
        System.err.println("Rate limited, retry after " + e.headers().values("Retry-After") + "s");
    } else {
        throw e;
    }
}

देखें त्रुटियाँ।

टाइमआउट और रीट्राई

क्लाइंट कनेक्शन त्रुटियों, 408, 409, 429 और 5xx को डिफ़ॉल्ट रूप से दो बार exponential backoff के साथ दोबारा आज़माता है। संख्या और टाइमआउट बिल्डर पर, या प्रति अनुरोध कॉन्फ़िगर करें:

import com.openai.core.RequestOptions;
import java.time.Duration;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .baseUrl("https://api14.com/api/v1")
    .apiKey(System.getenv("API14_API_KEY"))
    .maxRetries(4)
    .timeout(Duration.ofSeconds(60))
    .build();

client.chat().completions().create(params,
    RequestOptions.builder().timeout(Duration.ofMinutes(5)).build());

बिल्डर का टाइमआउट हर प्रयास पर लागू होता है। लंबे रीज़निंग अनुरोधों में मिनट लग सकते हैं, इसलिए उन्हें प्रति अनुरोध लंबा टाइमआउट दें या स्ट्रीम करें। daily_limit_reached या insufficient_balance में रीट्राई से मदद नहीं मिलती; अगला प्रयास शेड्यूल करने से पहले RateLimitException पकड़ें और त्रुटि कोड जाँचें। देखें रेट लिमिट।

सभी क्षमताएँ

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api14.com/api/v1",
  apiKey: process.env.API14_API_KEY,
});

const result = await client.chat.completions.create({
  "model": "openai/gpt-5-mini",
  "messages": [
    {
      "role": "user",
      "content": "Explain vector databases in two sentences."
    }
  ]
});
console.log(result.choices[0].message.content);