DEV Community: Dilip Kumar B K

Effortless AI Model Integration: Build and Evaluate AI Models (Spring Boot and Hugging Face)

Dilip Kumar B K — Thu, 02 Jan 2025 21:45:46 +0000

The AI revolution is here, and with it comes an ever-growing list of powerful models that can generate text, create visuals, and solve complex problems. But let’s face it: with so many options, figuring out which model is the best fit for your project can be overwhelming. What if there was a way to quickly test these models, see their results in action, and decide which one to integrate into your production system?

Enter Hugging Face’s Inference API—your shortcut to exploring and leveraging state-of-the-art AI models. It eliminates the hassle of setting up, hosting, or training models by offering a plug-and-play solution. Whether you’re brainstorming a new feature or evaluating a model's capabilities, Hugging Face makes AI integration simpler than ever.

In this blog, I’ll walk you through building a lightweight backend application using Spring Boot that allows you to test and evaluate AI models effortlessly. Here’s what you can expect:

🌟 What You’ll Learn

Access AI Models: Learn how to use Hugging Face’s Inference API to explore and test models.
Build a Backend: Create a Spring Boot application to interact with these models.
Test Models: Set up and test endpoints for text and image generation using sample prompts.

By the end, you’ll have a handy tool to test-drive different AI models and make informed decisions about their suitability for your project’s needs. If you’re ready to bridge the gap between curiosity and implementation, let’s get started!

🛠️ Why Hugging Face Inference API?

Here’s why Hugging Face is a game-changer for AI integration:

Ease of Use: No need to train or deploy models—just call the API.
Variety: Access over 150,000 models for tasks like text generation, image creation, and more.
Scalability: Perfect for prototyping and production use.

🧩 What You’ll Build

We’ll build QuickAI, a Spring Boot application that:

Generates Text: Create creative content based on a prompt.
Generates Images: Turn text descriptions into visuals.
Provides API Documentation: Use Swagger to test and interact with the API.

🚀 Getting Started

Step 1: Sign Up for Hugging Face

Head over to huggingface.co and create an account if you don’t already have one.

Step 2: Get Your API Key

Navigate to your account settings and generate an API key. This key will allow your Spring Boot application to interact with Hugging Face’s Inference API.

Step 3: Explore Models

Check out the Hugging Face Model Hub to find models for your needs. For this tutorial, we’ll use:

A text generation model (e.g., HuggingFaceH4/zephyr-7b-beta).
An image generation model (e.g., stabilityai/stable-diffusion-xl-base-1.0).

🛠️ Setting Up the Spring Boot Project

Step 1: Create a New Spring Boot Project

Use Spring Initializr to set up your project with the following dependencies:

Spring WebFlux: For reactive, non-blocking API calls.
Lombok: To reduce boilerplate code.
Swagger: For API documentation.

Step 2: Add Hugging Face Configuration

Add your Hugging Face API key and model URLs to the application.properties file:

huggingface.text.api.url=https://api-inference.huggingface.co/models/your-text-model
huggingface.api.key=your-api-key-here
huggingface.image.api.url=https://api-inference.huggingface.co/models/your-image-model

🎉 What’s Next?

Let's dive into the code and build the services for text and image generation. Stay tuned!

1. Text Generating Service:

@Service
public class LLMService {
    private final WebClient webClient;
    private static final Logger logger = LoggerFactory.getLogger(LLMService.class);

    // Constructor to initialize WebClient with Hugging Face API URL and API key
    public LLMService(@Value("${huggingface.text.api.url}") String apiUrl,
                      @Value("${huggingface.api.key}") String apiKey) {
        this.webClient = WebClient.builder()
                .baseUrl(apiUrl) // Set the base URL for the API
                .defaultHeader("Authorization", "Bearer " + apiKey) // Add API key to the header
                .build();
    }

    // Method to generate text using Hugging Face's Inference API
    public Mono<String> generateText(String prompt) {
        // Validate the input prompt
        if (prompt == null || prompt.trim().isEmpty()) {
            return Mono.error(new IllegalArgumentException("Prompt must not be null or empty"));
        }

        // Create the request body with the prompt
        Map<String, String> body = Collections.singletonMap("inputs", prompt);

        // Make a POST request to the Hugging Face API
        return webClient.post()
                .bodyValue(body) 
                .retrieve() 
                .bodyToMono(String.class) 
                .doOnSuccess(response -> logger.info("Response received: {}", response)) // Log successful responses
                .doOnError(error -> logger.error("Error during API call", error)) // Log errors
                .retryWhen(Retry.backoff(3, Duration.ofMillis(500))) // Retry on failure with exponential backoff
                .timeout(Duration.ofSeconds(5)) // Set a timeout for the API call
                .onErrorResume(error -> Mono.just("Fallback response due to error: " + error.getMessage())); // Provide a fallback response on error
    }
}

2. Image Generation Service:

@Service
public class ImageGenerationService {

    private static final Logger logger = LoggerFactory.getLogger(ImageGenerationService.class);
    private final WebClient webClient;

    public ImageGenerationService(@Value("${huggingface.image.api.url}") String apiUrl,
                                  @Value("${huggingface.api.key}") String apiKey) {
        this.webClient = WebClient.builder()
                .baseUrl(apiUrl)
                .defaultHeader("Authorization", "Bearer " + apiKey)
                .build();
    }

    public Mono<byte[]> generateImage(String prompt) {
        if (prompt == null || prompt.trim().isEmpty()) {
            return Mono.error(new IllegalArgumentException("Prompt must not be null or empty"));
        }

        Map<String, String> body = Collections.singletonMap("inputs", prompt);

        return webClient.post()
                .bodyValue(body)
                .retrieve()
                .bodyToMono(byte[].class) / Convert the response to a Mono<byte[]> (image bytes)
                .timeout(Duration.ofSeconds(10)) // Timeout after 10 seconds
                .retryWhen(Retry.backoff(3, Duration.ofMillis(500))) // Retry logic
                .doOnSuccess(response -> logger.info("Image generated successfully for prompt: {}", prompt))
                .doOnError(error -> logger.error("Error generating image for prompt: {}", prompt, error))
                .onErrorResume(WebClientResponseException.class, ex -> {
                    logger.error("HTTP error during image generation: {}", ex.getMessage(), ex);
                    return Mono.error(new RuntimeException("Error generating image: " + ex.getMessage()));
                })
                .onErrorResume(TimeoutException.class, ex -> {
                    logger.error("Timeout while generating image for prompt: {}", prompt);
                    return Mono.error(new RuntimeException("Request timed out"));
                });
    }
}

Example prompts and their results: 😃

1. Text Based Endpoint:

2. Image Based Endpoint:

📂 Explore the Project

Ready to dive in? Check out the QuickAI GitHub repository to see the full code and follow along. If you find it useful then give it a ⭐.

Bonus 🤩

Want to take this project further?

I have configured Swagger UI for API documentation which will help you in building frontend App.
Build a simple frontend app using your favorite frontend framework (like React, Angular, or just plain HTML/CSS/Vanilla JS).

🎉 Congratulations You made it this far.

Now you know how to use Hugging Face 🤗:

To quickly use AI models in your applications.
Generate Text: Create creative content from prompts.
Generate Images: Turn text descriptions into visuals.

💬 Let’s Connect!

Want to collaborate or have any suggestions find me on LinkedIn, Portfolio also look into other projects of mine here GitHub.

Have a question or suggestion, please do comment here below I'll be happy to address them.

Happy Coding! 😊

Understanding Database Connection Management in Spring Boot with Hibernate and Spring Data JPA

Dilip Kumar B K — Mon, 30 Dec 2024 08:38:27 +0000

Managing database connections efficiently is one of the most critical aspects of building robust applications. Have you ever struggled with getting your database to play nicely with your code? Or found yourself confused about what all those application.properties settings mean? 🤔

In this blog, we’ll demystify database connections in Spring Boot using Hibernate and Spring Data JPA. We’ll walk through the essential configurations, explain tricky concepts like ddl-auto, and show practical examples for different databases.

Let’s dive in! 🌊

Assuming that you we have a Spring Boot application created with required dependencies.

Why Combine Spring Boot, Hibernate, and Spring Data JPA?

Spring Boot makes configuring and starting your application a breeze. But it doesn’t stop there. It integrates seamlessly with Hibernate, a powerful ORM tool that handles the heavy lifting of converting Java objects into database tables. On top of that, Spring Data JPA saves you from writing boilerplate code for CRUD operations by providing repository abstractions.

Think of this trio as your tech dream team for database management. You get:

Simplicity: Easy configuration and setup.
Efficiency: No more manual SQL for common tasks.
Power: Advanced database operations are just a few annotations away. ⚡

Now that you know why this stack rocks, let’s look at how to set it up. 🔧

Connecting Your Application to a Database

Imagine you're setting up a new project, and you need your Spring Boot app to talk to a MySQL database. Here’s how you can configure the connection:

DataSource Configuration

Your application.properties file is the heart of Spring Boot’s configuration. To connect to MySQL, you need:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

What Do These Mean?

spring.datasource.url: This tells Spring where to find your database.
spring.datasource.username/password: Your credentials for the database.
driver-class-name: Optional but good to include—this specifies the JDBC driver to use.

With just a few lines, your application is ready to connect to the database. ✨

Understanding JPA Properties

But connection is just the first step. Next, you need to tell Hibernate how to manage your database schema and log SQL queries. Here’s what a typical configuration looks like:

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

What Do These Properties Do?

ddl-auto: Controls how Hibernate updates your database schema. (More on this below!)
show-sql: Logs SQL queries in the console—great for debugging. 🔍
format_sql: Makes those SQL logs easier to read.

These settings ensure that Hibernate knows what to do with your database, and you can follow along with what’s happening under the hood.

What Does `ddl-auto` Do, Anyway?

If you’ve ever wondered what ddl-auto really does, you’re not alone. It’s one of the most important (and often misunderstood) settings in Hibernate. 🤨

Think of ddl-auto as the project manager for your database schema. It decides how your application interacts with the schema during startup. Here’s what each option means:

Setting	Description
`none`	No changes are made to the schema.
`validate`	Checks that the schema matches your Java entities but doesn’t modify it.
`update`	Adjusts the schema to match your entities without dropping data.
`create`	Drops and recreates the schema every time you start the application.
`create-drop`	Same as `create`, but it drops the schema when the app stops.

When Should You Use Each Setting?

Use update in development to keep your schema in sync with your code.
Use validate in production to ensure everything matches without accidental changes.
Avoid create and create-drop in production—they can wipe your data! 🚨

Handling Database Creation Automatically

Here’s a fun fact: some databases let you create the database itself when you connect. For example, with MySQL, you can append ?createDatabaseIfNotExist=true to your URL:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb?createDatabaseIfNotExist=true

Unfortunately, not all databases are this accommodating. PostgreSQL and MSSQL, for instance, require you to create the database manually or programmatically. Let’s see how you can automate that process.

Automating Database Creation with an Initializer

Imagine you’re working with PostgreSQL, and you don’t want to create the database manually every time. You can write a Spring component to do it for you at startup:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
public class DatabaseInitializer implements CommandLineRunner {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void run(String... args) {
        String dbName = "mydb";

        // Check if the database exists before attempting to create it
        String checkDbSQL = "SELECT 1 FROM information_schema.schemata WHERE schema_name = '" + dbName + "'";

        try {
            Integer result = jdbcTemplate.queryForObject(checkDbSQL, Integer.class);
            if (result != null) {
                System.out.println("Database already exists.");
            } else {
                String createDbSQL = "CREATE DATABASE " + dbName;
                jdbcTemplate.execute(createDbSQL);
                System.out.println("Database created.");
            }
        } catch (Exception e) {
            System.err.println("Error checking or creating database: " + e.getMessage());
        }
    }
}

This way, you can ensure that your application’s database is ready to use whenever you start it. ✅

Making Schema Changes: A Practical Example

Let’s say your Product entity has been running in production for a while, but now you need to add a new field for the product category:

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private Double price;

    // New Field
    private String category;
}

If you’re using ddl-auto=update, Hibernate will automatically add the category column to your table without affecting existing data. Pretty neat, right? 😎

Just remember: always test schema changes in a staging environment first to avoid surprises in production. ⚠️

Configuring Different Databases

Here are sample configurations for other popular databases:

PostgreSQL

spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=myuser
spring.datasource.password=mypassword
spring.datasource.driver-class-name=org.postgresql.Driver

SQLite (Great for Testing! 🔑)

spring.datasource.url=jdbc:sqlite:memory:mydb
spring.datasource.driver-class-name=org.sqlite.JDBC

SQLite is perfect for lightweight applications or quick tests, as it runs entirely in memory.

Wrapping Up

Congratulations! You’ve learned how to manage database connections in Spring Boot with Hibernate and Spring Data JPA. From understanding key properties to automating database creation, you’re now equipped to handle your application’s database with confidence.

What’s Next?

Try configuring a new database in your project.
Experiment with ddl-auto settings in different environments. 💡

Have any questions or tips of your own? Drop them in the comments below—I’d love to hear from you! 😊