Building Your Personal AI API with Spring Boot, Spring AI, and Google Gemini

Create an Intelligent Web Service that Answers Questions using the Power of Generative AI

In this tutorial, we are going to integrate Spring Boot with Spring AI/Gen AI to build a web service that leverages Google’s Gemini generative AI model. The goal is to create a simple web service that can answer user questions intelligently, based on the capabilities of generative AI. With the power of Gemini, we can tap into cutting-edge AI to provide accurate and context-aware responses, making our web service both useful and interactive.

Overview

We’ll use Spring Boot, a popular Java-based framework, to create the backend for our web service. We’ll also integrate Spring AI, which makes working with machine learning and generative AI models seamless. Using Gemini as our AI model, we will set up a system that answers user questions with advanced, natural language responses.

Prerequisites

Java 11 or higher: Make sure you have the correct version of Java installed.
Maven: For dependency management and building the project.
Basic Understanding of Spring Boot: Familiarity with Spring Boot and RESTful web services will be helpful.
Gemini API Access: You’ll need API access to Google’s Gemini model for generative AI capabilities.

Step 1: Set Up a Spring Boot Project

First, let’s create a Spring Boot application. You can use Spring Initializr to set up your project structure.

Visit Spring Initializr.
Fill in the details: Project: Maven Project Language: Java Spring Boot Version: latest Dependencies: Select “Spring Web”, “Spring AI” and “Spring Boot Actuator”.
Generate the project and unzip it.
Import the project into your favorite IDE (e.g., IntelliJ IDEA or Eclipse).

Step 2: Add Dependencies for Spring AI and Google Gemini

Open your pom.xml file and add the dependencies needed for integrating Spring AI and Gemini. Each dependency serves a specific purpose:

Spring Boot Web: Provides core functionalities to create web applications, allowing us to build RESTful APIs.
Spring AI: Integrates machine learning and generative AI capabilities seamlessly into Spring Boot applications.
Google Gemini API Client: Allows us to interact with the Google Gemini AI model for generating intelligent responses.
Jackson for JSON Parsing: Used for parsing JSON data to and from Java objects, which is necessary for handling API requests and responses.

<dependencies>
    <!-- Spring Boot Web dependency -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring AI dependency -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai</artifactId>
        <version>1.0.0</version>
    </dependency>
    <!-- Google Gemini API Client -->
    <dependency>
        <groupId>com.google.api</groupId>
        <artifactId>google-gemini-client</artifactId>
        <version>1.0.0</version>
    </dependency>
    <!-- Jackson for JSON parsing -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
</dependencies>

Step 3: Configure Google Gemini API Access

To interact with Google’s Gemini model, you need to obtain an API key from Google and configure API access. Here’s how you can get the API key:

Sign Up for Google Cloud: If you don’t have a Google Cloud account, sign up at Google Cloud Platform.
Enable the Gemini API: Go to the Google Cloud Console, search for Gemini API, and enable it for your project. You may need to create a new project if you don’t have one.
Get API Key: Navigate to the APIs & Services section in the Cloud Console. - Click on Credentials. - Select Create Credentials > API Key. - Copy the generated API key.
Once you have your API key, you can add it to the application.properties file:

gemini.api.key=YOUR_GEMINI_API_KEY

Replace YOUR_GEMINI_API_KEY with the API key provided by Google when you registered for access.

Step 4: Create a Client Interface for Gemini Interaction

To make the system more flexible, we will create a separate client interface layer for interacting with the Gemini API. This way, we can easily swap out the Gemini API for another AI provider in the future if needed.

Create an interface called AIClient and then provide an implementation for Gemini.

package com.example.demo.client;

public interface AIClient {
    String getAnswer(String question);
}

Now, create an implementation of AIClient that uses the Gemini API.

package com.example.demo.client.impl;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import com.google.api.gemini.GeminiClient;
import com.google.api.gemini.model.GeminiRequest;
import com.google.api.gemini.model.GeminiResponse;
import com.example.demo.client.AIClient;

@Component
public class GeminiClientImpl implements AIClient {

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

    private final GeminiClient geminiClient;

    public GeminiClientImpl() {
        this.geminiClient = new GeminiClient(apiKey);
    }

    @Override
    public String getAnswer(String question) {
        GeminiRequest request = new GeminiRequest(question);
        GeminiResponse response = geminiClient.generateResponse(request);
        return response.getText();
    }
}

Step 4: Create a Service Layer to Use the AI Client

Now that we have a flexible client interface, we can create a service that uses this AIClient to get answers.

package com.example.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.example.demo.client.AIClient;

@Service
public class AIService {

    private final AIClient aiClient;

    @Autowired
    public AIService(AIClient aiClient) {
        this.aiClient = aiClient;
    }

    public String getAnswer(String question) {
        return aiClient.getAnswer(question);
    }
}

Step 5: Create a REST Controller for User Interaction

In this step, we’ll create a REST controller that allows users to interact with the AI service by sending HTTP requests. We’ll set up a GET endpoint where users can pass their question as a query parameter. The controller will use the AIService to process the requests and return the answers generated by the AI.

This approach makes it easy to test the service using a web browser or tools like Postman.

package com.example.demo.controller;

import com.example.demo.service.GeminiService;
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 QuestionController {

    @Autowired
    private GeminiService aiService;

    @GetMapping("/ask")
    public String askQuestion(@RequestParam String question) {
        return geminiService.getAnswer(question);
    }
}

Step 6: Run the Spring Boot Application

Now that everything is set up, it’s time to run the Spring Boot application. You can do this by running the DemoApplication class (the class with the @SpringBootApplication annotation).

Once the application is running, you can access the API by visiting the following URL in your browser, using a tool like Postman, or by using a curl command:

Example using curl

curl "http://localhost:8080/ask?question=What is generative AI?"

Step 7: Test and Refine the Service

Try asking a variety of questions to see how well the AI responds. You may want to add logging and error handling to refine the responses and provide meaningful messages when the API fails.

Enhancing Security and Performance

Rate Limiting: To prevent abuse of your AI-powered endpoint, you can use rate limiting tools like Spring Boot Rate Limiter to restrict the number of requests a user can make in a given timeframe.
Authentication and Authorization: Implement Spring Security to authenticate users and authorize access to the AI service. This helps protect the endpoint from unauthorized usage and ensures that only legitimate users can interact with your service.
Caching: Use caching mechanisms like Spring Cache to store frequently requested answers, reducing API calls and improving response times.
Input Validation: Make sure to validate user input to avoid malformed or potentially harmful requests.

Bonus Step: Integrate Speech-to-Text and Text-to-Speech to Build Your Own Jarvis

To take this project a step further, you can integrate speech-to-text and text-to-speech capabilities to create your own voice-based assistant, similar to Jarvis from Iron Man. This will allow users to interact with the AI using voice commands and receive spoken responses.

Tools You Can Use:

Google Cloud Speech-to-Text: Converts spoken words into text. This can be used to capture user questions via voice input.
Google Cloud Text-to-Speech: Converts text responses from the AI into speech, allowing the AI to “talk back” to the user.
Vosk API: An open-source alternative for speech recognition that works offline, suitable for simpler or offline applications.

Integration Steps:

Add Dependencies: Add the required dependencies for Google Cloud Speech and Text-to-Speech in your pom.xml.|

<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-speech</artifactId>
    <version>1.28.0</version>
</dependency>
<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-texttospeech</artifactId>
    <version>1.3.0</version>
</dependency>

2. Set Up the Services: Create services that use the Google Cloud SDK to interact with the Speech-to-Text and Text-to-Speech APIs.

3. Integrate with the AI Controller: Modify your controller to accept audio input, convert it to text using Speech-to-Text, send the text to Gemini for processing, and then convert the AI response back to speech using Text-to-Speech.

With these additional features, your AI-powered Spring Boot application becomes a fully interactive voice assistant that can answer questions, provide information, and even help automate tasks.

Conclusion

Integrating Spring Boot with Spring AI and Google Gemini allows you to create a powerful web service that uses generative AI to answer user questions. This kind of integration showcases how traditional web frameworks can combine with modern AI technologies to build intelligent and responsive applications.

This project can be expanded further by adding more advanced NLP techniques, incorporating other AI models, or creating a more robust UI for better user interaction. With the growing capabilities of generative AI, the possibilities are endless.

Have you tried integrating AI into your Spring Boot projects? What challenges did you face? Let us know in the comments below!