Spring AI Masterclass

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-bom</artifactId>
            <version>1.0.0-SNAPSHOT</version> <!-- Check for latest version -->
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Starter for OpenAI -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    </dependency>
    <!-- For Vector Stores (Example) -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-pgvector-store-spring-boot-starter</artifactId>
    </dependency>
</dependencies>

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4o
          temperature: 0.7 # 0.0 for deterministic, 1.0 for creative

@Service
public class AIService {

    private final ChatClient chatClient;

    public AIService(ChatClient.Builder builder) {
        // Initialize with a default system persona
        // This sets the "System Message" which guides the AI's behavior
        this.chatClient = builder
                .defaultSystem("You are a helpful and witty coding assistant named 'Jules'. You prefer clean code.")
                .build();
    }

    public String generateResponse(String concept, String skillLevel) {
        // Using PromptTemplate for dynamic variable substitution
        String templateString = """
                Explain the concept of {concept} to a developer with {skillLevel} experience.
                Include a code example in Java.
                """;

        PromptTemplate promptTemplate = new PromptTemplate(templateString);
        Prompt prompt = promptTemplate.create(Map.of(
                "concept", concept,
                "skillLevel", skillLevel
        ));

        // The call() method blocks until the full response is received.
        return chatClient.prompt(prompt)
                .call()
                .content();
    }
}

@Service
public class RAGService {

    private final VectorStore vectorStore;
    private final ChatClient chatClient;

    public RAGService(VectorStore vectorStore, ChatClient.Builder builder) {
        this.vectorStore = vectorStore;
        this.chatClient = builder.build();
    }

    // 1. Ingestion Process (Run via a job or admin API)
    public void ingestDocuments(Resource pdfResource) {
        // Tika is a library that can read PDF, Word, HTML, etc.
        TikaDocumentReader reader = new TikaDocumentReader(pdfResource);
        List<Document> documents = reader.get();

        // Split into chunks. Overlap ensures context isn't lost at boundaries.
        TokenTextSplitter splitter = new TokenTextSplitter(1000, 400, 10, 5000, true);
        List<Document> chunks = splitter.apply(documents);

        // This call automatically computes embeddings and saves to DB
        vectorStore.add(chunks);
    }

    // 2. Retrieval & Generation
    public String askWithContext(String query) {
        // Retrieve top 3 most similar documents
        // 'SearchRequest' allows filtering by metadata (e.g., only docs from 2024)
        List<Document> similarDocs = vectorStore.similaritySearch(
                SearchRequest.query(query).withTopK(3)
        );

        // Combine the content of the found documents
        String context = similarDocs.stream()
                .map(Document::getContent)
                .collect(Collectors.joining("\n"));

        // Prompt Engineering: Instruct the AI to ONLY use the provided context
        String systemPrompt = """
                You are a helpful documentation assistant.
                You must answer the user's question strictly using the provided context.
                If the answer is not in the context, simply say 'I don't know'.
                Do not make up facts.

                CONTEXT:
                {context}
                """;

        return chatClient.prompt()
                .system(s -> s.text(systemPrompt).param("context", context))
                .user(query)
                .call()
                .content();
    }
}

// Define your type-safe data structure
public record MovieRecommendation(
    String title,
    int year,
    String reason,
    List<String> cast
) {}

@RestController
@RequestMapping("/movies")
public class MovieController {

    private final ChatClient chatClient;

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

    @GetMapping("/recommend")
    public MovieRecommendation getRecommendation(@RequestParam String genre) {
        // Create the parser for our specific record class
        var outputParser = new BeanOutputParser<>(MovieRecommendation.class);

        String userPrompt = """
                Recommend a classic {genre} movie from the 90s.
                {format_instructions}
                """;

        PromptTemplate template = new PromptTemplate(userPrompt);
        Prompt prompt = template.create(Map.of(
                "genre", genre,
                // Automatically injects the JSON schema instructions
                "format_instructions", outputParser.getFormat()
        ));

        ChatResponse response = chatClient.prompt(prompt).call();

        // Parse result directly to Java object
        return outputParser.parse(response.getResult().getOutput().getContent());
    }
}

@Service
public class VisionService {

    private final ChatClient chatClient;

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

    public String analyzeImage(MultipartFile file) throws IOException {
        // Convert the uploaded file to a Spring Resource
        Resource imageResource = new ByteArrayResource(file.getBytes());

        // Define the user message with both text and media
        UserMessage userMessage = new UserMessage(
                "Analyze this image and list all food ingredients visible along with their estimated calorie count.",
                List.of(new Media(MimeTypeUtils.IMAGE_JPEG, imageResource))
        );

        // Send the request
        ChatResponse response = chatClient.prompt(new Prompt(userMessage)).call();

        return response.getResult().getOutput().getContent();
    }
}

@Configuration
public class ToolsConfig {

    // Define Input and Output records (Schemas)
    public record WeatherRequest(String location, String unit) {}
    public record WeatherResponse(String temp, String condition) {}

    @Bean
    @Description("Get the current weather for a specific location. Unit can be C or F.")
    public Function<WeatherRequest, WeatherResponse> currentWeather() {
        return request -> {
            // Logic to call external Weather API (e.g., OpenWeatherMap)
            System.out.println("Calling weather API for " + request.location());

            // In a real app, use RestClient to call an external API here
            return new WeatherResponse("25", "Sunny");
        };
    }

    @Bean
    @Description("Book a flight for the user.")
    public Function<FlightRequest, FlightResponse> bookFlight() {
        return request -> {
           // Execute transactional logic
           return new FlightResponse("CONFIRMED", "Ticket #123");
        };
    }
}

@Service
public class AssistantService {

    private final ChatClient chatClient;

    public AssistantService(ChatClient.Builder builder) {
        this.chatClient = builder
                // Register the tool by its bean name
                // You can register multiple tools here
                .defaultFunctions("currentWeather", "bookFlight")
                .build();
    }

    public String chat(String userMessage) {
        // Scenario: User asks "What's the weather in Tokyo?"
        // 1. LLM analyzes prompt. Sees it matches 'currentWeather' description.
        // 2. LLM returns a structured request to call 'currentWeather' with location="Tokyo".
        // 3. Spring AI intercepts this, calls your Java bean, and gets the result.
        // 4. Spring AI sends the result (25 degrees) back to the LLM.
        // 5. LLM generates final response: "It is currently 25 degrees and Sunny in Tokyo."
        return chatClient.prompt(userMessage).call().content();
    }
}