Setting Up Spring AI with OpenAI

<properties>
  <java.version>21</java.version>
  <!-- Pin an exact version. This ecosystem moves fast. -->
  <spring-ai.version>1.0.0</spring-ai.version>
</properties>
 
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.ai</groupId>
      <artifactId>spring-ai-bom</artifactId>
      <version>${spring-ai.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
 
<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-model-openai</artifactId>
  </dependency>
</dependencies>

dependencies {
    implementation(platform("org.springframework.ai:spring-ai-bom:1.0.0"))
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.ai:spring-ai-starter-model-openai")
}

export OPENAI_API_KEY="sk-proj-..."

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          # Start with a small, fast model. Move up only when quality demands it.
          model: gpt-4o-mini
          # 0.0-0.2 for extraction, classification, tool calling.
          # 0.7+ only when you genuinely want variety.
          temperature: 0.2
          # A hard ceiling on response length — and therefore on cost per call.
          max-tokens: 1000
      embedding:
        options:
          # Configured separately. Must match your vector store's dimensions.
          model: text-embedding-3-small
    retry:
      max-attempts: 3
      backoff:
        initial-interval: 2s
        multiplier: 2
        max-interval: 30s
      # 429 and 5xx are retried. 4xx client errors are not.
      on-client-errors: false
 
logging:
  level:
    # Uncomment while debugging to see the outgoing request bodies.
    # org.springframework.ai: DEBUG

app:
  ai:
    models:
      fast: gpt-4o-mini      # classification, routing, extraction
      strong: gpt-4o         # multi-step reasoning, code analysis

// Override per call — the application default stays untouched.
String analysis = chatClient.prompt()
        .user(complexQuestion)
        .options(ChatOptions.builder()
                .model(properties.models().strong())
                .temperature(0.1)
                .build())
        .call()
        .content();

package com.javaagentic.demo.chat;
 
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.stereotype.Service;
 
@Service
public class OpenAiChatService {
 
    private final ChatClient chatClient;
    private final MeterRegistry meterRegistry;
 
    public OpenAiChatService(ChatClient.Builder builder, MeterRegistry meterRegistry) {
        this.chatClient = builder
                .defaultSystem("You are a helpful assistant for Java developers.")
                .build();
        this.meterRegistry = meterRegistry;
    }
 
    public String ask(String question) {
        // chatResponse() rather than content() so the usage metadata is available.
        ChatResponse response = chatClient.prompt()
                .user(question)
                .call()
                .chatResponse();
 
        recordUsage(response);
        return response.getResult().getOutput().getText();
    }
 
    /**
     * Token usage is the only reliable early warning for a cost problem.
     * Recording it from the first day costs nothing and has saved many teams
     * an unpleasant conversation about the monthly bill.
     */
    private void recordUsage(ChatResponse response) {
        var usage = response.getMetadata().getUsage();
        if (usage == null) {
            return;
        }
        meterRegistry.counter("ai.tokens", "type", "prompt")
                .increment(usage.getPromptTokens());
        meterRegistry.counter("ai.tokens", "type", "completion")
                .increment(usage.getCompletionTokens());
    }
}

package com.javaagentic.demo.config;
 
import java.time.Duration;
 
import org.springframework.boot.web.client.RestClientCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
 
@Configuration
public class AiHttpConfig {
 
    /**
     * Without this, a stalled model call holds a request thread indefinitely.
     * Read timeout must exceed your slowest legitimate generation — long
     * completions on a large model can genuinely take 60 seconds.
     */
    @Bean
    RestClientCustomizer aiRestClientCustomizer() {
        return restClientBuilder -> {
            var factory = new SimpleClientHttpRequestFactory();
            factory.setConnectTimeout(Duration.ofSeconds(10));
            factory.setReadTimeout(Duration.ofSeconds(90));
            restClientBuilder.requestFactory(factory);
        };
    }
}

package com.javaagentic.demo;
 
import static org.assertj.core.api.Assertions.assertThat;
 
import com.javaagentic.demo.chat.OpenAiChatService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
 
@SpringBootTest
// Guarded so CI without a key does not fail. Real calls cost money — keep
// these few and mock the model in your ordinary unit tests.
@EnabledIfEnvironmentVariable(named = "OPENAI_API_KEY", matches = ".+")
class ChatSmokeTest {
 
    @Autowired
    OpenAiChatService chatService;
 
    @Test
    void answersASimpleQuestion() {
        String answer = chatService.ask("Reply with exactly the word: OK");
        assertThat(answer).containsIgnoringCase("OK");
    }
}