Spring AI Milestone: The Future of Intelligent Java Applications

Introduction

Section 1: Core Concepts and the Portable AI API

The ChatClient Fluent API

package com.example.ai.controller;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AIController {

    private final ChatClient chatClient;

    // Spring AI auto-configures the builder based on application.properties
    public AIController(ChatClient.Builder builder) {
        this.chatClient = builder
                .defaultSystem("You are a helpful assistant specializing in Java ecosystem news.")
                .build();
    }

    @GetMapping("/ask")
    public String askQuestion(@RequestParam String query) {
        // The fluent API allows for easy parameter injection and execution
        return chatClient.prompt()
                .user(query)
                .call()
                .content();
    }
}

Section 2: Implementing Retrieval Augmented Generation (RAG)

Ingesting Data into a Vector Store

package com.example.ai.service;

import org.springframework.ai.document.Document;
import org.springframework.ai.reader.JsonReader;
import org.springframework.ai.transformer.splitter.TokenTextSplitter;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Value;

import java.util.List;

@Service
public class IngestionService {

    private final VectorStore vectorStore;

    @Value("classpath:java-news-data.json")
    private Resource newsResource;

    public IngestionService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    public void ingestData() {
        // 1. Read Data
        JsonReader jsonReader = new JsonReader(newsResource, "content");
        List documents = jsonReader.get();

        // 2. Transform (Split) Data
        // Splitting is crucial to fit within token limits of embedding models
        TokenTextSplitter splitter = new TokenTextSplitter();
        List splitDocuments = splitter.apply(documents);

        // 3. Load into Vector Store
        // This automatically calls the EmbeddingModel to convert text to vectors
        vectorStore.add(splitDocuments);
        
        System.out.println("Ingested " + splitDocuments.size() + " document chunks.");
    }
}

Section 3: Advanced Techniques: Function Calling and Agents

Integrating Tools with Spring Beans

package com.example.ai.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Description;

import java.util.function.Function;

@Configuration
public class ToolsConfiguration {

    // Request Record
    public record WeatherRequest(String city, String unit) {}
    // Response Record
    public record WeatherResponse(String city, double temperature, String unit) {}

    @Bean
    @Description("Get the current weather for a specific city. Unit can be C or F.")
    public Function currentWeather() {
        return request -> {
            // In a real app, this would call a weather API
            // Simulating logic for demonstration
            double temp = request.unit().equalsIgnoreCase("F") ? 72.0 : 22.0;
            return new WeatherResponse(request.city(), temp, request.unit());
        };
    }
}

    @GetMapping("/weather-chat")
    public String weatherChat(@RequestParam String message) {
        return chatClient.prompt()
                .user(message)
                .functions("currentWeather") // Reference the bean name
                .call()
                .content();
    }

Section 4: Best Practices, Observability, and Optimization

Structured Output and Type Safety

package com.example.ai.model;

import org.springframework.ai.converter.BeanOutputConverter;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class MovieController {

    private final ChatClient chatClient;

    public MovieController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    record MovieRecommendation(String title, int year, String reason) {}

    @GetMapping("/recommend")
    public List getRecommendations() {
        // Create a converter for a List of our record
        var converter = new BeanOutputConverter<>(new ParameterizedTypeReference>() {});

        String response = chatClient.prompt()
                .user("Recommend 3 sci-fi movies from the 90s.")
                .format(converter) // Appends schema instructions to the prompt
                .call()
                .content();

        // Automatically parses JSON to Java Objects
        return converter.convert(response);
    }
}

Observability and Performance

Conclusion