Accueil / Articles

Réclassement dans RAG avec Spring AI et Pinecone : Déplacement d’une réponse de la 4e à la 1re place

Réclassement dans RAG avec Spring AI et Pinecone : recherche vectorielle simple versus étape de réclassement bge sur un manuel de RH, où une réponse auparavant peu visible passe de la 4e à la 1re place.

Éditeur : REACTAPP.TOP6 min de lecture1306 mots

Sources: Reranking in RAG: The Spring AI and Pinecone Implementation

En saisissant une question dans un outil de recherche d’entreprise, cinq résultats apparaissent. Tous semblent liés, mais celui qui répond réellement à la question se trouve en troisième position, derrière deux paragraphes ne partageant que quelques mots en commun. La recherche a compris ce qui a été dit, mais pas tout à fait ce qui était voulu. Cet écart entre sembler pertinent et l’être réellement est la raison d’existence du réclassement : la recherche vectorielle trouve du texte qui sonne similaire, mais pas nécessairement du texte qui répond.

Ce qui suit transforme cette idée en code fonctionnel. Deux méthodes de recherche analysent le même document côte à côte, permettant ainsi d’observer les différences plutôt que de se fier aveuglément aux résultats. Et ces différences s’avèrent plus importantes que prévu.

L’expérience

Le test est délibérément conçu autour d’une réponse cachée. Un véritable manuel de RH est divisé en petits fragments, et une question est posée dont la réponse se trouve dans une section que personne ne devinerait en premier. La réponse est ensuite recherchée de deux manières : la première consiste à chercher des fragments dont le contenu ressemble à celui de la question, tandis que la seconde prend ces mêmes fragments, les évalue correctement et propose un nouvel ordre en fonction de ceux qui répondent le mieux. Le but principal est de constater que ces deux ordres diffèrent pour la même question.

Stack et prérequis

La compilation s’effectue sous Java 21 avec Spring Boot 3.5.14 et Spring AI 1.0.8. Les embeddings proviennent de text-embedding-3-small d’OpenAI. Pinecone remplit à la fois la fonction de stockage vectoriel et celle d’API de réévaluation, et le modèle de réévaluation est bge-reranker-v2-m3.

Pourquoi utiliser Pinecone également pour le reranking ? Le VectorStore de Spring AI ne prend pas en compte le reranking, ce qui en fait le seul élément qui sort de cette abstraction pour appeler le SDK Java brut de Pinecone afin d’exécuter une seule opération de reranking.

Il faut d’abord disposer de trois éléments. Le premier est un compte Pinecone contenant un index dont la dimension est de 1536, correspondant à la sortie du modèle d’embedding. Le deuxième est une clé API d’OpenAI permettant de générer des embeddings. Le troisième est Gradle, utilisé pour gérer les dépendances.

Préparation du manuel

La recherche nécessite d’abord des données, donc le manuel doit être divisé en parties et chargé dans Pinecone. Une seule interface /ingest s’en charge : le fichier est lu, divisé en blocs de 300 tokens et stocké sous forme de vecteurs, et un mécanisme de détection des doublons empêche que des exécutions répétées ne réinsèrent tout à nouveau. Le fichier se trouve à l’adresse src/main/resources/docs/abc_company_employee_handbook.txt. Une lecture rapide à l’avance s’avère utile, en particulier la section consacrée au télétravail, qui contient l’une des réponses les plus difficiles.

Deux interfaces

La même question est traitée via deux interfaces qui semblent presque identiques de l’extérieur :

GET /api/search/without-reranking?query=your question here
GET /api/search/with-reranking?query=your question here

Le premier est la méthode de base honnête. Il interroge la base de données vectorielle, sélectionne les correspondances les plus proches et les renvoie dans l’ordre reçu, sans aucune autre analyse. Le second fait tout ce que fait le premier, mais ajoute une étape avant de renvoyer les résultats : il transmet les mêmes fragments à un modèle de réclassement pour déterminer lesquels répondent réellement à la question. Les fragments sont alors renvoyés réordonnés en fonction de ce jugement.

Les deux méthodes renvoient la même structure de réponse. Seule l’ordre diffère, et c’est justement cet ordre qui est important. Le travail intéressant a lieu un niveau en dessous du contrôleur, dans RetrievalService.

Voie 1 : recherche de similarité simple

La simplicité est ici l’objectif : interroger la base de données vectorielle pour obtenir ses fragments les plus proches, les accepter tels qu’ils sont renvoyés et en rester là. Aucun autre traitement n’a lieu. Une méthode gère la récupération des données :

private List<Document> retrieveTopK(String query) {
    return handbookVectorStore.similaritySearch(
        SearchRequest.builder().query(query).topK(topK).build());
}

Dans la configuration, topK vaut 5, ce qui signifie que les cinq fragments les plus proches en termes de similarité cosinus sont sélectionnés. C’est là toute la procédure de récupération. Chaque fragment est accompagné de son propre score de similarité fourni par le stockage vectoriel, indiquant à quel point son sens est proche de celui de la requête.

C’est justement au niveau du sens que les problèmes surviennent. Un passage peut se trouver très proche d’une question sans pour autant y répondre. Les détails relatifs aux congés maladie sont intégrés à la politique de travail à domicile, de sorte que le texte environnant semble correspondre parfaitement, et la recherche par similarité classe les résultats uniquement en fonction de cette proximité. On ne vérifie jamais si le texte répond réellement à la question. Le résultat est une liste restreinte convenable, sans aucune indication sur quel élément constitue la vraie réponse, tandis que la deuxième approche ajoute cette évaluation.

Voie 2 : ajout d’une étape de réclassification

Le but maintenant est de déterminer quels fragments répondent réellement à la question. Le processus commence de la même manière, en effectuant la même recherche et en récupérant les mêmes fragments :

List<Document> hits = retrieveTopK(query);

Ces cinq fragments identiques sont ceux que le premier point de terminaison a utilisés, réutilisés délibérément. Une recherche différente ne permettrait aucune base fiable pour comparer les deux résultats.

Vient ensuite le réclassement lui-même. Spring AI ne peut pas aider, car son stockage vectoriel ne sait pas ce qu’est le réclassement ; par conséquent, le code appelle directement le modèle hébergé par Pinecone :

return pinecone.getInferenceClient().rerank(
    rerankModel,          // bge-reranker-v2-m3
    query,
    documents,            // the same five chunks
    List.of("content"),   // the text to judge
    topN,                 // keep the best 3
    true,
    Map.of("truncate", "END"));

C’est une demande réelle adressée à un modèle hébergé, et non une solution rapide effectuée localement. Le réordonneur lit la question ainsi que chaque fragment et évalue dans quelle mesure ce fragment répond correctement. En revanche, la recherche par similarité compare des vecteurs calculés à l’avance et ne lit jamais les deux textes côte à côte.

Imaginez que l’on donne au réordonneur cinq paragraphes et que l’on demande les trois meilleurs. Au lieu de renvoyer du texte, il répond par des positions, par exemple le numéro 4 en premier, puis 1, puis 5, indiquant ainsi les fragments par leur emplacement dans la ligne. La dernière étape transforme ces positions en fragments réels. Lorsque le modèle indique le numéro 4, le code retourne à la liste originale, prend le quatrième fragment et extrait son texte ainsi que sa note.

Document original = hits.get(ranked.getIndex());
results.add(toChunkResult(original, ranked.getScore().doubleValue()));

Une modification subtile : le score affiché est désormais le score de réclassement, qui indique dans quelle mesure le fragment répond à la question, et non plus le score de similarité précédent. Il s’agit du même fragment, mais le chiffre à côté en signifie un tout autre. C’est ce changement de sens qui constitue l’idée principale.

Voir la différence

Testez une question avec les deux systèmes et consultez la console. La question choisie cache bien sa réponse : que faire en cas de maladie lorsqu’on travaille à domicile ?

Au sein de la recherche classique, cinq fragments s’affichent par ordre de similarité avec leurs scores respectifs. Le fragment qui répond réellement, l’index 6, se retrouve à la position 4 avec seulement 37,5 %. Trois fragments devant lui abordent le télétravail ou les congés maladie en général et obtiennent de meilleurs scores car ils partagent davantage de vocabulaire avec la requête. La vraie réponse figure parmi les résultats les moins pertinents, bien qu’elle soit la seule complète.

Au niveau de l’endpoint réévalué, les mêmes cinq fragments sont pris en compte et le modèle évalue chacun d’eux pour déterminer s’il répond à la question. La sortie inclut une bande de pertinence ainsi qu’une note concernant l’évolution du classement. Le fragment correspondant à la réponse passe de la quatrième à la première place avec une pertinence de 95,6 % et le label « Correspondance excellente », tandis que les fragments similaires descendent à « Correspondance faible » avec des scores de 20,4 % et 6,2 %. Un autre détail se distingue : l’index 5, qui était en tête du classement de similarité, n’a pas réussi à figurer parmi les trois meilleurs après réévaluation. La similarité le favorisait, mais la pertinence l’a éliminé.

Le point clé

La recherche vectorielle permet d’obtenir une réponse approximative, et le réclassement permet de la sélectionner définitivement. Le fait de transmettre la liste restreinte à un modèle qui lit la question ainsi que chaque fragment en tant que paire détermine souvent si l’utilisateur fait confiance à ce qu’il voit ou continue de scroller. La démonstration effectuée sur des documents privés montre le même effet avec des données réelles, où les fragments se déplacent en haut ou en bas du classement.