<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.5</version> <!-- Use a recent stable version -->
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example.ai</groupId>
    <artifactId>simple-ai-agent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>simple-ai-agent</name>
    <description>Demo project for Spring AI Agent</description>
    <properties>
        <java.version>17</java.version>
        <spring-ai.version>0.8.1</spring-ai.version> <!-- Check for latest stable Spring AI version -->
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- For OpenAI -->
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        </dependency>
        <!-- For Google Gemini (if you prefer, comment out OpenAI and add this) -->
        <!--
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-vertexai-gemini-spring-boot-starter</artifactId>
        </dependency>
        -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

spring.ai.openai.api-key=${OPENAI_API_KEY}
spring.ai.openai.chat.options.model=gpt-4o-mini # Or gpt-3.5-turbo, gpt-4, etc.

spring.ai.vertexai.gemini.api-key=${GOOGLE_API_KEY}
spring.ai.vertexai.gemini.chat.options.model=gemini-pro # Or gemini-1.5-flash, etc.

package com.example.ai.simple_ai_agent;

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 SimpleChatController {

    private final ChatClient chatClient;

    public SimpleChatController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/chat")
    public String chat(@RequestParam(value = "message", defaultValue = "Tell me a joke!") String message) {
        // Send a simple user message to the LLM
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }

    @GetMapping("/chat/enhanced")
    public String enhancedChat(@RequestParam(value = "message", defaultValue = "Explain quantum physics briefly.") String message) {
        // Provide a system message to guide the LLM's behavior
        String systemPrompt = "You are a witty, helpful assistant. Respond concisely and with a touch of humor.";

        return chatClient.prompt()
                .system(systemPrompt)
                .user(message)
                .call()
                .content();
    }
}

Well, the meaning of life is a bit like a rubber chicken: squishy, unexpected, and often leaves you wondering why you're holding it. But it's probably best experienced with a good cup of coffee and some friendly company!

package com.example.ai.simple_ai_agent;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.SystemPromptTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
public class PromptController {

    private final ChatClient chatClient;

    public PromptController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/role-play")
    public String rolePlayChat(
            @RequestParam(value = "role", defaultValue = "historian") String role,
            @RequestParam(value = "topic", defaultValue = "World War II") String topic) {

        // Define a system prompt template with a placeholder for the role
        SystemPromptTemplate systemPromptTemplate = new SystemPromptTemplate(
                "You are a professional and knowledgeable {role}. " +
                "Your task is to provide insightful information about the given topic. " +
                "Keep your responses concise and informative."
        );

        // Fill the placeholder in the system prompt
        String systemPrompt = systemPromptTemplate.create(Map.of("role", role)).getContents();

        // Create the user message
        UserMessage userMessage = new UserMessage("Tell me something interesting about " + topic + ".");

        // Construct the full prompt with both system and user messages
        Prompt prompt = new Prompt(userMessage, systemPrompt);

        // Call the chat client
        ChatResponse chatResponse = chatClient.prompt(prompt).call().chatResponse();

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

As a scientist, I find black holes fascinating regions of spacetime where gravity is so strong that nothing, not even light, can escape. They form from the remnants of massive stars and can range from stellar-mass to supermassive sizes at the centers of galaxies. Their event horizon marks the point of no return.

package com.example.ai.simple_ai_agent;

import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.context.annotation.Bean;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SimpleAiAgentApplication {

    public static void main(String[] args) {
        SpringApplication.run(SimpleAiAgentApplication.class, args);
    }

    // Configure a global ChatMemoryProvider for the application
    @Bean
    public ChatMemory chatMemory() {
        // This remembers the last 10 messages across the entire application.
        // For a real agent, you'd want per-user or per-session memory,
        // which we'll cover in intermediate topics.
        return new MessageWindowChatMemory(); // Default constructor has a reasonable window
    }
}

package com.example.ai.simple_ai_agent;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor; // Import this
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class StatefulChatController {

    private final ChatClient chatClient;
    // We'll use a simple in-memory map for demonstration.
    // In a real application, this would be backed by a persistent store.
    private final java.util.Map<String, ChatMemory> conversationMemories = new java.util.concurrent.ConcurrentHashMap<>();

    public StatefulChatController(ChatClient.Builder chatClientBuilder) {
        // The chatClient will be built for each request with a specific advisor
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/chat/stateful")
    public String statefulChat(
            @RequestParam(value = "message") String message,
            @RequestParam(value = "sessionId", defaultValue = "defaultUser") String sessionId) {

        // Get or create ChatMemory for the specific session
        ChatMemory sessionMemory = conversationMemories.computeIfAbsent(sessionId, id ->
                MessageWindowChatMemory.builder().maxMessages(10).build()); // Retain last 10 messages

        // Apply the MessageChatMemoryAdvisor to the current ChatClient prompt
        // This advisor will manage adding messages to and retrieving messages from the sessionMemory
        return chatClient.prompt()
                .advisors(new MessageChatMemoryAdvisor(sessionMemory))
                .user(message)
                .call()
                .content();
    }

    // Optional: An endpoint to clear memory for a session
    @GetMapping("/chat/clear-memory")
    public String clearMemory(@RequestParam(value = "sessionId", defaultValue = "defaultUser") String sessionId) {
        conversationMemories.remove(sessionId);
        return "Memory cleared for session: " + sessionId;
    }
}

package com.example.ai.simple_ai_agent;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;
import org.springframework.ai.tool.ToolFunction; // Import this

import java.util.function.Function;

@Configuration
public class ToolConfiguration {

    // Define a record for the tool's input
    public record WeatherRequest(String city) {}
    // Define a record for the tool's output
    public record WeatherResponse(String city, String temperature, String conditions) {}

    // This method simulates fetching weather data
    // In a real app, this would call a weather API
    @Service("weatherService") // Give it a name for the LLM to refer to
    public static class WeatherService {
        public WeatherResponse getCurrentWeather(WeatherRequest request) {
            String city = request.city();
            // Simulate different weather for different cities
            if ("London".equalsIgnoreCase(city)) {
                return new WeatherResponse(city, "15°C", "Partly cloudy");
            } else if ("New York".equalsIgnoreCase(city)) {
                return new WeatherResponse(city, "22°C", "Sunny");
            } else if ("Tokyo".equalsIgnoreCase(city)) {
                return new WeatherResponse(city, "20°C", "Rainy");
            } else {
                return new WeatherResponse(city, "N/A", "Unknown");
            }
        }
    }

    // Expose the tool as a Spring Bean using ToolFunction
    @Bean
    public Function<WeatherRequest, WeatherResponse> getCurrentWeatherTool(
            WeatherService weatherService) {
        return weatherService::getCurrentWeather;
    }
}

package com.example.ai.simple_ai_agent;

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 ToolCallingChatController {

    private final ChatClient chatClient;

    // Inject the ChatClient.Builder. Spring AI will automatically discover the ToolFunction beans.
    public ToolCallingChatController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/chat/weather-agent")
    public String weatherAgent(
            @RequestParam(value = "message", defaultValue = "What's the weather like in New York?") String message) {

        // When the user asks about weather, the LLM will "see" the `getCurrentWeatherTool`
        // and infer it needs to call it.
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }

    @GetMapping("/chat/mixed-agent")
    public String mixedAgent(
            @RequestParam(value = "message", defaultValue = "What is the weather in London and then tell me a joke?") String message) {
        // The agent can call tools and then continue generating text
        String systemPrompt = "You are a helpful assistant. Use tools when necessary and always be friendly.";
        return chatClient.prompt()
                .system(systemPrompt)
                .user(message)
                .call()
                .content();
    }
}

The current weather in New York is 22°C and sunny.

In London, it's currently 15°C and partly cloudy.

Why don't scientists trust atoms?
Because they make up everything! 😂

        <!-- For Embedding Model (if using OpenAI) -->
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        </dependency>
        <!-- For in-memory Vector Store (simple for demo) -->
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-vector-store-simple</artifactId>
        </dependency>
        <!-- For actual Vector DB like Chroma (uncomment and configure if needed) -->
        <!--
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-chroma-spring-boot-starter</artifactId>
        </dependency>
        -->

package com.example.ai.simple_ai_agent;

import org.springframework.ai.document.Document;
import org.springframework.ai.embedding.EmbeddingClient;
import org.springframework.ai.vectorstore.SimpleVectorStore;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.boot.ApplicationRunner; // To load data on startup

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;

@Configuration
public class RagConfiguration {

    // Inject a dummy policy document from resources
    @Value("classpath:/data/company-policy.txt")
    private Resource companyPolicy;

    @Bean
    public VectorStore vectorStore(EmbeddingClient embeddingClient) {
        // For demonstration, SimpleVectorStore is in-memory.
        // For production, you'd use a persistent vector database.
        return new SimpleVectorStore(embeddingClient);
    }

    // This ApplicationRunner will load our policy document into the vector store on startup
    @Bean
    public ApplicationRunner initVectorStore(VectorStore vectorStore) {
        return args -> {
            // Read the policy document
            String policyContent = new String(companyPolicy.getInputStream().readAllBytes(), StandardCharsets.UTF_8);

            // Create a Document from the content. Spring AI will handle splitting and embedding.
            Document policyDocument = new Document(policyContent);

            // Add the document to the vector store
            vectorStore.add(List.of(policyDocument));
            System.out.println("Company policy loaded into vector store.");
        };
    }
}

## Company Vacation Policy

Employees are eligible for 20 days of paid vacation per calendar year. New employees accrue vacation days at a rate of 1.67 days per month for the first year. After the first year, all 20 days are available at the beginning of the calendar year.

Vacation requests must be submitted through the HR portal at least two weeks in advance. All requests are subject to manager approval based on team staffing needs. Unused vacation days can be carried over for a maximum of 5 days into the next calendar year. Any days exceeding this limit will be forfeited.

## Remote Work Policy

Our company supports remote work arrangements. Employees must maintain a suitable home office environment and ensure reliable internet connectivity. Regular check-ins with managers are required. For international remote work, specific country regulations and tax implications must be discussed with HR prior to any arrangement. Failure to comply may result in termination.

## Expense Reimbursement Policy

Employees can claim reimbursement for approved business expenses, including travel, meals, and professional development courses. Receipts are mandatory for all claims. Expenses exceeding $50 require prior manager approval. Reimbursement requests must be submitted within 30 days of the expense incurrence.

package com.example.ai.simple_ai_agent;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.RetrievalAdvisor; // Import for RAG
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RagChatController {

    private final ChatClient chatClient;
    private final VectorStore vectorStore;

    public RagChatController(ChatClient.Builder chatClientBuilder, VectorStore vectorStore) {
        this.vectorStore = vectorStore;
        // Configure ChatClient with a RetrievalAdvisor to enable RAG
        this.chatClient = chatClientBuilder
                .defaultAdvisors(new RetrievalAdvisor(vectorStore)) // Use the vector store for retrieval
                .build();
    }

    @GetMapping("/chat/policy-agent")
    public String policyAgent(
            @RequestParam(value = "query", defaultValue = "How many vacation days can I carry over?") String query) {

        String systemPrompt = "You are a helpful HR assistant. Answer questions based on the provided policy documents only. If you cannot find the answer, politely state that the information is not available in the documents.";

        return chatClient.prompt()
                .system(systemPrompt)
                .user(query)
                .call()
                .content();
    }
}

You can carry over a maximum of 5 unused vacation days into the next calendar year. Any days exceeding this limit will be forfeited.

I apologize, but the company dress code policy is not available in the documents I have access to.

package com.example.ai.simple_ai_agent;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Service;

@Service
public class ChainWorkflow {

    private final ChatClient chatClient;
    private final String[] systemPrompts;

    public ChainWorkflow(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
        this.systemPrompts = new String[] {
            """
            STEP 1: You are an expert data extractor.
            From the given text, identify and extract all numerical performance metrics and their corresponding descriptions.
            Present them as a list, one per line, in the format: "Metric Name: Value".
            Example: "Customer Satisfaction: 92 points"
            """,
            """
            STEP 2: You are an expert data formatter.
            Take the list of metrics provided. For each metric, convert numerical values to percentages where appropriate (e.g., "92 points" becomes "92%"). If a value is already a percentage or a currency, retain its format.
            Maintain the format: "Metric Name: Value".
            Example: "Customer Satisfaction: 92%"
            """,
            """
            STEP 3: You are an executive summarizer.
            Take the formatted list of metrics and write a concise, one-paragraph executive summary (max 3 sentences) highlighting the most significant points.
            Focus on key achievements or areas needing attention.
            """
        };
    }

    public String processReport(String rawReport) {
        String currentOutput = rawReport;
        System.out.println("--- Starting Chain Workflow ---");
        System.out.println("Initial Input:\n" + rawReport);

        for (int i = 0; i < systemPrompts.length; i++) {
            System.out.println("\n--- Step " + (i + 1) + " ---");
            // Combine the system prompt for the current step with the output from the previous step
            String stepInput = currentOutput; // Input to the LLM for this step is the previous output
            currentOutput = chatClient.prompt()
                    .system(systemPrompts[i]) // Apply the specific system prompt for this step
                    .user(stepInput)
                    .call()
                    .content();
            System.out.println("Output:\n" + currentOutput);
        }
        System.out.println("\n--- Chain Workflow Finished ---");
        return currentOutput;
    }
}

package com.example.ai.simple_ai_agent;

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class WorkflowController {

    private final ChainWorkflow chainWorkflow;

    public WorkflowController(ChainWorkflow chainWorkflow) {
        this.chainWorkflow = chainWorkflow;
    }

    @PostMapping("/workflow/chain-report")
    public String runChainWorkflow(@RequestBody String reportContent) {
        return chainWorkflow.processReport(reportContent);
    }
}

package com.example.ai.simple_ai_agent;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.stereotype.Service;

import java.util.Map;

@Service
public class RoutingWorkflow {

    private final ChatClient chatClient;

    public RoutingWorkflow(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    // A tool/function to simulate specialized handlers
    public String handleBilling(String query) {
        return "Billing Specialist: We are looking into your billing query: '" + query + "'. Please provide your account number.";
    }

    public String handleTechnical(String query) {
        return "Technical Support: I understand you have a technical issue with: '" + query + "'. Can you please restart your device?";
    }

    public String handleGeneral(String query) {
        return "Customer Service: Thank you for your general inquiry: '" + query + "'. How else can I assist?";
    }

    public String routeAndRespond(String userQuery) {
        // The LLM acts as the router to decide which handler is most appropriate
        String routingPrompt = """
            Given the user query: "{query}", classify its intent as either 'billing', 'technical', or 'general'.
            Respond with *only* the chosen category.
            Example:
            User: "My internet is not working."
            Output: technical
            User: "I was charged twice."
            Output: billing
            User: "I want to know your operating hours."
            Output: general
            """;

        String category = chatClient.prompt()
                .system(routingPrompt)
                .user(userQuery)
                .call()
                .content()
                .trim()
                .toLowerCase();

        System.out.println("Detected category: " + category);

        // Based on the category, invoke the specialized handler
        switch (category) {
            case "billing":
                return handleBilling(userQuery);
            case "technical":
                return handleTechnical(userQuery);
            case "general":
                return handleGeneral(userQuery);
            default:
                return "I couldn't classify your request. Please try rephrasing.";
        }
    }
}

package com.example.ai.simple_ai_agent;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RoutingController {

    private final RoutingWorkflow routingWorkflow;

    public RoutingController(RoutingWorkflow routingWorkflow) {
        this.routingWorkflow = routingWorkflow;
    }

    @GetMapping("/workflow/route-query")
    public String routeCustomerQuery(@RequestParam(value = "query") String query) {
        return routingWorkflow.routeAndRespond(query);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.5</version> <!-- Use a recent stable version -->
        <relativePath/>
    </parent>
    <groupId>com.example.techgadget</groupId>
    <artifactId>customer-service-agent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>customer-service-agent</name>
    <description>Customer Service AI Agent for TechGadget Inc.</description>
    <properties>
        <java.version>17</java.version>
        <spring-ai.version>0.8.1</spring-ai.version> <!-- Check for latest stable Spring AI version -->
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-vector-store-simple</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <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>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

spring.ai.openai.api-key=${OPENAI_API_KEY}
spring.ai.openai.chat.options.model=gpt-4o-mini

## TechGadget Product Warranty
All TechGadget products come with a one-year limited warranty covering manufacturing defects. This warranty does not cover accidental damage, misuse, or normal wear and tear. To claim warranty, customers must provide proof of purchase.

## TechGadget Return Policy
Customers can return products within 30 days of purchase for a full refund, provided the product is in its original condition and packaging. A 15% restocking fee may apply for opened products. Custom-ordered items are non-returnable.

## TechGadget Support Channels
For technical support, please visit our website's support page or call us at 1-800-TECH-SUP. For sales inquiries, email sales@techgadget.com.

## TechGadget Product Line
We offer a range of smart home devices, including smart thermostats, intelligent lighting systems, and security cameras. Our flagship product is the "GlowOrb Smart Light."

// src/main/java/com/example/techgadget/RagConfig.java
package com.example.techgadget;

import org.springframework.ai.document.Document;
import org.springframework.ai.embedding.EmbeddingClient;
import org.springframework.ai.vectorstore.SimpleVectorStore;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;

import java.nio.charset.StandardCharsets;
import java.util.List;

@Configuration
public class RagConfig {

    @Value("classpath:/data/techgadget-kb.txt")
    private Resource techGadgetKb;

    @Bean
    public VectorStore vectorStore(EmbeddingClient embeddingClient) {
        return new SimpleVectorStore(embeddingClient);
    }

    @Bean
    public ApplicationRunner initVectorStore(VectorStore vectorStore) {
        return args -> {
            String kbContent = new String(techGadgetKb.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
            vectorStore.add(List.of(new Document(kbContent)));
            System.out.println("TechGadget knowledge base loaded into vector store.");
        };
    }
}

// src/main/java/com/example/techgadget/OrderService.java
package com.example.techgadget;

import org.springframework.ai.tool.ToolFunction;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;

import java.util.function.Function;

@Configuration
public class OrderServiceConfig {

    public record OrderStatusRequest(String orderId) {}
    public record OrderStatusResponse(String orderId, String status, String estimatedDelivery) {}

    @Service("orderService")
    public static class OrderService {
        public OrderStatusResponse getOrderStatus(OrderStatusRequest request) {
            String orderId = request.orderId();
            // Simulate looking up order status based on orderId
            switch (orderId) {
                case "TG12345":
                    return new OrderStatusResponse(orderId, "Shipped", "October 5, 2025");
                case "TG67890":
                    return new OrderStatusResponse(orderId, "Processing", "October 10, 2025");
                default:
                    return new OrderStatusResponse(orderId, "Not Found", "N/A");
            }
        }
    }

    @Bean
    public Function<OrderStatusRequest, OrderStatusResponse> getOrderStatusTool(
            OrderService orderService) {
        return orderService::getOrderStatus;
    }
}

// src/main/java/com/example/techgadget/CustomerServiceController.java
package com.example.techgadget;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.client.advisor.RetrievalAdvisor;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@RestController
public class CustomerServiceController {

    private final ChatClient chatClient;
    private final Map<String, ChatMemory> conversationMemories = new ConcurrentHashMap<>();

    public CustomerServiceController(ChatClient.Builder chatClientBuilder, VectorStore vectorStore) {
        // Configure ChatClient with both RetrievalAdvisor and default MessageChatMemoryAdvisor
        this.chatClient = chatClientBuilder
                .defaultAdvisors(
                        new RetrievalAdvisor(vectorStore), // For RAG
                        new MessageChatMemoryAdvisor(new MessageWindowChatMemory()) // Default memory if not overridden per session
                )
                .build();
    }

    @GetMapping("/api/customer-service")
    public String serveCustomer(
            @RequestParam(value = "message") String message,
            @RequestParam(value = "customerId", defaultValue = "guest") String customerId) {

        ChatMemory sessionMemory = conversationMemories.computeIfAbsent(customerId, id ->
                MessageWindowChatMemory.builder().maxMessages(10).build());

        String systemPrompt = """
            You are "TechGadget Support Assistant", a friendly and helpful AI agent for TechGadget Inc.
            Your primary goal is to assist customers with product information, company policies, and order inquiries.
            You have access to internal knowledge base documents for product and policy details.
            You can also check order statuses using the 'getOrderStatusTool'.
            If a customer asks for an order status, you MUST ask for their order ID if not provided.
            Always maintain a polite and professional tone.
            """;

        return chatClient.prompt()
                .system(systemPrompt)
                .advisors(new MessageChatMemoryAdvisor(sessionMemory)) // Override or add specific session memory
                .user(message)
                .call()
                .content();
    }

    @GetMapping("/api/customer-service/clear-session")
    public String clearCustomerSession(@RequestParam(value = "customerId", defaultValue = "guest") String customerId) {
        conversationMemories.remove(customerId);
        return "Customer session cleared for " + customerId;
    }
}

// src/main/java/com/example/recipeplanner/RecipeSteps.java
package com.example.recipeplanner;

import java.util.List;

public record RecipeSteps(
        String recipeName,
        List<String> ingredients,
        List<Step> preparationSteps,
        List<Step> cookingSteps) {

    public record Step(int stepNumber, String description) {}
}

// src/main/java/com/example/recipeplanner/RecipePlannerService.java
package com.example.recipeplanner;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.stereotype.Service;

import java.util.Map;

@Service
public class RecipePlannerService {

    private final ChatClient chatClient;

    public RecipePlannerService(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    public RecipeSteps planRecipe(String dish) {
        String systemPrompt = """
            You are a master chef and culinary planner.
            Your task is to create a detailed, step-by-step recipe plan for "{dish}".
            The plan must include:
            1. The exact name of the recipe.
            2. A list of all necessary ingredients.
            3. Detailed preparation steps.
            4. Detailed cooking steps.

            Generate the output as a JSON object matching the `RecipeSteps` Java record structure.
            Do not include any other text or explanation.
            RecipeSteps Java record:
            public record RecipeSteps(
                String recipeName,
                List<String> ingredients,
                List<Step> preparationSteps,
                List<Step> cookingSteps) {
                public record Step(int stepNumber, String description) {}
            }
            """;

        // We use .entity() to map the LLM's JSON output directly to our Java record
        return chatClient.prompt()
                .system(new PromptTemplate(systemPrompt).create(Map.of("dish", dish)).getContents())
                .user("Plan the recipe for " + dish)
                .call()
                .entity(RecipeSteps.class);
    }
}

// src/main/java/com/example/recipeplanner/RecipePlannerController.java
package com.example.recipeplanner;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RecipePlannerController {

    private final RecipePlannerService recipePlannerService;

    public RecipePlannerController(RecipePlannerService recipePlannerService) {
        this.recipePlannerService = recipePlannerService;
    }

    @GetMapping("/api/plan-recipe")
    public RecipeSteps getRecipePlan(@RequestParam(value = "dish", defaultValue = "Spaghetti Carbonara") String dish) {
        return recipePlannerService.planRecipe(dish);
    }
}

{
  "recipeName": "Spaghetti Carbonara",
  "ingredients": [
    "200g spaghetti",
    "100g guanciale (or pancetta)",
    "2 large egg yolks",
    "50g Pecorino Romano cheese, grated",
    "Black pepper, freshly ground",
    "Salt, to taste"
  ],
  "preparationSteps": [
    {
      "stepNumber": 1,
      "description": "Bring a large pot of salted water to a boil for the spaghetti."
    },
    {
      "stepNumber": 2,
      "description": "Cut the guanciale (or pancetta) into small strips or cubes."
    },
    {
      "stepNumber": 3,
      "description": "In a bowl, whisk together the egg yolks, grated Pecorino Romano, and a generous amount of freshly ground black pepper."
    }
  ],
  "cookingSteps": [
    {
      "stepNumber": 1,
      "description": "Cook the spaghetti according to package directions until al dente."
    },
    {
      "stepNumber": 2,
      "description": "While the pasta cooks, heat a large non-stick pan over medium heat. Add the guanciale and cook until crispy and golden. Remove the guanciale with a slotted spoon, leaving the rendered fat in the pan."
    },
    {
      "stepNumber": 3,
      "description": "Before draining the spaghetti, reserve about 1 cup of the pasta cooking water."
    },
    {
      "stepNumber": 4,
      "description": "Drain the spaghetti and immediately add it to the pan with the guanciale fat. Toss well."
    },
    {
      "stepNumber": 5,
      "description": "Quickly add the egg mixture to the pasta, tossing vigorously to coat. Add a splash of reserved pasta water if needed to create a creamy sauce. The heat from the pasta will cook the egg, but prevent it from scrambling."
    },
    {
      "stepNumber": 6,
      "description": "Stir in the crispy guanciale. Season with additional black pepper and salt if necessary. Serve immediately."
    }
  ]
}