DEV Community: Pranjit Medhi

Building a Local RAG Application with Spring AI, Ollama, PGVector, and Apache Tika

Pranjit Medhi — Sat, 16 May 2026 06:05:54 +0000

Retrieval-Augmented Generation (RAG) is a powerful design pattern that allows you to ground Large Language Models (LLMs) with your proprietary, real-time context. This prevents hallucinations and eliminates the need for expensive model fine-tuning.
This comprehensive guide walks you through building a completely local, production-ready RAG application using the Spring ai.

1. Prerequisites and Local Environment Setup

Before touching Java code, you need to set up the infrastructure. Create a compose.yml file to spin up PostgreSQL (with the pgvector extension) and Ollama:

docker-compose.yml
services:
  postgres:
    image: pgvector/pgvector:pg16
    container_name: spring-ai-rag-postgres
    environment:
      POSTGRES_DB: spring_ai_rag
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5432:5432"

  ollama:
    image: ollama/ollama:latest
    container_name: spring-ai-rag-ollama
    ports:
      - "11434:11434"

Pulling the Local AI Models
Start your Docker containers by running docker compose up -d. Next, allocate models to your local Ollama engine via your terminal:

docker exec -it spring-ai-rag-ollama ollama pull llama3.2
docker exec -it spring-ai-rag-ollama ollama pull nomic-embed-text

2. Project Setup & Dependencies

Head over to start.spring.io and create a standard Spring Boot project using Maven or Gradle. Add the following dependencies to your pom.xml:

    <!-- Spring Web for REST APIs -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring AI Ollama Support -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
    </dependency>

    <!-- Spring AI PGVector Store Starter -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-pgvector-store-spring-boot-starter</artifactId>
    </dependency>

    <!-- Apache Tika Document Reader Support -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-tika-document-reader</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>`

3. Configuration Management

Add the following properties to your src/main/resources/application.yml file to stitch your components together:

spring:
  application:
    name: spring-ai-local-rag

  # Database Connection Details
  datasource:
    url: jdbc:postgresql://localhost:5432/spring_ai_rag
    username: postgres
    password: postgres

  ai:
    # Ollama Model Configurations
    ollama:
      base-url: http://localhost:11434
      chat:
        options:
          model: llama3.2
      embedding:
        options:
          model: nomic-embed-text

    # Vector Database Settings
    vectorstore:
      pgvector:
        initialize-schema: true
        table-name: rag_documents

4. Implementing Retrieval and Chat Generation

Next, build the execution pipeline. We configure a structured ChatClient. This component automatically queries PGVector behind the scenes based on incoming prompts and attaches relevant context.

public class RagService {

    @Value("classpath:rag-guide.txt")
    Resource textfile;

    ChatClient chatClient;
    VectorStore vectorStore;

    public RagService(ChatClient.Builder chatClient, VectorStore vectorStore) {
        this.chatClient = chatClient.build();
        this.vectorStore = vectorStore;
    }

    public void ingestText() {

        System.out.println("Reading document...");

        TikaDocumentReader reader = new TikaDocumentReader(textfile);

        List<Document> documents = reader.get();

        System.out.println("Documents loaded: " + documents.size());

        vectorStore.add(documents);

        System.out.println("Documents added to vector store");
    }


    public String askSimpleQuestion() {
        String question = "What is RAG?";
        System.out.println("Starting similarity search...");
        SearchRequest searchRequest = SearchRequest.builder()
                .query(question)
                .topK(3)
                .build();
        List<Document> documents =
                vectorStore.similaritySearch(searchRequest);
        System.out.println("Similarity search completed");
        StringBuilder context = new StringBuilder();
        for (Document document : documents) {
            context.append(document.getText()).append("\n");
        }
        System.out.println("Calling LLM...");

        String prompt = """
                Given the following context information,
                answer the question.
                Context:
                %s
                Question:
                %s
                """.formatted(context, question);

        String response = chatClient.prompt(prompt)
                .call()
                .content();

        System.out.println("LLM response received");

        return response;
    }
}

5. Data foler

Create a store rag-guide.txt file in resources folder

6. Running the application

We will run the application using CommandLineRuner interface of springboot as show below:

@SpringBootApplication
public class RagCliApplication implements CommandLineRunner{

    @Autowired
    private RagService service;

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


    @Override
    public void run(String... args) throws Exception {
         service.ingestText();
        final String s = service.askSimpleQuestion();
        System.out.println(s);
    }
}

The Builder Design Pattern: A Deep Dive for Software Developers

Pranjit Medhi — Tue, 23 Dec 2025 15:44:58 +0000

In object-oriented programming, constructing complex objects can quickly become unwieldy—especially when an object requires many parameters, some of which may be optional or interdependent. Enter the Builder Design Pattern, a creational pattern that provides a clean, readable, and maintainable way to construct complex objects step by step.

Originally popularized by the Gang of Four (GoF) and later refined by Joshua Bloch in Effective Java, the Builder pattern is now a staple in modern software design, used everywhere from domain models to API clients.

What Is the Builder Design Pattern?

The Builder pattern separates the construction of a complex object from its representation, allowing the same construction process to create different representations.

Core Components

Builder: An abstract interface that defines the steps to construct the product.
ConcreteBuilder: Implements the Builder interface and constructs and assembles parts of the product.
Director: (Optional) Orchestrates the building steps in a specific order.
Product: The complex object being built.

In practice—especially in languages like Java, C#, or TypeScript—the pattern is often implemented without a separate Director, using a fluent interface where the Builder itself guides construction through method chaining.

A Practical Example (Java)

public class User {
    private final String firstName;
    private final String lastName;
    private final int age;
    private final String email;
    private final String phoneNumber;

    // Private constructor enforces use of Builder
    private User(Builder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.email = builder.email;
        this.phoneNumber = builder.phoneNumber;
    }

    public static class Builder {
        private String firstName;
        private String lastName;
        private int age;
        private String email;
        private String phoneNumber;

        public Builder firstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public Builder lastName(String lastName) {
            this.lastName = lastName;
            return this;
        }

        public Builder age(int age) {
            this.age = age;
            return this;
        }

        public Builder email(String email) {
            this.email = email;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}

Advantages of the Builder Pattern

*1. Improved Readability and Maintainability *
Method names clearly indicate what each parameter represents, eliminating confusion over parameter order (a common issue with telescoping constructors).

2. Immutability Support
Builders work naturally with immutable objects. The product is only instantiated once all fields are set—via a private constructor—ensuring thread safety and state consistency.

3. Validation at Build Time
You can centralize validation logic in the build() method, ensuring the object is always in a valid state upon creation.

4. Handles Optional Parameters Gracefully
Unlike constructors or factory methods, builders don’t require you to pass null or default values for optional fields.

5. Fluent and Expressive API
Chained method calls create a domain-specific language (DSL)-like experience, improving code ergonomics.

Disadvantages and Trade-offs

1. Increased Code Verbosity
For every complex class, you need a corresponding Builder class. This doubles (or more) the amount of boilerplate code—though modern IDEs and tools (like Lombok in Java) can mitigate this.

2. Overkill for Simple Objects
If your class has only a few required fields and no optional ones, a simple constructor is cleaner and more efficient.

3. Runtime Overhead
While usually negligible, the extra object allocation (the Builder instance) and method calls do introduce minor performance costs—important only in high-performance or memory-constrained contexts.

Conclusion

The Builder design pattern is a powerful tool for managing the creation of complex, immutable objects in a readable and safe manner. While it introduces some boilerplate, the benefits in clarity, correctness, and maintainability often outweigh the costs - especially in large-scale applications.