Spring AI is an open-source application framework designed to easily integrate Artificial Intelligence (AI) features into Spring Boot applications. It functions as a standard middleware layer; rather than training or building AI models from scratch, it enables developers to seamlessly connect their enterprise code with existing AI models. Below, we outline the step-by-step process for configuring and developing a chatbot.
First, you need to select an LLM (Large Language Model) that Spring AI will use to communicate:

 

Step 1:We will use the standalone Ollama LLM model. To do this, install Ollama on your system (download via https://ollama.com/download/windows) and then download a free model from https://ollama.com/search.
CMD:

Check Ollama Run using URL: http://localhost:11434/
Step 2:
In this step, we configure the Spring Boot AI application using Spring Initializr (https://start.spring.io/); we have previously covered how to perform this configuration. Here, we will explain the coding process step-by-step. 

Step 2.1: Check the dependencies in the `pom.xml` file and ensure they match your project setup.

 
<?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>4.1.1</version> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>a143mk.AI</groupId> <artifactId>aiChatclient</artifactId> <version>0.0.1-SNAPSHOT</version> <name/> <description/> <url/> <licenses> <license/> </licenses> <developers> <developer/> </developers> <scm> <connection/> <developerConnection/> <tag/> <url/> </scm> <properties> <java.version>17</java.version> <spring-ai.version>2.0.1</spring-ai.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webmvc</artifactId> </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-starter-model-ollama</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webmvc-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>
Step 2.2: 

We create a REST controller named `ChatClientController.java`. Here, we will see how to implement the LLM packages and classes, and we will also use `@CrossOrigin` to facilitate the design of the web UI. package a143mk.AI.aiChatclient; import org.springframework.ai.chat.client.ChatClient; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import reactor.core.publisher.Flux; import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/chat") @CrossOrigin(origins = "*") public class ChatClientControler { private final ChatClient chatClient; public ChatClientControler(ChatClient.Builder chatClientBuilder) { this.chatClient = chatClientBuilder.build(); } @PostMapping("/Message") public ResponseEntity<String> chat(@RequestParam(value="q") String message) { String response = this.chatClient.prompt(message).call().content(); return ResponseEntity.ok(response); } @PostMapping(value = "/Message/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE) public Flux<String> streamChat(@RequestParam(value = "q") String message) { return this.chatClient.prompt(message) .stream() .content(); } }

Step 2.3: We will configure the LLM model settings within the `application.properties` file.

 

Step 3: Finally, we create the web page (`indexAI_CHAT.html`) and integrate the REST controller with the web UI.

  <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>AI ChatBot</title> <!-- jQuery --> <script src="https://code.jquery.com/jquery-3.7.1.min.js"></script> <style> body { font-family: Arial, sans-serif; margin: 40px; background: #f5f5f5; } .chat-container { max-width: 700px; margin: auto; background: white; padding: 25px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); } #chatInput { width: 70%; padding: 10px; font-size: 16px; } #sendBtn { padding: 10px 20px; font-size: 16px; cursor: pointer; } #sendStrim { padding: 10px 20px; font-size: 16px; cursor: pointer; } /* #response-display { margin-top: 20px; padding: 15px; background: #eee; min-height: 100px; white-space: pre-wrap; border-radius: 5px; }*/ /* Your original container */ #response-display { margin-top: 20px; padding: 15px; background: #eee; min-height: 100px; white-space: pre-wrap; border-radius: 5px; font-family: sans-serif; /* Clean font for regular text */ } /* New styles for the code block container */ #response-display pre { background: #272822; /* Dark background for code contrast */ color: #f8f8f2; /* Light text color */ padding: 12px; margin: 10px 0; border-radius: 4px; overflow-x: auto; /* Adds horizontal scrollbar if code is too long */ } /* New styles for the actual code text */ #response-display pre code { font-family: 'Courier New', Courier, monospace; /* Monospace font */ font-size: 14px; white-space: pre; /* Keeps code indentation exactly as written */ } .error { color: red; } </style> </head> <body> <div class="chat-container"> <h2>AI Chatbot</h2> <input type="text" id="chatInput" value="hi" placeholder="Enter your message" > <button id="sendBtn">Send Message</button> <h3>Response:</h3> <pre id="response-display">Waiting...</pre> <em id="chat-container">Power by <a href="https://a143mk.blogspot.com/">a143mk</a></em> </div> <script> // Check jQuery console.log("jQuery version:", $.fn.jquery); $('#sendBtn').on('click', function () { // Get value from input var userInput = $('#chatInput').val().trim(); // Validate input if (!userInput) { $('#response-display').text("Please enter a message."); return; } // API URL var targetUrl = "http://localhost:8081/chat/Message?q="+ encodeURIComponent(userInput); console.log("Calling API:", targetUrl); // Show loading $('#response-display').text("Sending..."); // POST request $.post(targetUrl).done(function (entityResponse) { // console.log("API Response:", entityResponse); $('#response-display').text(entityResponse); }) .fail(function (xhr, status, error) { console.error("Request failed:", status, error); console.error("HTTP Status:", xhr.status); console.error("Response:", xhr.responseText); $('#response-display') .addClass("error") .text( "Request failed" + "HTTP Status: " + xhr.status + "\n" + "Error: " + error ); }); }); // Allow Enter key to send $('#chatInput').on('keypress', function (event) { if (event.which === 13) { $('#sendBtn').click(); } }); </script> </body> </html>

Step 1: Obtain the authentication details/Requirements from the client as shown in the example below.

Step 2: Making an API call with an Json payload and pushing master data to the location.

1. A REST API Controller is responsible for handling HTTP requests (such as GET, POST, PUT, DELETE) from clients and routing them to the appropriate service methods. It acts as the entry point for external clients to interact with the backend application. 
2. Purpose: The main role of the controller is to manage incoming HTTP requests, map them to specific methods (often called endpoints), and return appropriate responses to the client. 
3. Responsibilities: Handle HTTP requests (e.g., GET, POST, PUT, DELETE). Map the incoming requests to service methods. Return HTTP responses, often in JSON or Json format. Perform basic request validation or authentication. Act as the "interface" between the client and the service layer. In a Spring Boot application, for example, the controller is typically annotated with @RestController and the request mappings are handled using annotations like @GetMapping, @PostMapping, etc. 

Example "ClientApiController.java" of a REST Controller in Spring Boot with handlined Json Payload :

 
package a143mk.a143mkCustMasterMaster.SystemClientcontroller; import java.net.URL; import java.text.Format; import java.text.SimpleDateFormat; import java.util.Date; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import a143mk.a143mkCustMasterMaster.FromBean.APIResponseEntityBean; import a143mk.a143mkCustMasterMaster.SystemClientServices.CustMastSysteCliService; import org.apache.log4j.PropertyConfigurator; @RestController @RequestMapping("/CUST_T_API") public class ClientApiController { private static final Logger logger = LoggerFactory.getLogger(CustomerMasterCoSysteCli.class); @Autowired private CustMastSysteCliService custMasteServ; @RequestMapping(method = RequestMethod.POST, value="/cust") public ResponseEntity<APIResponseEntityBean> getCustMasterSysteCli() { APIResponseEntityBean responseEntityBean = null; Object retunResult=null; try { /*Log4je Config*/ ClassLoader loader = Thread.currentThread().getContextClassLoader(); URL url = loader.getResource("application.properties"); PropertyConfigurator.configure(url); /* End Log4je Config*/ logger.info("Push A143mk Customer TO SysteCli Method is getCustMasterSysteCli()"); retunResult=custMasteServ.CustMastSystemNameService(); responseEntityBean = new APIResponseEntityBean("SUCCESS", "Please check Log file For Success or not!", dtFormater.format(new Date()), retunResult); } catch (Exception e) { // TODO: handle exception responseEntityBean = new APIResponseEntityBean("ERROR", e.getMessage(),dtFormater.format(new Date()), retunResult); logger.error(e.getMessage()); //e.printStackTrace(); } return new ResponseEntity<APIResponseEntityBean>(responseEntityBean, HttpStatus.OK); } }  

The Service class is a part of the business logic layer of your application. It contains methods that implement the core functionality of the application (e.g., creating, reading, updating, deleting data). The service class is called by the controller to perform operations that are not directly related to the web request itself. 

1. Purpose: The service layer acts as a mediator between the controller and the data layer (such as a repository or database). It focuses on business logic and operations. 
2. Responsibilities: Perform the core business logic of the application. Interact with the database (via repositories or DAOs). Provide methods for the controller to use (i.e., encapsulate business operations). Handle any necessary validation or transformation before sending data back to the controller. In a Spring Boot application, service classes are typically annotated with @Service, and they are injected into the controller using @Autowired (or constructor injection). 

Example "CustMastSystemNameService.java" of a Service Class in Spring Boot: 

 Method Internal Working ->geta143mkCustMasterFOrSYS() ->pusha143mkCustToSystemNameSystem().

 
package a143mk.a143mkCustMaster.SYSServices; import java.io.Serializable; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import a143mk.a143mkCustMaster.Entity.a143mkCustAddressMaster; import a143mk.a143mkCustMaster.Entity.a143mkCustMaster; import a143mk.a143mkCustMaster.Repository.a143mkCustAddressMasterRepository; import a143mk.a143mkCustMaster.Repository.a143mkCustMasterRepository; import a143mk.a143mkCustMaster.SYSConfig.SSLStopGetToken; import org.springframework.http.*; import org.springframework.web.client.RestTemplate; @SuppressWarnings("serial") @Service public class CustMastSystemNameService implements Serializable { private static final Logger logger = LoggerFactory.getLogger(CustMastSystemNameService.class); @Autowired private a143mkCustMasterRepository customerMastRepositM1Table; @Autowired private a143mkCustAddressMasterRepository custAdderssMastRepoM2Table; public List<Map<String, Object>> geta143mkCustMasterFOrSYS() { List<Map<String, Object>> pusha143mkCustSystemNameList = new ArrayList<>(); try { logger.info("Start a143mkCust_push"); List<a143mkCustMaster> getMasterV = customerMastRepositM1Table.mdmCustDetailsSystemName(); if (getMasterV != null) { for (a143mkCustMaster getCust : getMasterV) { // Use a Map instead of JSONObject Map<String, Object> customerMap = new HashMap<>(); customerMap.put("name", getCust.geta143mkCustName()); customerMap.put("type", "Business"); customerMap.put("sub_type", "a143mkCust"); customerMap.put("phone", Optional.ofNullable(getCust.getPhoneNo()).map(String::trim).filter(p->p.length()>10).orElse("no")); customerMap.put("email", Optional.ofNullable(getCust.getEmailId()).orElse("no")); customerMap.put("code", Optional.ofNullable(getCust.getWhDepotStoreNo()).map(String::trim).filter(p->p.length()>5).orElse("no")); customerMap.put("user_id", "AA143Mkbolgs"); //Pass the client_id value or pass the value according to your client. pusha143mkCustSystemNameList.add(customerMap); // Address logic List<a143mkCustAddressMaster> cutoAddressSystemName = custAdderssMastRepoM2Table.geta143mkCustAddressTableList(getCust.getLegacyCustNo()); List<Map<String, Object>> pushAddressList = new ArrayList<>(); if (cutoAddressSystemName != null) { for (a143mkCustAddressMaster custAdde : cutoAddressSystemName) { Map<String, Object> address = new HashMap<>(); address.put("address_1", custAdde.getAddress1()); address.put("address_2", Optional.ofNullable(custAdde.getAddress2()).orElse("")); address.put("address_3", Optional.ofNullable(custAdde.getAddress3()).orElse("")); address.put("city", Optional.ofNullable(custAdde.getCityName()).orElse("no")); address.put("state", Optional.ofNullable(custAdde.getStateCode()).orElse("")); address.put("pincode", Optional.ofNullable(custAdde.getPincode()).orElse("") ); address.put("state_code", custAdde.getStateCode()); pushAddressList.add(address); } } // Add the address list to the customer map customerMap.put("address_details", pushAddressList); } ResponseEntity<String> returnto=pusha143mkCustToSystemNameSystem(pusha143mkCustSystemNameList); if(returnto!=null) { logger.info("Success:" +returnto); }else { logger.error("Error to Push customer to SystemName", returnto); } } } catch (Exception e) { logger.error("Error in geta143mkCustMasterFOrSYS", e); } return pusha143mkCustSystemNameList; } private ResponseEntity<String> pusha143mkCustToSystemNameSystem(List<Map<String, Object>> pusha143mkCustSystemNameList) { RestTemplate restTemplate = new RestTemplate(); try { // 1. Get token String getTokenTms = new SSLStopGetToken().GetToken(); if (getTokenTms == null) { throw new RuntimeException("Failed to get SystemName token"); } // 2. Set headers HttpHeaders headers = new HttpHeaders(); headers.set("Authorization", "Bearer " + getTokenTms); // 3. Build the request entity HttpEntity<List<Map<String, Object>>> request = new HttpEntity<>(pusha143mkCustSystemNameList, headers); // 4. This is the Client Master API URL through which client master data can be sent. This is a test URL; you can modify it according to your client's requirements. String url = "https://a143mk-uat.client.com/api/master/push_customer"; ResponseEntity<String> response = restTemplate.postForEntity(url, request, String.class); // 5. Get response body /* responseObject = response.getBody(); System.out.println("Response: " + responseObject); logger.info("statuse for in geta143mkCustMasterFOrSYS: ", responseObject);*/ return response; } catch (Exception e) { logger.error("Error pushing customer to SystemName", e); return null; } } }