Как использовать OpenAI API в Java

<dependency>
    <groupId>com.openai</groupId>
    <artifactId>openai</artifactId>
    <version>latest_version</version>
</dependency>

// Инициализация клиента
OpenAIClient client = OpenAI.builder()
    .apiKey("your-api-key-here")
    .build();
 
// Простой запрос к модели
ChatMessage userMsg = ChatMessage.userMessage("Привет, GPT!");
ChatCompletionRequest request = ChatCompletionRequest.builder()
    .model("gpt-3.5-turbo")
    .messages(List.of(userMsg))
    .build();
 
ChatCompletionResponse response = client.createChatCompletion(request);
System.out.println(response.getChoices().get(0).getMessage().getContent());

OPENAI_API_KEY=sk-ваш-ключ-здесь

String apiKey = System.getenv("OPENAI_API_KEY");
if (apiKey == null || apiKey.isEmpty()) {
    throw new IllegalStateException("API ключ не найден. Проверьте переменную окружения OPENAI_API_KEY");
}

Dotenv dotenv = Dotenv.configure().load();
String apiKey = dotenv.get("OPENAI_API_KEY");

public class OpenAiService {
    private static final Logger LOG = LoggerFactory.getLogger(OpenAiService.class);
    private final OpenAIClient client;
    
    public OpenAiService(String apiKey) {
        LOG.info("Инициализация сервиса OpenAI");
        this.client = OpenAI.builder()
            .apiKey(apiKey)
            .connectTimeout(Duration.ofSeconds(30))
            .readTimeout(Duration.ofMinutes(2))
            .build();
    }
    
    // Методы для работы с API будут здесь
}

public class OpenAiTest {
    public static void main(String[] args) {
        String apiKey = System.getenv("OPENAI_API_KEY");
        if (apiKey == null) {
            System.err.println("API ключ не найден! Установите переменную OPENAI_API_KEY");
            return;
        }
        
        OpenAIClient client = OpenAI.builder()
            .apiKey(apiKey)
            .build();
            
        ChatMessage message = ChatMessage.userMessage("Напиши 'Привет, мир!' на Java");
        ChatCompletionRequest request = ChatCompletionRequest.builder()
            .model("gpt-3.5-turbo")
            .messages(List.of(message))
            .build();
            
        try {
            ChatCompletionResponse response = client.createChatCompletion(request);
            System.out.println(response.getChoices().get(0).getMessage().getContent());
        } catch (Exception e) {
            System.err.println("Ошибка при обращении к API: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Proxy proxy = new Proxy(Proxy.Type.HTTP, 
    new InetSocketAddress("your-proxy.company.com", 8080));
 
OpenAIClient client = OpenAI.builder()
    .apiKey(apiKey)
    .proxy(proxy)
    .build();

// Добавляем зависимость в pom.xml
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>0.7.0</version>
</dependency>

@Configuration
public class OpenAiConfig {
    @Bean
    public OpenAiApi openAiApi(@Value("${openai.api-key}") String apiKey) {
        return new OpenAiApi(apiKey);
    }
}

@Service
public class AiCompletionService {
    private final OpenAiChatClient chatClient;
    
    public AiCompletionService(OpenAiChatClient chatClient) {
        this.chatClient = chatClient;
    }
    
    public String generateText(String prompt) {
        UserMessage userMessage = new UserMessage(prompt);
        ChatResponse response = chatClient.call(
            new Prompt(List.of(userMessage), new ChatOptions())
        );
        return response.getResult().getOutput().getContent();
    }
}

public class CustomOpenAiClient {
    private static final String API_URL = "https://api.openai.com/v1/chat/completions";
    private final String apiKey;
    private final HttpClient httpClient;
    private final ObjectMapper objectMapper;
    
    public CustomOpenAiClient(String apiKey) {
        this.apiKey = apiKey;
        this.httpClient = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        this.objectMapper = new ObjectMapper();
    }
    
    public String generateCompletion(String prompt) throws Exception {
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("model", "gpt-3.5-turbo");
        
        List<Map<String, String>> messages = new ArrayList<>();
        Map<String, String> message = new HashMap<>();
        message.put("role", "user");
        message.put("content", prompt);
        messages.add(message);
        
        requestBody.put("messages", messages);
        
        String requestBodyJson = objectMapper.writeValueAsString(requestBody);
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(API_URL))
            .header("Authorization", "Bearer " + apiKey)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(requestBodyJson))
            .build();
        
        HttpResponse<String> response = httpClient.send(request, 
            HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() != 200) {
            throw new RuntimeException("API вернул код: " + response.statusCode() 
                + ", тело: " + response.body());
        }
        
        JsonNode rootNode = objectMapper.readTree(response.body());
        return rootNode.path("choices").get(0).path("message").path("content").asText();
    }
}

OkHttpClient client = new OkHttpClient.Builder()
    .connectTimeout(30, TimeUnit.SECONDS)
    .readTimeout(60, TimeUnit.SECONDS)
    .addInterceptor(chain -> {
        Request originalRequest = chain.request();
        Request requestWithAuth = originalRequest.newBuilder()
            .header("Authorization", "Bearer " + apiKey)
            .build();
        return chain.proceed(requestWithAuth);
    })
    .build();

@Service
public class SpringOpenAiClient {
    private final RestTemplate restTemplate;
    private final String apiKey;
    
    // ... конструктор и настройка ...
    
    public String chat(String prompt) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + apiKey);
        headers.setContentType(MediaType.APPLICATION_JSON);
        
        Map<String, Object> requestMap = createRequestBody(prompt);
        HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestMap, headers);
        
        ResponseEntity<Map> response = restTemplate.exchange(
            "https://api.openai.com/v1/chat/completions",
            HttpMethod.POST,
            entity,
            Map.class
        );
        
        // Извлечение результата из вложенных map'ов
        Map<String, Object> body = response.getBody();
        List<Map<String, Object>> choices = (List<Map<String, Object>>) body.get("choices");
        Map<String, Object> message = (Map<String, Object>) choices.get(0).get("message");
        return (String) message.get("content");
    }
}

public class SimpleChatExample {
    public static void main(String[] args) {
        // Инициализация клиента
        OpenAIClient client = OpenAI.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .build();
 
        // Создание сообщения пользователя
        ChatMessage userMessage = ChatMessage.userMessage("Как реализовать бинарный поиск на Java?");
 
        // Формирование запроса
        ChatCompletionRequest request = ChatCompletionRequest.builder()
            .model("gpt-3.5-turbo")
            .messages(List.of(userMessage))
            .build();
 
        // Отправка запроса и получение ответа
        try {
            ChatCompletionResponse response = client.createChatCompletion(request);
            String assistantResponse = response.getChoices().get(0).getMessage().getContent();
            System.out.println("Ответ ассистента: " + assistantResponse);
        } catch (Exception e) {
            System.err.println("Произошла ошибка: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

OpenAIClient client = OpenAI.builder()
    .apiKey(apiKey)
    .connectTimeout(Duration.ofSeconds(30))
    .readTimeout(Duration.ofMinutes(2))
    .build();

// Пример с ручной реализацией ретраев
public String sendWithRetries(String prompt, int maxRetries) {
    int retryCount = 0;
    Exception lastException = null;
    
    while (retryCount < maxRetries) {
        try {
            ChatMessage userMessage = ChatMessage.userMessage(prompt);
            ChatCompletionRequest request = ChatCompletionRequest.builder()
                .model("gpt-3.5-turbo")
                .messages(List.of(userMessage))
                .build();
                
            ChatCompletionResponse response = client.createChatCompletion(request);
            return response.getChoices().get(0).getMessage().getContent();
        } catch (Exception e) {
            lastException = e;
            
            // Проверяем, стоит ли повторять запрос
            if (isRetryableError(e)) {
                retryCount++;
                // Экспоненциальная задержка перед повторной попыткой
                try {
                    Thread.sleep((long) Math.pow(2, retryCount) * 100);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("Прерывание во время ожидания ретрая", ie);
                }
            } else {
                // Если ошибка не предполагает ретрай, сразу выбрасываем исключение
                throw new RuntimeException("Неретраяблная ошибка при запросе к API", e);
            }
        }
    }
    
    throw new RuntimeException("Исчерпаны все попытки запроса к API", lastException);
}
 
private boolean isRetryableError(Exception e) {
    // Временные ошибки сети или сервера обычно предполагают ретрай
    return e.getMessage().contains("timeout") || 
           e.getMessage().contains("rate limit") ||
           e.getMessage().contains("500") ||
           e.getMessage().contains("503");
}

// Сохраняем историю сообщений
List<ChatMessage> conversationHistory = new ArrayList<>();
 
// Добавляем первое сообщение пользователя
conversationHistory.add(ChatMessage.userMessage("Что такое бинарное дерево?"));
 
// Отправляем запрос с первым сообщением
ChatCompletionRequest firstRequest = ChatCompletionRequest.builder()
    .model("gpt-3.5-turbo")
    .messages(conversationHistory)
    .build();
ChatCompletionResponse firstResponse = client.createChatCompletion(firstRequest);
 
// Получаем ответ ассистента и добавляем его в историю
String assistantResponseText = firstResponse.getChoices().get(0).getMessage().getContent();
conversationHistory.add(ChatMessage.assistantMessage(assistantResponseText));
 
// Задаем следующий вопрос и добавляем его в историю
conversationHistory.add(ChatMessage.userMessage("А как реализовать его обход?"));
 
// Отправляем новый запрос со всей историей
ChatCompletionRequest secondRequest = ChatCompletionRequest.builder()
    .model("gpt-3.5-turbo")
    .messages(conversationHistory)
    .build();

List<ChatMessage> messages = new ArrayList<>();
messages.add(ChatMessage.systemMessage("Ты опытный Java-разработчик. Отвечай кратко, с примерами кода."));
messages.add(ChatMessage.userMessage("Как использовать Stream API для фильтрации списка?"));
 
ChatCompletionRequest request = ChatCompletionRequest.builder()
    .model("gpt-3.5-turbo")
    .messages(messages)
    .build();

ChatCompletionRequest request = ChatCompletionRequest.builder()
    .model("gpt-4")                    // Модель, которую используем
    .messages(messagesList)            // Список сообщений диалога
    .temperature(0.7)                  // Температура (креативность)
    .topP(1.0)                         // Сэмплинг по вероятности
    .n(1)                              // Количество генерируемых вариантов
    .stream(false)                     // Потоковая передача ответа
    .stop(Arrays.asList("###"))        // Маркеры для остановки генерации
    .maxTokens(500)                    // Максимальная длина ответа
    .presencePenalty(0.0)              // Штраф за повторение тем
    .frequencyPenalty(0.0)             // Штраф за повторение слов
    .user("user-12345")                // Идентификатор пользователя
    .build();

List<ChatMessage> messages = new ArrayList<>();
// Системное сообщение - задаёт общий контекст и инструкции
messages.add(ChatMessage.systemMessage("Ты Java-программист с 10-летним опытом"));
// Сообщение пользователя - запрос от пользователя
messages.add(ChatMessage.userMessage("Как лучше организовать многопоточность в приложении?"));
// Сообщение ассистента - предыдущие ответы модели
messages.add(ChatMessage.assistantMessage("Для многопоточности в Java есть несколько подходов..."));

ChatCompletionResponse response = client.createChatCompletion(request);
 
// Получение текста ответа
String content = response.getChoices().get(0).getMessage().getContent();
 
// Статистика использования токенов
int promptTokens = response.getUsage().getPromptTokens();
int completionTokens = response.getUsage().getCompletionTokens();
int totalTokens = response.getUsage().getTotalTokens();
 
// Получение ID запроса для отладки или логирования
String requestId = response.getId();
 
// Метаданные о модели
String model = response.getModel();
 
// Причина завершения генерации
String finishReason = response.getChoices().get(0).getFinishReason();

ChatCompletionRequest request = ChatCompletionRequest.builder()
    .model("gpt-3.5-turbo")
    .messages(messages)
    .n(3)  // Запрашиваем 3 разных варианта ответа
    .build();
 
ChatCompletionResponse response = client.createChatCompletion(request);
 
// Обработка всех вариантов
for (int i = 0; i < response.getChoices().size(); i++) {
    System.out.println("Вариант " + (i+1) + ": " + 
        response.getChoices().get(i).getMessage().getContent());
}

try {
    ChatCompletionResponse response = client.createChatCompletion(request);
    // Обработка успешного ответа
} catch (OpenAIHttpException e) {
    if (e.statusCode == 429) {
        // Превышен лимит запросов, нужно подождать
        System.err.println("Rate limit exceeded. Retry after: " + 
            e.getResponse().headers().get("Retry-After"));
    } else if (e.statusCode == 400) {
        // Некорректный запрос
        System.err.println("Bad request: " + e.getMessage());
    } else if (e.statusCode == 401) {
        // Проблемы с аутентификацией
        System.err.println("Authentication error. Check your API key.");
    } else {
        // Другие ошибки
        System.err.println("Error: " + e.getMessage());
    }
}

// Простой способ примерно оценить количество токенов
// (очень приблизительно, но для базовой оценки подойдет)
public int estimateTokens(String text) {
    // В среднем 1 токен ≈ 4 символа для английского текста
    // и 1 токен ≈ 2-3 символа для русского
    return text.length() / 3;
}
 
// Оценка стоимости запроса перед отправкой
public double estimateCost(List<ChatMessage> messages, String model) {
    int totalTokens = 0;
    for (ChatMessage msg : messages) {
        totalTokens += estimateTokens(msg.getContent());
    }
    
    // Примерная стоимость (цены меняются, это для примера)
    double costPer1KTokens = model.equals("gpt-4") ? 0.03 : 0.002;
    return totalTokens * costPer1KTokens / 1000;
}

// Использование GPT-3.5 Turbo
ChatCompletionRequest request35 = ChatCompletionRequest.builder()
    .model("gpt-3.5-turbo")
    .messages(messagesList)
    .build();
 
// Использование GPT-4
ChatCompletionRequest request4 = ChatCompletionRequest.builder()
    .model("gpt-4")
    .messages(messagesList)
    .build();

public class AdaptiveModelService {
    private final OpenAIClient client;
    
    // Пороговое значение сложности запроса
    private static final double COMPLEXITY_THRESHOLD = 0.7;
    
    public AdaptiveModelService(OpenAIClient client) {
        this.client = client;
    }
    
    public String processQuery(String userQuery) {
        // Оцениваем сложность запроса
        double complexity = estimateQueryComplexity(userQuery);
        
        // Выбираем модель в зависимости от сложности
        String model = complexity > COMPLEXITY_THRESHOLD ? "gpt-4" : "gpt-3.5-turbo";
        
        ChatMessage userMessage = ChatMessage.userMessage(userQuery);
        ChatCompletionRequest request = ChatCompletionRequest.builder()
            .model(model)
            .messages(List.of(userMessage))
            .build();
            
        ChatCompletionResponse response = client.createChatCompletion(request);
        return response.getChoices().get(0).getMessage().getContent();
    }
    
    // Простая эвристика для оценки сложности запроса
    private double estimateQueryComplexity(String query) {
        // Упрощенный алгоритм, на практике нужно что-то более сложное
        int medicalTermsCount = countMedicalTerms(query);
        int totalWords = query.split("\\s+").length;
        
        return Math.min(1.0, (double) medicalTermsCount / totalWords * 2);
    }
    
    // Подсчет медицинских терминов в запросе
    private int countMedicalTerms(String text) {
        // В реальности здесь был бы словарь медицинских терминов
        String[] medicalTerms = {"диагноз", "симптом", "лечение", "препарат", "дозировка"};
        int count = 0;
        
        for (String term : medicalTerms) {
            if (text.toLowerCase().contains(term)) {
                count++;
            }
        }
        
        return count;
    }
}

// Пример работы с моделью для эмбеддингов
public List<Double> getEmbeddings(String text) {
    EmbeddingRequest request = EmbeddingRequest.builder()
        .model("text-embedding-ada-002")
        .input(text)
        .build();
        
    EmbeddingResponse response = client.createEmbedding(request);
    return response.getData().get(0).getEmbedding();
}

ChatCompletionRequest request = ChatCompletionRequest.builder()
    .model("gpt-3.5-turbo")
    .messages(messages)
    .temperature(0.2)  // Низкая температура для точных ответов
    .build();

public class CreativeResponseGenerator {
    private final OpenAIClient client;
    
    public String generateCreativeResponse(String prompt, boolean needsCreativity) {
        double temperature = needsCreativity ? 1.2 : 0.3;
        double topP = needsCreativity ? 0.9 : 1.0;
        
        ChatCompletionRequest request = ChatCompletionRequest.builder()
            .model("gpt-3.5-turbo")
            .messages(List.of(ChatMessage.userMessage(prompt)))
            .temperature(temperature)
            .topP(topP)
            .maxTokens(500)
            .presencePenalty(needsCreativity ? 0.6 : 0.0)
            .frequencyPenalty(needsCreativity ? 0.7 : 0.0)
            .build();
            
        ChatCompletionResponse response = client.createChatCompletion(request);
        return response.getChoices().get(0).getMessage().getContent();
    }
}

public class DiverseContentGenerator {
    private final OpenAIClient client;
    
    public String generateExplanation(String topic, int complexity) {
        // Увеличиваем штрафы для более сложных объяснений
        double presencePenalty = Math.min(0.8, 0.2 + (complexity * 0.1));
        double frequencyPenalty = Math.min(0.9, 0.3 + (complexity * 0.1));
        
        ChatCompletionRequest request = ChatCompletionRequest.builder()
            .model("gpt-4")
            .messages(createMessageList(topic, complexity))
            .presencePenalty(presencePenalty)
            .frequencyPenalty(frequencyPenalty)
            .build();
            
        return client.createChatCompletion(request)
            .getChoices().get(0).getMessage().getContent();
    }
    
    private List<ChatMessage> createMessageList(String topic, int complexity) {
        List<ChatMessage> messages = new ArrayList<>();
        messages.add(ChatMessage.systemMessage(
            String.format("Объясни тему '%s' на уровне сложности %d/10", 
                topic, complexity)
        ));
        return messages;
    }
}

public class TokenCalculator {
    // Примерное количество токенов на одно слово
    private static final double TOKENS_PER_WORD = 1.3;
    // Запас для безопасности
    private static final double SAFETY_MARGIN = 1.2;
    
    public int calculateMaxTokens(String prompt, int expectedResponseLength) {
        // Оценка токенов в промпте
        int promptTokens = (int)(prompt.split("\\s+").length * TOKENS_PER_WORD);
        // Оценка необходимых токенов для ответа
        int responseTokens = (int)(expectedResponseLength * TOKENS_PER_WORD);
        // Добавляем запас и округляем до сотен
        return (int)((responseTokens * SAFETY_MARGIN) / 100) * 100;
    }
}

public class AdvancedCompletionService {
    private final OpenAIClient client;
    private final TokenCalculator tokenCalculator;
    
    public String generateResponse(CompletionRequest req) {
        ChatCompletionRequest.Builder builder = ChatCompletionRequest.builder()
            .model(selectModel(req.complexity))
            .messages(req.messages)
            .maxTokens(tokenCalculator.calculateMaxTokens(
                req.prompt, req.expectedLength))
            .temperature(calculateTemperature(req.creativity))
            .presencePenalty(calculatePresencePenalty(req.diversity))
            .frequencyPenalty(calculateFrequencyPenalty(req.diversity));
            
        if (req.stream) {
            builder.stream(true);
        }
        
        return client.createChatCompletion(builder.build())
            .getChoices().get(0).getMessage().getContent();
    }
    
    private String selectModel(int complexity) {
        return complexity > 7 ? "gpt-4" : "gpt-3.5-turbo";
    }
    
    private double calculateTemperature(double creativity) {
        return Math.min(2.0, 0.3 + (creativity * 0.17));
    }
    
    private double calculatePresencePenalty(double diversity) {
        return Math.min(2.0, diversity * 0.2);
    }
    
    private double calculateFrequencyPenalty(double diversity) {
        return Math.min(2.0, diversity * 0.2);
    }
}
 
public class CompletionRequest {
    public List<ChatMessage> messages;
    public String prompt;
    public int expectedLength;
    public int complexity;
    public double creativity;
    public double diversity;
    public boolean stream;
}

public class StructuredResponseGenerator {
    private final OpenAIClient client;
    
    public String generateSingleParagraph(String prompt) {
        ChatCompletionRequest request = ChatCompletionRequest.builder()
            .model("gpt-3.5-turbo")
            .messages(List.of(ChatMessage.userMessage(prompt)))
            .stop(Arrays.asList("\n\n", "###"))  // Останавливаем на двойном переносе строки
            .maxTokens(150)
            .build();
            
        return client.createChatCompletion(request)
            .getChoices().get(0).getMessage().getContent();
    }
}

public class ConfidenceAnalyzer {
    private static final double CONFIDENCE_THRESHOLD = 0.8;
    
    public boolean isResponseConfident(CompletionResponse response) {
        List<Double> probabilities = response.getLogprobs().getTokenLogprobs();
        double averageConfidence = probabilities.stream()
            .mapToDouble(Math::exp)  // Преобразуем log prob в вероятность
            .average()
            .orElse(0.0);
            
        return averageConfidence > CONFIDENCE_THRESHOLD;
    }
}

public class CompletionMetricsCollector {
    private final MetricsRegistry registry;
    
    public void recordCompletion(ChatCompletionRequest request, ChatCompletionResponse response) {
        // Записываем базовые метрики
        registry.recordTokenUsage(
            "completion_tokens", 
            response.getUsage().getCompletionTokens()
        );
        
        // Анализируем эффективность настроек
        registry.recordGauge(
            "temperature", 
            request.getTemperature()
        );
        
        // Считаем стоимость запроса
        double cost = calculateCost(
            request.getModel(), 
            response.getUsage().getTotalTokens()
        );
        registry.recordCost("api_cost", cost);
    }
    
    private double calculateCost(String model, int tokens) {
        // Актуальные цены можно хранить в конфигурации
        Map<String, Double> costPerToken = Map.of(
            "gpt-4", 0.03 / 1000.0,
            "gpt-3.5-turbo", 0.002 / 1000.0
        );
        
        return tokens * costPerToken.getOrDefault(model, 0.0);
    }
}

public class CompletionPresets {
    public static ChatCompletionRequest.Builder getCreativeWritingPreset() {
        return ChatCompletionRequest.builder()
            .temperature(1.1)
            .topP(0.9)
            .presencePenalty(0.6)
            .frequencyPenalty(0.7);
    }
    
    public static ChatCompletionRequest.Builder getCodeGenerationPreset() {
        return ChatCompletionRequest.builder()
            .temperature(0.2)
            .topP(1.0)
            .presencePenalty(0.0)
            .frequencyPenalty(0.0);
    }
    
    public static ChatCompletionRequest.Builder getTechnicalWritingPreset() {
        return ChatCompletionRequest.builder()
            .temperature(0.4)
            .topP(0.95)
            .presencePenalty(0.1)
            .frequencyPenalty(0.1);
    }
}