DEV Community: Adnene HAMDOUNI

RAG with Spring Boot: Give Your AI a Private Contextual Memory

Adnene HAMDOUNI — Mon, 07 Sep 2026 21:21:58 +0000

RAG with Spring Boot: Give Your AI a Private Contextual Memory

📌 Metadata

Subject: RAG / Vector Databases / Spring AI / Java
Target: Java Developers, Data/AI Architects
Estimated Reading Time: 10 minutes
Tags: #SpringBoot #SpringAI #RAG #VectorDatabase #JavaAI

🎯 Introduction

One of the biggest challenges of generative AI in the enterprise is the phenomenon of hallucinations. An LLM, however powerful, can invent facts with disconcerting confidence, especially when it comes to recent data or confidential internal documents it has never "seen" during its training.

Imagine asking your AI: "What is the reimbursement procedure for customer X?". If the AI doesn't have access to your contracts, it will make a guess based on statistical probabilities. This is where RAG (Retrieval Augmented Generation) changes the game.

RAG doesn't seek to retrain the model (which would be costly and slow). Instead, it turns the AI into an ultra-fast researcher: before answering, the AI searches your private documents, extracts the relevant passages, and uses this information as a basis to formulate its response. This is called grounded generation.

By the end of this article, you will understand how to orchestrate this flow with Spring AI and implement a robust contextual memory architecture.

🛠️ Technical Core

1. The RAG Pipeline Deconstructed: Understanding the Flow

To implement RAG, you need to design two distinct pipelines: one for ingestion and one for retrieval.

A. The Ingestion Pipeline (Storing Knowledge)

This is where your documents become "readable" for the AI:

Document Reading: Load files (PDF, Markdown, HTML) via DocumentReader.
Chunking: Split the text into pieces (chunks). Why? Because LLMs have a limited context window and precise pieces allow for finer search.
Embedding: Each piece is converted into a numerical vector by an embedding model. This vector represents the semantic meaning of the text.
Vector Store: These vectors are stored in a vector database (like PGVector).

B. The Retrieval Pipeline (The Response)

This is what happens when the user asks a question:

Query Vectorization: The question is converted into a vector.
Similarity Search: Search the Vector Store for the $K$ text pieces whose vectors are closest to that of the question.
Prompt Augmentation: Build a prompt like: "Here are relevant documents: [Context]. Based solely on these documents, answer the question: [Question]".
Generation: The LLM generates the final response based on the provided evidence.

2. Technical Implementation with Spring AI

Prerequisites

JDK 17+, Spring Boot 3.x.
A Vector Store. We will use PGVector (PostgreSQL extension), the preferred choice for enterprises because it allows keeping transactional and vector data in the same place.

Step 1: Vector Store Configuration

Add the PGVector starter to your pom.xml and configure your access in application.yml:

spring:
  ai:
    vectorstore:
      pgvector:
        initialize-schema: true
        index-type: HNSW
        distance-type: COSINE_DISTANCE
        dimensions: 1536

Step 2: Document Ingestion

Here's how to load and store your knowledge:

@Service
class KnowledgeIngestionService {
    private final VectorStore vectorStore;

    public KnowledgeIngestionService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    public void ingest(Resource pdfResource) {
        TikaDocumentReader reader = new TikaDocumentReader(pdfResource);
        TokenTextSplitter splitter = new TokenTextSplitter();
        List<Document> chunks = splitter.apply(reader.get());
        vectorStore.accept(chunks);
    }
}

Step 3: Chat with Contextual Memory

Thanks to the QuestionAnswerAdvisor, Spring AI automates the entire retrieval process.

@RestController
class RagController {
    private final ChatClient chatClient;

    public RagController(ChatClient.Builder builder, VectorStore vectorStore) {
        var ragAdvisor = QuestionAnswerAdvisor.builder(vectorStore)
                .searchRequest(SearchRequest.builder().topK(4).similarityThreshold(0.7).build())
                .build();

        this.chatClient = builder
                .defaultAdvisors(ragAdvisor)
                .build();
    }

    @GetMapping("/ask")
    public String ask(@RequestParam String question) {
        return chatClient.prompt()
                .user(question)
                .call()
                .content();
    }
}

Pro Tip: If you notice the AI answering "I don't know" when the info is present, lower the similarityThreshold (e.g., 0.6). If it hallucinates too much, increase it (e.g., 0.8).

3. Analysis & Optimization: Going Further

RAG is not a "magic" solution; it requires tuning:

The Chunking Challenge
Chunk size is crucial. Pieces that are too small lose the global context. Pieces that are too large introduce noise. A common strategy is "Overlapping": making chunks overlap to avoid cutting an important sentence in half.

Embeddings: The Search Engine
The choice of the embedding model (e.g., text-embedding-3-small vs a local model via HuggingFace) directly impacts precision. A good embedding model understands that "car" and "automobile" are semantically close.

Confidentiality vs Fine-Tuning
Why choose RAG over fine-tuning?

Instant Updates: Add a document to the Vector Store, and the AI knows it immediately. No retraining needed.
Traceability: RAG allows citing sources ("According to document X, page 4..."), which is impossible with fine-tuning.
Security: You control exactly which document is retrieved based on the user's rights.

🏁 Conclusion & Opening

RAG transforms AI from a conversational assistant into a true business expert capable of exploiting your private data with precision and security. It is the foundation of any serious enterprise AI.

But we still have one step to go. Today, our AI answers. Tomorrow, it must act. This is where Autonomous Agents and the MCP protocol come in, which we will explore in the next article.

Your turn! Install PGVector, load your first documents, and see your Spring Boot application suddenly become very intelligent.

📚 Sources & Resources

Spring AI: Integrating Artificial Intelligence into Your Java Applications in Minutes

Adnene HAMDOUNI — Mon, 07 Sep 2026 21:21:57 +0000

Spring AI: Integrating Artificial Intelligence into Your Java Applications in Minutes

📌 Metadata

Subject: Spring Boot / AI / Java
Target: Java Developers, Software Architects
Estimated Reading Time: 8 minutes
Tags: #SpringBoot #SpringAI #Java #LLM #GenerativeAI

🎯 Introduction

For a long time, generative AI seemed to be the exclusive domain of Python. Java developers were often forced to call raw REST APIs without any real abstraction layer.

That's where Spring AI comes in.

This new project from the Spring ecosystem doesn't just add an HTTP client for OpenAI. It brings a real abstraction layer, similar to what Spring Data did for databases. The idea is simple: you write your business logic once, and you can change your AI model (GPT-4, Claude, Mistral, or even a local model via Ollama) without modifying a single line of business code.

By the end of this article, you will know how to configure your first Spring AI project and create a chat service capable of returning structured data.

🛠️ Technical Core

1. Fundamental Concept: Model Abstraction

At the heart of Spring AI is the ChatModel interface. It standardizes interactions with LLMs. This is critical in an enterprise environment to avoid "vendor lock-in". You can switch from OpenAI to a local model via Ollama simply by changing a dependency.

2. Technical Implementation

Prerequisites

JDK 17 or higher.
Spring Boot 3.x.
An OpenAI API key (or Ollama installed locally).

Step 1: Project Configuration

Add the corresponding starter to your pom.xml:

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

Then, configure your API key in the application.yml file:

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4o
          temperature: 0.7

Step 2: Creating the Chat Service with ChatClient

The fluent ChatClient API is the modern way to interact with AI. Here's how to implement a simple controller:

@RestController
@RequestMapping("/ai")
class AiController {
    private final ChatClient chatClient;

    public AiController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return this.chatClient.prompt()
            .user(message)
            .call()
            .content();
    }
}

Step 3: Mastering PromptTemplates and Structured Output

To make your applications truly useful, you cannot rely on free-text messages. You need structures.

PromptTemplates allow you to inject dynamic variables:

String response = chatClient.prompt()
    .user(u -> u
        .text("Explain the concept of {concept} in two sentences for a beginner.")
        .param("concept", "Dependency Injection"))
    .call()
    .content();

Structured Output is the "killer feature" for Java devs. You can map the AI response directly into a Java record:

record Movie(String title, String director, int year) {}

@GetMapping("/movie-info")
public Movie getMovieInfo(@RequestParam String movieName) {
    return chatClient.prompt()
        .user("Give me info on the movie " + movieName)
        .call()
        .entity(Movie.class);
}

Pro Tip: Use Advisors (like MessageChatMemoryAdvisor) to natively add conversation history without having to manually manage a list of messages for every call.

3. Analysis & Comparison: Spring AI vs LangChain4j

If you explore AI in Java, you will definitely encounter LangChain4j.

Criterion	Spring AI	LangChain4j
Integration	Native and deep with Spring Boot	Standalone libraries (usable everywhere)
Learning Curve	Very low for Spring devs	Moderate (closer to LangChain Python)
Ecosystem	Benefits from the entire Spring ecosystem	Very complete on third-party integrations
Philosophy	Abstraction and simplicity	Flexibility and functional richness

Verdict: If your stack is already Spring Boot, Spring AI is the logical choice for its simplicity and alignment with your development patterns.

🏁 Conclusion & Opening

AI is no longer an "option" or a gadget for data scientists; it is now a first-class citizen in the Java ecosystem. With Spring AI, the technical barrier collapses to make room for business innovation.

But a LLM alone has a limit: it doesn't know your private data. That's where RAG (Retrieval Augmented Generation) comes in. In the next article, we'll see how to give a "memory" to your Spring Boot application by connecting a Vector Store.

Your turn! Install Ollama locally, configure Spring AI, and try creating your first structured agent. Share your feedback in the comments!

📚 Sources & Resources

RAG with Spring Boot: Give Your AI a Private Contextual Memory

Adnene HAMDOUNI — Mon, 07 Sep 2026 21:12:13 +0000

RAG with Spring Boot: Give Your AI a Private Contextual Memory

📌 Metadata

Subject: RAG / Vector Databases / Spring AI / Java
Target: Java Developers, Data/AI Architects
Estimated Reading Time: 10 minutes
Tags: #SpringBoot #SpringAI #RAG #VectorDatabase #JavaAI

🎯 Introduction

By the end of this article, you will understand how to orchestrate this flow with Spring AI and implement a robust contextual memory architecture.

🛠️ Technical Core

1. The RAG Pipeline Deconstructed: Understanding the Flow

To implement RAG, you need to design two distinct pipelines: one for ingestion and one for retrieval.

A. The Ingestion Pipeline (Storing Knowledge)

This is where your documents become "readable" for the AI:

Document Reading: Load files (PDF, Markdown, HTML) via DocumentReader.
Chunking: Split the text into pieces (chunks). Why? Because LLMs have a limited context window and precise pieces allow for finer search.
Embedding: Each piece is converted into a numerical vector by an embedding model. This vector represents the semantic meaning of the text.
Vector Store: These vectors are stored in a vector database (like PGVector).

B. The Retrieval Pipeline (The Response)

This is what happens when the user asks a question:

Query Vectorization: The question is converted into a vector.
Similarity Search: Search the Vector Store for the $K$ text pieces whose vectors are closest to that of the question.
Prompt Augmentation: Build a prompt like: "Here are relevant documents: [Context]. Based solely on these documents, answer the question: [Question]".
Generation: The LLM generates the final response based on the provided evidence.

2. Technical Implementation with Spring AI

Prerequisites

JDK 17+, Spring Boot 3.x.
A Vector Store. We will use PGVector (PostgreSQL extension), the preferred choice for enterprises because it allows keeping transactional and vector data in the same place.

Step 1: Vector Store Configuration

Add the PGVector starter to your pom.xml and configure your access in application.yml:

spring:
  ai:
    vectorstore:
      pgvector:
        initialize-schema: true
        index-type: HNSW
        distance-type: COSINE_DISTANCE
        dimensions: 1536

Step 2: Document Ingestion

Here's how to load and store your knowledge:

@Service
class KnowledgeIngestionService {
    private final VectorStore vectorStore;

    public KnowledgeIngestionService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    public void ingest(Resource pdfResource) {
        TikaDocumentReader reader = new TikaDocumentReader(pdfResource);
        TokenTextSplitter splitter = new TokenTextSplitter();
        List<Document> chunks = splitter.apply(reader.get());
        vectorStore.accept(chunks);
    }
}

Step 3: Chat with Contextual Memory

Thanks to the QuestionAnswerAdvisor, Spring AI automates the entire retrieval process.

@RestController
class RagController {
    private final ChatClient chatClient;

    public RagController(ChatClient.Builder builder, VectorStore vectorStore) {
        var ragAdvisor = QuestionAnswerAdvisor.builder(vectorStore)
                .searchRequest(SearchRequest.builder().topK(4).similarityThreshold(0.7).build())
                .build();

        this.chatClient = builder
                .defaultAdvisors(ragAdvisor)
                .build();
    }

    @GetMapping("/ask")
    public String ask(@RequestParam String question) {
        return chatClient.prompt()
                .user(question)
                .call()
                .content();
    }
}

Pro Tip: If you notice the AI answering "I don't know" when the info is present, lower the similarityThreshold (e.g., 0.6). If it hallucinates too much, increase it (e.g., 0.8).

3. Analysis & Optimization: Going Further

RAG is not a "magic" solution; it requires tuning:

Confidentiality vs Fine-Tuning
Why choose RAG over fine-tuning?

Instant Updates: Add a document to the Vector Store, and the AI knows it immediately. No retraining needed.
Traceability: RAG allows citing sources ("According to document X, page 4..."), which is impossible with fine-tuning.
Security: You control exactly which document is retrieved based on the user's rights.

🏁 Conclusion & Opening

RAG transforms AI from a conversational assistant into a true business expert capable of exploiting your private data with precision and security. It is the foundation of any serious enterprise AI.

But we still have one step to go. Today, our AI answers. Tomorrow, it must act. This is where Autonomous Agents and the MCP protocol come in, which we will explore in the next article.

Your turn! Install PGVector, load your first documents, and see your Spring Boot application suddenly become very intelligent.

📚 Sources & Resources

Spring AI: Integrating Artificial Intelligence into Your Java Applications in Minutes

Adnene HAMDOUNI — Mon, 07 Sep 2026 21:12:13 +0000

Spring AI: Integrating Artificial Intelligence into Your Java Applications in Minutes

📌 Metadata

Subject: Spring Boot / AI / Java
Target: Java Developers, Software Architects
Estimated Reading Time: 8 minutes
Tags: #SpringBoot #SpringAI #Java #LLM #GenerativeAI

🎯 Introduction

For a long time, generative AI seemed to be the exclusive domain of Python. Java developers were often forced to call raw REST APIs without any real abstraction layer.

That's where Spring AI comes in.

By the end of this article, you will know how to configure your first Spring AI project and create a chat service capable of returning structured data.

🛠️ Technical Core

1. Fundamental Concept: Model Abstraction

2. Technical Implementation

Prerequisites

JDK 17 or higher.
Spring Boot 3.x.
An OpenAI API key (or Ollama installed locally).

Step 1: Project Configuration

Add the corresponding starter to your pom.xml:

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

Then, configure your API key in the application.yml file:

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4o
          temperature: 0.7

Step 2: Creating the Chat Service with ChatClient

The fluent ChatClient API is the modern way to interact with AI. Here's how to implement a simple controller:

@RestController
@RequestMapping("/ai")
class AiController {
    private final ChatClient chatClient;

    public AiController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return this.chatClient.prompt()
            .user(message)
            .call()
            .content();
    }
}

Step 3: Mastering PromptTemplates and Structured Output

To make your applications truly useful, you cannot rely on free-text messages. You need structures.

PromptTemplates allow you to inject dynamic variables:

String response = chatClient.prompt()
    .user(u -> u
        .text("Explain the concept of {concept} in two sentences for a beginner.")
        .param("concept", "Dependency Injection"))
    .call()
    .content();

Structured Output is the "killer feature" for Java devs. You can map the AI response directly into a Java record:

record Movie(String title, String director, int year) {}

@GetMapping("/movie-info")
public Movie getMovieInfo(@RequestParam String movieName) {
    return chatClient.prompt()
        .user("Give me info on the movie " + movieName)
        .call()
        .entity(Movie.class);
}

Pro Tip: Use Advisors (like MessageChatMemoryAdvisor) to natively add conversation history without having to manually manage a list of messages for every call.

3. Analysis & Comparison: Spring AI vs LangChain4j

If you explore AI in Java, you will definitely encounter LangChain4j.

Criterion	Spring AI	LangChain4j
Integration	Native and deep with Spring Boot	Standalone libraries (usable everywhere)
Learning Curve	Very low for Spring devs	Moderate (closer to LangChain Python)
Ecosystem	Benefits from the entire Spring ecosystem	Very complete on third-party integrations
Philosophy	Abstraction and simplicity	Flexibility and functional richness

Verdict: If your stack is already Spring Boot, Spring AI is the logical choice for its simplicity and alignment with your development patterns.

🏁 Conclusion & Opening

Your turn! Install Ollama locally, configure Spring AI, and try creating your first structured agent. Share your feedback in the comments!

📚 Sources & Resources

RAG avec Spring Boot : Donnez une mémoire contextuelle et privée à votre IA

Adnene HAMDOUNI — Mon, 07 Sep 2026 20:46:18 +0000

RAG avec Spring Boot : Donnez une mémoire contextuelle et privée à votre IA

📌 Métadonnées

Titre : RAG avec Spring Boot : Donnez une mémoire contextuelle et privée à votre IA
Sujet : RAG / Vector Databases / Spring AI / Java
Cible : Développeurs Java, Architectes Data/IA
Temps de lecture estimé : 10 minutes
Tags : #SpringBoot #SpringAI #RAG #VectorDatabase #JavaAI

🎯 Introduction

L'un des plus grands défis de l'IA générative en entreprise est le phénomène des hallucinations. Un LLM, aussi puissant soit-il, peut inventer des faits avec une assurance déconcertante, surtout lorsqu'il s'agit de données récentes ou de documents internes confidentiels qu'il n'a jamais "vus" lors de son entraînement.

Imaginez demander à votre IA : "Quelle est la procédure de remboursement pour le client X ?". Si l'IA n'a pas accès à vos contrats, elle fera une supposition basée sur des probabilités statistiques. C'est ici que le RAG (Retrieval Augmented Generation) change la donne.

Le RAG ne cherche pas à réentraîner le modèle (ce qui serait coûteux et lent). Au lieu de cela, il transforme l'IA en un chercheur ultra-rapide : avant de répondre, l'IA va fouiller dans vos documents privés, extraire les passages pertinents, et utiliser ces informations comme base pour formuler sa réponse. C'est ce qu'on appelle la génération groundée.

À la fin de cet article, vous comprendrez comment orchestrer ce flux avec Spring AI et mettre en place une architecture de mémoire contextuelle robuste.

🛠️ Corps de l'Article

1. Le Pipeline RAG décomposé : Comprendre le flux

Pour implémenter le RAG, il faut concevoir deux pipelines distincts : un pour l'ingestion et un pour la récupération.

A. Le Pipeline d'Ingestion (Le stockage du savoir)

C'est l'étape où vos documents deviennent "lisibles" pour l'IA :

Document Reading : On charge les fichiers (PDF, Markdown, HTML) via des DocumentReader.
Chunking : On découpe le texte en morceaux (chunks). Pourquoi ? Parce que les LLM ont une fenêtre de contexte limitée et que des morceaux précis permettent une recherche plus fine.
Embedding : Chaque morceau est converti en un vecteur numérique (une liste de nombres) par un modèle d'embedding. Ce vecteur représente le sens sémantique du texte.
Vector Store : Ces vecteurs sont stockés dans une base de données vectorielle (comme PGVector).

B. Le Pipeline de Récupération (La réponse)

C'est ce qui se passe quand l'utilisateur pose une question :

Vectorisation de la requête : La question est convertie en vecteur.
Recherche de similarité : On cherche dans le Vector Store les $K$ morceaux de texte dont les vecteurs sont les plus proches de celui de la question.
Augmentation du Prompt : On construit un prompt du type : "Voici des documents pertinents : [Contexte]. En t'appuyant uniquement sur ces documents, réponds à la question : [Question]".
Génération : Le LLM génère la réponse finale basée sur les preuves fournies.

2. Mise en œuvre Technique avec Spring AI

Pré-requis

JDK 17+, Spring Boot 3.x.
Un Vector Store. Nous utiliserons PGVector (extension de PostgreSQL), le choix privilégié pour les entreprises car il permet de garder les données transactionnelles et vectorielles au même endroit.

Étape 1 : Configuration du Vector Store

Ajoutez le starter PGVector à votre pom.xml et configurez vos accès dans application.yml :

spring:
  ai:
    vectorstore:
      pgvector:
        initialize-schema: true
        index-type: HNSW # Optimisation pour la recherche rapide
        distance-type: COSINE_DISTANCE
        dimensions: 1536 # Pour OpenAI text-embedding-3-small

Étape 2 : L'ingestion des documents

Voici comment charger et stocker vos connaissances :

@Service
class KnowledgeIngestionService {
    private final VectorStore vectorStore;

    public KnowledgeIngestionService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    public void ingest(Resource pdfResource) {
        // 1. Lecture du PDF
        TikaDocumentReader reader = new TikaDocumentReader(pdfResource);

        // 2. Découpage en chunks
        TokenTextSplitter splitter = new TokenTextSplitter();
        List<Document> chunks = splitter.apply(reader.get());

        // 3. Stockage (Embedding + Save)
        vectorStore.accept(chunks);
    }
}

Étape 3 : Le Chat avec mémoire contextuelle

Grâce au QuestionAnswerAdvisor, Spring AI automatise tout le processus de récupération.

@RestController
class RagController {
    private final ChatClient chatClient;

    public RagController(ChatClient.Builder builder, VectorStore vectorStore) {
        // On configure l'Advisor pour le RAG
        var ragAdvisor = QuestionAnswerAdvisor.builder(vectorStore)
                .searchRequest(SearchRequest.builder().topK(4).similarityThreshold(0.7).build())
                .build();

        this.chatClient = builder
                .defaultAdvisors(ragAdvisor)
                .build();
    }

    @GetMapping("/ask")
    public String ask(@RequestParam String question) {
        return chatClient.prompt()
                .user(question)
                .call()
                .content();
    }
}

Astuce de pro : Si vous constatez que l'IA répond "Je ne sais pas" alors que l'info est présente, baissez le similarityThreshold (ex: 0.6). Si elle hallucine trop, augmentez-le (ex: 0.8).

3. Analyse & Optimisation : Aller plus loin

Le RAG n'est pas une solution "magique", il demande du réglage :

Le défi du Chunking
La taille des morceaux est cruciale. Des morceaux trop petits perdent le contexte global. Des morceaux trop grands introduisent du bruit. Une stratégie courante est le "Overlapping" : faire chevaucher les chunks pour ne pas couper une phrase importante en deux.

Embeddings : Le moteur de la recherche
Le choix du modèle d'embedding (ex: text-embedding-3-small vs un modèle local via HuggingFace) impacte directement la précision. Un bon modèle d'embedding comprend que "voiture" et "automobile" sont sémantiquement proches.

Confidentialité vs Fine-Tuning
Pourquoi choisir le RAG plutôt que le fine-tuning ?

Mise à jour instantanée : Ajoutez un document au Vector Store, et l'IA le connaît immédiatement. Pas besoin de réentraîner.
Traçabilité : Le RAG permet de citer ses sources ("Selon le document X, page 4..."), ce qui est impossible avec le fine-tuning.
Sécurité : Vous contrôlez exactement quel document est récupéré selon les droits de l'utilisateur.

🏁 Conclusion & Ouverture

Le RAG transforme l'IA d'un assistant conversationnel en un véritable expert métier capable d'exploiter vos données privées avec précision et sécurité. C'est la fondation de toute application d'IA sérieuse en entreprise.

Mais nous avons encore un pas à franchir. Aujourd'hui, notre IA répond. Demain, elle doit agir. C'est là qu'interviennent les Agents Autonomes et le protocole MCP, que nous explorerons dans le prochain article.

À vous de jouer ! Installez PGVector, chargez vos premiers documents et voyez votre application Spring Boot devenir soudainement très intelligente.

📚 Sources & Ressources

Spring AI : Intégrez l'Intelligence Artificielle dans vos applications Java en quelques minutes

Adnene HAMDOUNI — Mon, 07 Sep 2026 20:46:17 +0000

Spring AI : Intégrez l'Intelligence Artificielle dans vos applications Java en quelques minutes

📌 Métadonnées

Titre : Spring AI : Intégrez l'Intelligence Artificielle dans vos applications Java en quelques minutes
Sujet : Spring Boot / AI / Java
Cible : Développeurs Java, Architectes Logiciels
Temps de lecture estimé : 8 minutes
Tags : #SpringBoot #SpringAI #Java #LLM #GenerativeAI

🎯 Introduction

Pendant longtemps, le monde de l'IA générative a semblé être le domaine exclusif de Python. Entre LangChain, PyTorch et la simplicité des notebooks Jupyter, les développeurs Java se sentaient souvent comme des citoyens de seconde zone, contraints d'appeler des API REST brutes ou de jongler avec des bibliothèques peu matures.

C'est ici qu'intervient Spring AI.

Ce nouveau projet de l'écosystème Spring ne se contente pas d'ajouter un client HTTP pour OpenAI. Il apporte une véritable couche d'abstraction, similaire à ce que Spring Data a fait pour les bases de données. L'idée est simple : vous écrivez votre logique métier une seule fois, et vous pouvez changer de modèle d'IA (GPT-4, Claude, Mistral ou même un modèle local via Ollama) sans modifier une seule ligne de code métier.

À la fin de cet article, vous saurez comment configurer votre premier projet Spring AI et créer un service de chat intelligent capable de retourner des données structurées.

🛠️ Corps de l'Article

1. Concept Fondamental : L'Abstraction du Modèle

Le cœur de Spring AI réside dans l'interface ChatModel. Plutôt que de vous lier à un SDK spécifique, Spring AI définit un contrat standard pour l'interaction avec les LLM.

Pourquoi est-ce crucial ?
Dans un environnement entreprise, la dépendance à un seul fournisseur d'IA est un risque. Un jour, vous pourriez préférer Azure OpenAI pour la conformité, ou un modèle Llama 3 hébergé localement pour la confidentialité des données. Grâce à l'injection de dépendances de Spring, le passage d'un modèle à un autre se résume à un changement de dépendance dans votre pom.xml et une clé API dans vos propriétés.

2. Mise en Œuvre Technique (Le "Comment")

Pré-requis

JDK 17 ou supérieur.
Spring Boot 3.x.
Une clé API OpenAI (ou Ollama installé localement).

Étape 1 : Configuration du projet

Ajoutez le starter correspondant à votre fournisseur dans votre fichier pom.xml :

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

Ensuite, configurez votre clé API dans le fichier application.yml :

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-4o
          temperature: 0.7

Étape 2 : Création du service de Chat avec ChatClient

L'API fluide ChatClient est la manière moderne d'interagir avec l'IA. Voici comment implémenter un contrôleur simple :

@RestController
@RequestMapping("/ai")
class AiController {
    private final ChatClient chatClient;

    // Le Builder est auto-configuré par Spring Boot
    public AiController(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return this.chatClient.prompt()
            .user(message)
            .call()
            .content();
    }
}

Étape 3 : Maîtriser les PromptTemplates et la Sortie Structurée

Pour rendre vos applications réellement utiles, vous ne pouvez pas vous contenter de messages libres. Vous avez besoin de structures.

Les PromptTemplates permettent d'injecter des variables dynamiques :

String response = chatClient.prompt()
    .user(u -> u
        .text("Explique-moi le concept de {concept} en deux phrases pour un débutant.")
        .param("concept", "Injection de dépendances"))
    .call()
    .content();

La Sortie Structurée est la fonctionnalité "tueuse" pour les devs Java. Vous pouvez mapper la réponse de l'IA directement dans un record Java :

record Movie(String title, String director, int year) {}

@GetMapping("/movie-info")
public Movie getMovieInfo(@RequestParam String movieName) {
    return chatClient.prompt()
        .user("Donne moi des infos sur le film " + movieName)
        .call()
        .entity(Movie.class); // Mapping automatique JSON -> Java Record
}

Astuce de pro : Utilisez les Advisors (comme MessageChatMemoryAdvisor) pour ajouter nativement un historique de conversation sans avoir à gérer manuellement une liste de messages à chaque appel.

3. Analyse & Comparaison : Spring AI vs LangChain4j

Si vous explorez l'IA en Java, vous croiserez forcément LangChain4j.

Critère	Spring AI	LangChain4j
Intégration	Native et profonde avec Spring Boot	Bibliothèques autonomes (utilisables partout)
Courbe d'apprentissage	Très faible pour les devs Spring	Modérée (approche plus proche de LangChain Python)
Écosystème	Bénéficie de tout l'écosystème Spring	Très complet sur les intégrations tierces
Philosophie	Abstraction et simplicité	Flexibilité et richesse fonctionnelle

Verdict : Si votre stack est déjà Spring Boot, Spring AI est le choix logique pour sa simplicité et son alignement avec vos patterns de développement.

🏁 Conclusion & Ouverture

L'IA n'est plus une "option" ou un gadget pour les data scientists ; c'est désormais un premier citoyen dans l'écosystème Java. Avec Spring AI, la barrière technique s'effondre pour laisser place à l'innovation métier.

Mais un LLM seul a une limite : il ne connaît pas vos données privées. C'est là qu'intervient le RAG (Retrieval Augmented Generation). Dans le prochain article, nous verrons comment donner une "mémoire" à votre application Spring Boot en connectant un Vector Store.

À vous de jouer ! Installez Ollama en local, configurez Spring AI et essayez de créer votre premier agent structuré. Partagez vos retours en commentaires !