Guide

Pinecone : une base vectorielle pour la recherche sémantique et le RAG

Pinecone stocke des embeddings et retrouve les vecteurs proches d'une requête. Modèle de facturation, namespaces, reranking, recherche hybride et alternatives.

L'équipe CodeWorlds14 min de lecture ·

Pratique Python dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article11

Pinecone stocke des embeddings et retrouve les vecteurs les plus proches d'une requête. Vous ne provisionnez aucun serveur, ne choisissez aucun type d'index et ne vous souciez d'aucun réplica, car le service tourne en mode serverless et vous payez les lectures, les écritures et le stockage. Cela simplifie le démarrage et complique la prévision de la facture.

Pourquoi une base distincte pour les vecteurs

La recherche par mots-clés trouve un document qui contient une expression, mais rate celui qui dit la même chose avec d'autres mots. Un embedding transforme un texte en un vecteur de nombres, et la distance entre vecteurs reflète la proximité de sens. Une question sur le retour de marchandises tombe alors sur un paragraphe consacré à la rétractation d'un contrat, bien qu'ils n'aient aucun mot en commun.

On recourt à une base vectorielle quand ces vecteurs sont nombreux et que les réponses doivent arriver en quelques dizaines de millisecondes. À dix mille chunks, pgvector sur le Postgres que vous exploitez déjà suffit. À plusieurs millions, avec une exigence de temps de réponse stable, un service spécialisé prend l'avantage, car l'indexation et la mise à l'échelle des lectures sont tout son métier.

Il faut comprendre qu'une base vectorielle ne résout pas la qualité à elle seule. Son travail consiste uniquement à trouver rapidement les vecteurs les plus proches d'une requête. Que ces vecteurs représentent des chunks sensés dépend de la façon dont les documents ont été découpés et du modèle d'embedding, c'est-à-dire de décisions prises plus tôt. Changer de base quand les résultats sont mauvais ne change généralement rien, car le problème se situe une étape en amont.

La deuxième raison est la division du travail. Une équipe qui ne veut pas maintenir une base de plus avec des sauvegardes et des mises à jour achète le service et paie pour être débarrassée de cette responsabilité.

Le modèle de facturation et ses unités

La facture comporte trois composantes plutôt qu'un prix par instance.

ÉlémentTarifRemarques
Offre Starter0 USD2 Go de stockage, 2 M d'unités d'écriture, 1 M d'unités de lecture par mois
Offre Standard50 USD par mois au minimumFacturation minimale quelle que soit l'utilisation
Stockage0,33 USD par Go et par moisMesuré sur la taille des vecteurs, métadonnées comprises
Unités d'écriture4 à 4,50 USD par millionLe tarif dépend du cloud et de la région ; un upsert coûte généralement plusieurs unités
Unités de lecture16 à 18 USD par millionLe tarif dépend du cloud et de la région ; une seule requête peut coûter de 1 à 10 unités

La surprise la plus courante concerne les unités de lecture. Une requête sans filtre sur un petit jeu de données consomme une unité, mais la même requête avec un filtrage sur les métadonnées sur un gros index en coûte plusieurs ou une dizaine. La facture croît donc non pas avec le nombre d'utilisateurs mais avec la précision de votre filtrage.

Les écritures se comportent de façon similaire. Ajouter un vecteur de 1536 dimensions avec ses métadonnées coûte généralement trois à quatre unités, et non une. Charger un million de chunks d'un coup représente donc un vrai coût qu'il vaut la peine de calculer avant de lancer l'import.

Votre premier index

Bash
pip install pinecone
Python
from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])

pc.create_index(
    name="documentation",
    dimension=1536,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1")
)

index = pc.Index("documentation")

Le nombre de dimensions doit correspondre à votre modèle d'embedding et ne peut pas être modifié ensuite. Le modèle text-embedding-3-small d'OpenAI produit 1536 dimensions, tandis que des modèles ouverts plus petits en produisent souvent 384. Cette différence se traduit directement sur le coût de stockage, car un vecteur de 1536 dimensions occupe quatre fois plus de place qu'un vecteur de 384 pour le même nombre de chunks.

L'écriture et la recherche tiennent en quelques lignes.

Python
index.upsert(
    vectors=[
        {
            "id": "terms-4",
            "values": embedding,
            "metadata": {"section": "returns", "language": "en", "version": 3}
        }
    ],
    namespace="production"
)

results = index.query(
    vector=query_embedding,
    top_k=4,
    include_metadata=True,
    filter={"language": "en", "version": {"$gte": 3}},
    namespace="production"
)

Vous attribuez vous-même les identifiants des vecteurs, et ils devraient découler de l'origine du chunk, par exemple un identifiant de document plus un numéro de partie. Retraiter un document écrase alors les anciens vecteurs au lieu de créer des doublons.

Namespaces et multi-tenance

Un namespace découpe un index en espaces disjoints. Une requête vise toujours l'un d'eux : les données de clients différents ne se mélangent donc jamais, même si un filtre est erroné.

C'est mieux que la multi-tenance par un champ de métadonnées contenant l'identifiant du client. Un filtre peut être oublié par accident, alors qu'un namespace doit être nommé délibérément. Les opérations sur les namespaces n'entraînent aucun frais supplémentaire.

Attention cependant au nombre d'index. De nombreux petits index se comportent moins bien qu'un seul index plus grand découpé en namespaces, car chaque index a son propre surcoût. La règle est un index par modèle d'embedding, avec un namespace par client ou par environnement.

Pour retirer un client du système, supprimer un namespace entier est une seule opération, ce qui compte quand une demande de suppression arrive.

Les namespaces aident aussi quand vous changez la façon de traiter les documents. Au lieu d'écraser les données de production, vous écrivez la nouvelle version à côté, vous comparez les résultats sur le même jeu de questions et vous ne basculez l'application qu'une fois que tout est validé. L'ancien namespace reste comme solution de repli, et le supprimer une semaine plus tard est un seul appel. Le même mécanisme couvre le versionnage du modèle d'embedding, à condition que les dimensions correspondent.

Embeddings intégrés et reranking

Pinecone peut calculer lui-même les embeddings : vous envoyez du texte au lieu de vecteurs. Cela supprime une étape du pipeline et une dépendance, au prix de vous lier aux modèles que propose l'éditeur.

L'élément le plus intéressant est le reranking. La recherche vectorielle renvoie rapidement des candidats, mais leur ordre peut être imprécis, surtout quand la requête contient des noms propres ou des numéros de version. Un modèle de reranking prend vingt candidats et les réordonne en regardant le texte complet plutôt que le seul vecteur.

En pratique, cela donne : récupérer vingt résultats, les passer par le reranking, remettre les quatre meilleurs au modèle. La qualité des réponses dans un système RAG s'améliore plus visiblement après cette étape qu'après avoir remplacé le modèle de langage par un plus grand, pour une fraction du coût.

Recherche hybride

La seule similarité sémantique rate les requêtes précises. Une question sur l'erreur ERR_2041 ou sur la version 3.2.1 trouvera des chunks sur un sujet voisin, pas forcément celui qui porte ce numéro exact.

La solution combine les vecteurs avec la recherche par mots-clés. Pinecone prend en charge les vecteurs creux (sparse) en plus des vecteurs denses : une seule requête fusionne donc les deux signaux. L'alternative est d'interroger un magasin full text en parallèle et de fusionner les résultats dans l'application.

Un contournement moins coûteux est de détecter le motif dans la requête. Si l'utilisateur a saisi quelque chose qui ressemble à un code d'erreur ou à un numéro de version, interrogez d'abord votre propre base par une simple recherche et traitez la recherche vectorielle comme un complément. Pour beaucoup de produits, cela règle la plupart des cas sans ajouter une couche de plus.

Testez-le sur vos propres données avant de considérer le sujet comme réglé. Un jeu de vingt requêtes que les utilisateurs saisissent réellement, associées au document que chacune devrait renvoyer, révèle la différence entre configurations mieux que n'importe quel benchmark.

Comment mesurer la qualité de la recherche

L'erreur la plus courante dans les projets RAG est de juger tout le système d'après la réponse du modèle. Quand une réponse est fausse, on accuse le modèle, alors que dans la plupart des cas c'est la récupération qui a échoué et le modèle n'a simplement jamais reçu le bon chunk.

Séparez ces deux couches par une mesure. Collectez trente vraies questions et, pour chacune, marquez à la main le chunk qui devrait apparaître dans les résultats. Suivez ensuite un seul chiffre : dans quelle proportion de requêtes le bon chunk s'est retrouvé parmi les quatre premiers.

Python
def hit_rate(dataset, k=4):
    hits = 0
    for question, expected_id in dataset:
        result = index.query(vector=embed(question), top_k=k, namespace="production")
        if expected_id in [d["id"] for d in result["matches"]]:
            hits += 1
    return hits / len(dataset)

Ce seul chiffre en dit plus que l'intuition. En dessous de soixante-dix pour cent, inutile de régler le prompt, car le problème se situe dans les données ou dans le découpage des documents. Au-dessus de quatre-vingt-dix, d'autres changements de récupération rapportent de moins en moins, et la marge d'amélioration se déplace vers l'instruction donnée au modèle.

Constituez le jeu de questions à partir de vrais journaux plutôt que de l'inventer à un bureau. Les questions écrites par l'auteur du système font écho à la documentation indexée : elles correspondent donc trop facilement et gonflent le score.

Mesurez de nouveau à chaque changement de découpage. Passer de chunks de 400 caractères à 800 peut augmenter le taux de réussite d'une douzaine de points ou le baisser, selon le type de document, et sans mesure cela reste une affaire de croyance.

Suivez la latence séparément. Le temps de réponse de l'index tend à être stable, mais le total augmente avec l'embedding de la requête et le reranking. Mesurez les trois segments individuellement avant de commencer à optimiser le mauvais.

Ce que ça coûte vraiment

Prenons une base de connaissances typique : cent mille chunks de 1536 dimensions, dix mille requêtes par mois.

Le stockage représente environ 0,6 Go de vecteurs avec métadonnées, donc moins d'un dollar. Un import ponctuel de cent mille vecteurs à quatre unités d'écriture chacun fait 400 mille unités, moins de deux dollars. Dix mille requêtes à cinq unités de lecture chacune font 50 mille unités, environ un dollar.

L'utilisation totalise quelques dollars, mais sur l'offre Standard vous payez quand même le minimum mensuel de 50 USD. La conclusion pratique : à petite échelle, vous payez surtout le confort plutôt que les ressources. Le seuil de rentabilité face à pgvector sur le Postgres que vous exploitez déjà se situe autour du million de vecteurs, ou là où apparaît une exigence stricte de latence.

Pinecone face aux alternatives

SolutionPoint fortPoint faibleÀ choisir quand
PineconeAucune maintenance, latence stable à grande échelleFacturation minimale, coût difficile à prévoirMillions de vecteurs, aucun temps d'équipe pour l'infrastructure
pgvectorUne seule base pour tout, transactions à côté des donnéesDemande de régler l'index sur de gros jeux de donnéesJusqu'à un million de vecteurs, données déjà dans Postgres
QdrantOpen source, filtrage puissant, option auto-hébergéeLa maintenance vous incombeDonnées sensibles, besoin de contrôle total
WeaviateModules intégrés, recherche hybrideConfiguration plus élaboréeScénarios de recherche complexes

La région compte aussi. Un index en Virginie répond à une application à Francfort avec bien une centaine de millisecondes de retard avant même d'avoir calculé quoi que ce soit. Avec trois appels par question d'utilisateur, cela devient une différence perceptible dans l'interface.

Migrer entre ces solutions n'est pas coûteux, car les vecteurs se déplacent tant que vous gardez le même modèle d'embedding. Changer de modèle coûte beaucoup plus cher, car il faut recalculer tout le jeu de données.

Avant d'ajouter une base distincte à la pile, vérifiez toutefois si quelque chose que vous exploitez déjà peut la porter. Elasticsearch gère les vecteurs à côté de la recherche full text, ce qui vous donne un hybride sans service de plus, et Atlas Vector Search fait de même au sein de la base documentaire que votre application interroge déjà. Une base vectorielle dédiée l'emporte par l'échelle et la qualité de récupération, pas par principe.

Dans l'autre sens, le problème n'est parfois pas du tout la similarité sémantique mais une simple recherche de noms avec tolérance aux fautes. Meilisearch le fait en quelques dizaines de millisecondes et ajoute la recherche hybride par-dessus, couvrant les deux cas à la fois. Le cœur est sous MIT, mais les modules destinés aux déploiements plus importants relèvent de la Business Source License, à vérifier séparément quand on planifie un déploiement commercial.

Dans la même niche se trouve Typesense, qui se distingue en ajoutant le clustering et la réplication qui manquent aux options les plus simples. La licence demande toutefois de l'attention : le moteur est sous GPL version trois plutôt que sous une licence permissive. L'exécuter comme un service sur le réseau ne change rien, mais distribuer le binaire avec votre propre produit, par exemple dans une image de conteneur remise à un client, a de vraies conséquences.

Erreurs fréquentes

La première est de déverser le texte complet des documents dans les métadonnées. Les métadonnées comptent dans la taille de l'index et augmentent le coût de stockage, alors qu'il vous faut généralement seulement un identifiant pour récupérer le texte dans votre propre base.

La deuxième est de n'avoir aucune stratégie de mise à jour. Un document modifié un mois plus tard laisse des chunks périmés dans l'index quand les identifiants sont aléatoires. Résultat : le modèle reçoit deux versions contradictoires de la même clause.

La troisième est de régler top_k à cinquante en espérant de meilleurs résultats. Plus de candidats signifie plus d'unités de lecture et un prompt plus long, alors que la qualité ne s'améliore que jusqu'à un certain point. Récupérer vingt résultats et les reranker fonctionne mieux.

La quatrième est de ne pas avoir d'environnement de test. Un namespace distinct pour les données de travail ne coûte presque rien et vous permet de tester un changement de découpage sans perturber les résultats de production.

La cinquième est d'ignorer les limites de débit pendant l'import. Charger par énormes lots sans cadence se termine par des erreurs qui laissent une partie des données non écrite, généralement sans message clair dans le journal de l'application.

FAQ

Pinecone a-t-il une offre gratuite ?

Oui, l'offre Starter donne 2 Go de stockage, deux millions d'unités d'écriture et un million d'unités de lecture par mois, sans carte et sans minimum. Cela couvre un prototype et une base de connaissances modeste. L'offre Standard commence à 50 USD par mois en facturation minimale.

Quand choisir pgvector plutôt que Pinecone ?

Quand les données vivent déjà dans Postgres, que le jeu de données reste autour du million de vecteurs et que vous acceptez de régler l'index. Vous évitez alors un service distinct et vous combinez la recherche vectorielle avec des filtres SQL dans une seule requête. Au-delà de cette échelle, la maintenance commence à coûter plus que l'abonnement.

Puis-je changer le nombre de dimensions d'un index existant ?

Non. Les dimensions sont fixées à la création de l'index et liées au modèle d'embedding. Changer de modèle signifie un nouvel index et un recalcul de tout le jeu de données : le choix initial du modèle est donc une décision à long terme.

Comment intégrer Pinecone à une application Next.js ?

Faites tous les appels depuis le serveur, car la clé d'API ne doit jamais atteindre le navigateur. En pratique, vous construisez une route d'API qui calcule l'embedding de la requête, interroge l'index et renvoie les chunks. LangChain propose aussi des intégrations si vous assemblez un pipeline RAG complet.

Pinecone stocke-t-il le texte d'origine ?

Il stocke les vecteurs et les métadonnées que vous lui envoyez. Gardez le contenu d'origine dans votre propre base et ne mettez dans les métadonnées qu'un identifiant plus les champs nécessaires au filtrage. Cet arrangement est moins cher et facilite la suppression de données sur demande.

Les règles de facturation sont décrites dans la documentation des coûts, et les tarifs sur pinecone.io.

À lire aussi