Spring AI — Build AI-Powered Applications

@RestController
@RequiredArgsConstructor
public class AIChatController {

    private final ChatClient chatClient;

    @GetMapping("/ai/chat")
    public String chat(@RequestParam String message) {
        return chatClient.prompt()
            .user(message)
            .call()
            .content();
    }
}

@Service
public class CodeReviewService {

    private final ChatClient chatClient;

    public CodeReviewResponse reviewCode(String code, String language) {
        return chatClient.prompt()
            .system("""
                You are a senior {language} code reviewer. 
                Focus on: security vulnerabilities, performance issues, 
                and adherence to SOLID principles.
                Respond in JSON format with fields: issues[], suggestions[], score (1-10).
                """)
            .user("Review this code:\n```%s\n%s\n```".formatted(language, code))
            .call()
            .entity(CodeReviewResponse.class);  // auto-maps JSON to Java object!
    }
}

@GetMapping(value = "/ai/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> streamChat(@RequestParam String message) {
    return chatClient.prompt()
        .user(message)
        .stream()
        .content();  // tokens streamed as they're generated
}

@Service
@RequiredArgsConstructor
public class DocumentQAService {

    private final ChatClient chatClient;
    private final VectorStore vectorStore;

    // Ingest documents (run once or on upload)
    public void ingestDocuments(List<Document> documents) {
        // Spring AI handles chunking + embedding + storage
        vectorStore.add(documents);
    }

    // Answer questions using your documents
    public String askQuestion(String question) {
        // 1. Find relevant documents
        List<Document> relevant = vectorStore.similaritySearch(
            SearchRequest.query(question).withTopK(5)
        );

        // 2. Build context from retrieved docs
        String context = relevant.stream()
            .map(Document::getContent)
            .collect(Collectors.joining("\n\n"));

        // 3. Ask LLM with context
        return chatClient.prompt()
            .system("""
                Answer the user's question based ONLY on the provided context.
                If the context doesn't contain the answer, say "I don't know."

                Context:
                {context}
                """)
            .user(question)
            .call()
            .content();
    }
}

// Define functions the AI can call
@Configuration
public class AIFunctionConfig {

    @Bean
    @Description("Get the current weather for a city")
    public Function<WeatherRequest, WeatherResponse> getWeather() {
        return request -> weatherService.getWeather(request.city());
    }

    @Bean
    @Description("Search the product catalog by keyword and category")
    public Function<ProductSearchRequest, List<Product>> searchProducts() {
        return request -> productService.search(request.keyword(), request.category());
    }

    @Bean
    @Description("Place an order for a customer")
    public Function<OrderRequest, OrderConfirmation> placeOrder() {
        return request -> orderService.create(request);
    }
}

// The AI decides WHEN to call functions based on user intent
@GetMapping("/ai/assistant")
public String assistant(@RequestParam String message) {
    return chatClient.prompt()
        .user(message)
        .functions("getWeather", "searchProducts", "placeOrder")
        .call()
        .content();
}

// User: "What's the weather in NYC and find me a rain jacket under $50"
// AI calls: getWeather("NYC") → searchProducts("rain jacket", "outerwear")
// AI responds: "It's 45°F and rainy in NYC. Here are rain jackets under $50: ..."

@Service
public class CustomerSupportAgent {

    private final ChatClient chatClient;
    private final OrderRepository orderRepo;
    private final RefundService refundService;

    public String handleTicket(String customerMessage, String customerId) {
        return chatClient.prompt()
            .system("""
                You are a customer support agent for an e-commerce platform.
                You can look up orders, initiate refunds, and escalate issues.
                Be empathetic and concise. Follow company policy.
                Customer ID: {customerId}
                """)
            .user(customerMessage)
            .functions("lookupOrder", "initiateRefund", "escalateToHuman")
            .advisors(new MessageChatMemoryAdvisor(chatMemory))  // conversation memory
            .call()
            .content();
    }
}

// Define your response type
public record SentimentAnalysis(
    String sentiment,       // "positive", "negative", "neutral"
    double confidence,      // 0.0 - 1.0
    List<String> keywords,  // extracted keywords
    String summary          // one-line summary
) {}

// Get structured, type-safe output
@GetMapping("/ai/analyze")
public SentimentAnalysis analyzeSentiment(@RequestParam String review) {
    return chatClient.prompt()
        .user("Analyze the sentiment of this review: " + review)
        .call()
        .entity(SentimentAnalysis.class);  // auto-maps to Java record!
}