Spring Boot ChatGPT Integration Tutorial

In this tutorial, we will integrate ChatGPT with a Spring Boot application using the new RestClient class introduced in Spring Boot 3.2. We will demonstrate how to call the ChatGPT APIs using this REST client to generate responses based on user input.

Introduction

ChatGPT, developed by OpenAI, is a powerful AI model that can generate human-like text based on input prompts. Integrating ChatGPT with a Spring Boot application allows you to leverage its capabilities to build intelligent applications that can interact with users in a conversational manner.

Prerequisites

• Java 17 or later
• Maven 3.8.1 or later
• OpenAI API Key

1. Setting Up the Project

Step 1: Create a New Spring Boot Project

Use Spring Initializr to create a new Spring Boot project. Include dependencies for Spring Web.

Using Spring Initializr:

• Go to start.spring.io
• Select:
  • Project: Maven Project
  • Language: Java
  • Spring Boot: 3.3.0 (or latest)
  • Dependencies: Spring Web
• Generate the project and unzip it.

Step 2: Add Dependencies

In your project's pom.xml, ensure you have the necessary dependencies.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2. Configuring the Application

Step 1: Add API Key to Configuration

Add your OpenAI API key to application.properties.

openai.api.key=your_openai_api_key
openai.api.url=https://api.openai.com/v1/completions

Step 2: Configure RestClient

Create a configuration class to set up the RestClient.

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestClient;

@Configuration
public class AppConfig {

    @Bean
    public RestClient restClient() {
        return RestClient.builder().build();
    }
}

3. Creating the ChatGPT Client

Step 1: Define the Request and Response Models

Create models for the request and response data.

ChatGPTRequest.java

package com.example.demo.model;

import java.util.List;

public class ChatGPTRequest {
    private String model;
    private List<ChatGPTMessage> messages;

    // Getters and setters
}

public class ChatGPTMessage {
    private String role;
    private String content;

    // Getters and setters
}

ChatGPTResponse.java

package com.example.demo.model;

import java.util.List;

public class ChatGPTResponse {
    private List<Choice> choices;

    // Getters and setters

    public static class Choice {
        private ChatGPTMessage message;

        // Getters and setters
    }
}

Step 2: Create the ChatGPT Client Service

Create a service to interact with the ChatGPT API.

package com.example.demo.service;

import com.example.demo.model.ChatGPTRequest;
import com.example.demo.model.ChatGPTResponse;
import com.example.demo.model.ChatGPTMessage;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;

import java.util.Collections;

@Service
public class ChatGPTService {

    private final RestClient restClient;

    @Value("${openai.api.key}")
    private String apiKey;

    @Value("${openai.api.url}")
    private String apiUrl;

    public ChatGPTService(RestClient restClient) {
        this.restClient = restClient;
    }

    public String getChatGPTResponse(String userMessage) {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.setBearerAuth(apiKey);

        ChatGPTMessage userMessageObj = new ChatGPTMessage();
        userMessageObj.setRole("user");
        userMessageObj.setContent(userMessage);

        ChatGPTRequest request = new ChatGPTRequest();
        request.setModel("gpt-3.5-turbo");
        request.setMessages(Collections.singletonList(userMessageObj));

        HttpEntity<ChatGPTRequest> entity = new HttpEntity<>(request, headers);

        ChatGPTResponse response = restClient.exchange(apiUrl, HttpMethod.POST, entity, ChatGPTResponse.class).getBody();

        return response != null && !response.getChoices().isEmpty()
                ? response.getChoices().get(0).getMessage().getContent()
                : "No response from ChatGPT";
    }
}

4. Creating the Chatbot Controller

Step 1: Create a Controller to Expose the Service

Create a controller to expose an endpoint for the chatbot.

package com.example.demo.controller;

import com.example.demo.service.ChatGPTService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ChatbotController {

    private final ChatGPTService chatGPTService;

    @Autowired
    public ChatbotController(ChatGPTService chatGPTService) {
        this.chatGPTService = chatGPTService;
    }

    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return chatGPTService.getChatGPTResponse(message);
    }
}

5. Testing the Integration

Step 1: Run the Application

Run your Spring Boot application. Ensure the application starts without errors.

Step 2: Access the Chat Endpoint

Use Postman, curl, or your browser to test the endpoint. For example:

http://localhost:8080/chat?message=Hello, how are you?

You should receive a response generated by the ChatGPT model based on the provided message.

Conclusion

This tutorial demonstrated how to integrate ChatGPT with a Spring Boot application using RestClient to call the ChatGPT APIs. You learned how to configure Spring Boot, create a service to interact with the ChatGPT API, and expose an endpoint for user interaction. This setup allows you to integrate AI-powered chat functionalities into your Spring Boot applications, enhancing user experience with intelligent and dynamic responses. 

Explore further customization and enhancements to leverage the full potential of AI in your projects.