Pinecone pour le RAG de Production à Grande Échelle

Pourquoi Pinecone ?

• Entièrement géré (pas d'ops)
• Mise à l'échelle jusqu'à des milliards de vecteurs
• Latence p95 de 50ms
• Recherche hybride intégrée
• Conforme SOC 2

Configuration (Novembre 2025)

DEVELOPERpython
from pinecone import Pinecone

pc = Pinecone(api_key="YOUR_API_KEY")

# Créer un index
pc.create_index(
    name="rag-production",
    dimension=1536,  # OpenAI text-embedding-3-small
    metric="cosine",
    spec=ServerlessSpec(
        cloud="aws",
        region="us-east-1"
    )
)

index = pc.Index("rag-production")

Insertion de Documents

DEVELOPERpython
from openai import OpenAI

client = OpenAI()

def upsert_documents(documents):
    vectors = []

    for i, doc in enumerate(documents):
        # Générer l'embedding
        embedding = client.embeddings.create(
            model="text-embedding-3-small",
            input=doc['text']
        ).data[0].embedding

        vectors.append({
            "id": f"doc_{i}",
            "values": embedding,
            "metadata": {
                "text": doc['text'],
                "source": doc['source'],
                "date": doc['date']
            }
        })

    # Insertion par lots (max 100 par lot)
    for i in range(0, len(vectors), 100):
        batch = vectors[i:i+100]
        index.upsert(vectors=batch)

Requêtage

DEVELOPERpython
def search(query, top_k=10):
    # Créer l'embedding de la requête
    query_embedding = client.embeddings.create(
        model="text-embedding-3-small",
        input=query
    ).data[0].embedding

    # Rechercher
    results = index.query(
        vector=query_embedding,
        top_k=top_k,
        include_metadata=True
    )

    return [match['metadata']['text'] for match in results['matches']]

Filtrage de Métadonnées

DEVELOPERpython
# Filtrer par source
results = index.query(
    vector=query_embedding,
    filter={"source": {"$eq": "wikipedia"}},
    top_k=10,
    include_metadata=True
)

# Plage de dates
results = index.query(
    vector=query_embedding,
    filter={
        "date": {"$gte": "2025-01-01", "$lte": "2025-12-31"}
    },
    top_k=10
)

Namespaces (Multi-tenancy)

DEVELOPERpython
# Séparer les données des clients
index.upsert(
    vectors=[...],
    namespace="customer_123"
)

# Requêter un namespace spécifique
results = index.query(
    vector=query_embedding,
    namespace="customer_123",
    top_k=10
)

Recherche Hybride (Sparse + Dense)

DEVELOPERpython
# Insertion avec vecteurs sparse
index.upsert(
    vectors=[{
        "id": "doc1",
        "values": dense_vector,  # Embedding dense
        "sparse_values": {
            "indices": [10, 45, 123],  # Indices BM25
            "values": [0.5, 0.3, 0.2]
        },
        "metadata": {"text": "..."}
    }]
)

# Requête hybride
results = index.query(
    vector=dense_query,
    sparse_vector={
        "indices": [10, 45],
        "values": [0.6, 0.4]
    },
    top_k=10,
    alpha=0.7  # Poids dense
)

Optimisation des Coûts

Tarification serverless (Nov 2025) :

• $0.09 par million d'unités de lecture
• $2.00 par million d'unités d'écriture
• $0.00025 par GB-heure de stockage

Conseils :

1. Utiliser serverless pour les charges variables
2. Insertions par lots (100 par requête)
3. Mettre en cache les requêtes fréquentes
4. Supprimer les anciennes données

Surveillance

DEVELOPERpython
# Statistiques de l'index
stats = index.describe_index_stats()
print(f"Total vectors: {stats['total_vector_count']}")
print(f"Dimension: {stats['dimension']}")

Pinecone est de qualité production. Utilisez-le quand vous avez besoin d'échelle, de fiabilité et de zéro ops.