Embedding Vectoriel Python 2026 : Guide Pratique

Un embedding vectoriel, c'est la représentation numérique du sens d'un texte — un vecteur de 384 à 1536 dimensions qui encode la sémantique d'une phrase ou d'un paragraphe. Deux textes proches dans le sens humain auront des vecteurs proches dans l'espace mathématique. C'est cette propriété qui permet la recherche sémantique : "trouver les passages d'un corpus dont le sens est proche de ma requête", indépendamment des mots exacts utilisés. En cybersécurité, les applications sont directes et concrètes : chercher des tickets de support similaires à un incident en cours, regrouper des alertes IOC par famille de menaces, construire un assistant RAG sur votre documentation interne de sécurité. La librairie Python sentence-transformers (SBERT), développée par Nils Reimers et publiée dans le paper Sentence-BERT (2019), reste en 2026 la référence pour la génération d'embeddings de qualité en Python. Elle expose une API simple, supporte des dizaines de modèles pré-entraînés optimisés pour différents cas d'usage, et s'intègre nativement avec ChromaDB, FAISS et pgvector. Les modèles disponibles sur Hugging Face / sentence-transformers couvrent des cas d'usage de la recherche sémantique généraliste au clustering multilingue spécialisé. Ce guide vous donne le code complet, les benchmarks comparatifs des modèles, et les patterns d'architecture pour les cas d'usage les plus courants.

Installer sentence-transformers et générer votre premier embedding

L'installation est volontairement simple :

pip install sentence-transformers chromadb faiss-cpu
# Pour GPU : pip install faiss-gpu (CUDA requis)
# Pour pgvector : pip install pgvector psycopg2-binary

Premier embedding en 5 lignes :

from sentence_transformers import SentenceTransformer

# Téléchargement automatique depuis Hugging Face (une seule fois)
model = SentenceTransformer("all-MiniLM-L6-v2")

# Générer un embedding
sentence = "Analyse de malware : identification de Redline Stealer via comportement réseau"
embedding = model.encode(sentence)

print(f"Dimensions : {len(embedding)}")  # 384
print(f"Type : {type(embedding)}")       # numpy.ndarray
print(f"Norme : {embedding @ embedding:.2f}")  # ~1.0 (vecteur normalisé)

C'est tout. Le modèle est téléchargé depuis Hugging Face lors du premier appel et mis en cache dans ~/.cache/huggingface. Les appels suivants utilisent le cache local.

Comparatif des modèles sentence-transformers en 2026

Pour du contenu en français, paraphrase-multilingual-MiniLM-L12-v2 est le point d'entrée recommandé — bon équilibre vitesse/qualité. Si la qualité de la recherche est critique (corpus documentaire de sécurité avec des termes techniques), multilingual-e5-large-instruct est le meilleur choix en 2026, au prix d'une vitesse d'embedding 8 fois inférieure.

ChromaDB : le vector store local le plus simple à démarrer

ChromaDB est le vector store le plus accessible pour démarrer un projet d'embeddings. Il fonctionne en mémoire ou avec persistance SQLite, sans infrastructure externe. API Python native, sans configuration.

import chromadb
from sentence_transformers import SentenceTransformer

# Initialisation avec persistance sur disque
client = chromadb.PersistentClient(path="./chroma_db")

# Créer une collection (ou la récupérer si elle existe)
collection = client.get_or_create_collection(
    name="security_docs",
    metadata={"hnsw:space": "cosine"}  # Similarité cosinus recommandée
)

model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")

# Documents à indexer
documents = [
    "Le Kerberoasting cible les comptes de service Active Directory avec SPN.",
    "DCSync permet d'extraire les hashes NTLM depuis un DC via l'API de réplication.",
    "L'AS-REP Roasting cible les comptes sans pré-authentification Kerberos requise.",
    "Pass-the-Hash exploite les hashes NTLM pour l'authentification sans le mot de passe clair.",
    "BloodHound visualise les chemins d'attaque dans Active Directory via requêtes Neo4j.",
]

# Générer les embeddings et les stocker
embeddings = model.encode(documents).tolist()

collection.add(
    ids=[f"doc_{i}" for i in range(len(documents))],
    embeddings=embeddings,
    documents=documents,
    metadatas=[{"source": "AD-security", "category": "attack"} for _ in documents]
)

print(f"Collection : {collection.count()} documents indexés")

# Recherche sémantique
query = "Comment récupérer les mots de passe depuis l'annuaire AD ?"
query_embedding = model.encode(query).tolist()

results = collection.query(
    query_embeddings=[query_embedding],
    n_results=3,
    include=["documents", "distances", "metadatas"]
)

for doc, dist in zip(results["documents"][0], results["distances"][0]):
    print(f"Score: {1-dist:.3f} | {doc[:80]}...")

Ce code indexe 5 documents et retrouve les 3 plus pertinents pour la requête. La beauté de la recherche sémantique : la requête "récupérer les mots de passe depuis AD" trouvera DCSync, Pass-the-Hash et Kerberoasting — sans que ces mots ne soient dans la requête. C'est le cœur de l'utilité des embeddings.

FAISS : pour les corpus de grande échelle (millions de vecteurs)

ChromaDB est excellent pour des corpus de quelques milliers à quelques centaines de milliers de documents. Au-delà, FAISS (Facebook AI Similarity Search) de Meta devient nécessaire pour maintenir des temps de recherche acceptables.

import faiss
import numpy as np
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-MiniLM-L6-v2")

# Supposons 100 000 documents à indexer
documents = [f"Document de sécurité numéro {i}" for i in range(100_000)]

# Encoder en batch (plus efficace que document par document)
print("Encodage en cours...")
embeddings = model.encode(documents, batch_size=256, show_progress_bar=True)
embeddings = embeddings.astype("float32")  # FAISS requiert float32

dimension = embeddings.shape[1]  # 384 pour MiniLM

# Index IVF (Inverted File) pour la recherche approchée à grande échelle
# nlist = nombre de clusters (règle empirique : sqrt(n_docs))
nlist = 316  # sqrt(100_000) ~ 316
quantizer = faiss.IndexFlatIP(dimension)  # Inner Product (= cosine si normalisé)
index = faiss.IndexIVFFlat(quantizer, dimension, nlist, faiss.METRIC_INNER_PRODUCT)

# Normaliser les vecteurs (pour que IP = cosine similarity)
faiss.normalize_L2(embeddings)

# Entraîner l'index (nécessaire pour IVF)
print("Entraînement de l'index IVF...")
index.train(embeddings)
index.add(embeddings)

print(f"Index construit : {index.ntotal} vecteurs")

# Sauvegarder
faiss.write_index(index, "security_docs.faiss")

# Recherche
index.nprobe = 10  # Nombre de clusters à explorer (plus = plus précis mais plus lent)

query = "CVE critique dans les systèmes Active Directory"
query_vec = model.encode([query]).astype("float32")
faiss.normalize_L2(query_vec)

distances, indices = index.search(query_vec, k=5)
for idx, score in zip(indices[0], distances[0]):
    print(f"Score: {score:.3f} | Doc {idx}: {documents[idx][:60]}")

FAISS IVF réduit la complexité de recherche de O(n) linéaire à O(log n) approximatif. Sur 1 million de vecteurs de 384 dimensions, une recherche des 10 plus proches voisins prend moins de 10ms. Sur du brute-force (IndexFlatIP), la même recherche prendrait 800ms à 1 seconde. C'est la différence entre viable et non-viable en production.

Pipeline RAG complet avec sentence-transformers

Voici un pipeline RAG fonctionnel qui combine indexation, retrieval et génération avec un LLM local via Ollama :

#!/usr/bin/env python3
"""
Pipeline RAG : sentence-transformers + ChromaDB + Ollama
Usage : python rag_pipeline.py "Votre question ici"
"""
import chromadb, requests, sys
from sentence_transformers import SentenceTransformer
from pathlib import Path

EMBED_MODEL = "paraphrase-multilingual-MiniLM-L12-v2"
LLM_MODEL = "mistral:7b"
OLLAMA_URL = "http://localhost:11434/api/generate"
TOP_K = 5  # Nombre de chunks à récupérer

class RAGPipeline:
    def __init__(self, collection_name: str, db_path: str = "./rag_db"):
        self.embed_model = SentenceTransformer(EMBED_MODEL)
        self.client = chromadb.PersistentClient(path=db_path)
        self.collection = self.client.get_or_create_collection(
            name=collection_name,
            metadata={"hnsw:space": "cosine"}
        )

    def index_directory(self, directory: str, chunk_size: int = 300):
        """Indexe tous les fichiers .txt et .md d'un répertoire."""
        docs, ids, metas = [], [], []
        for i, path in enumerate(Path(directory).rglob("*.[tm][xd]*")):
            text = path.read_text(errors="ignore")
            # Chunking simple par fenêtre glissante de mots
            words = text.split()
            for j in range(0, len(words), chunk_size // 2):  # 50% overlap
                chunk = " ".join(words[j:j+chunk_size])
                if len(chunk) > 50:  # Ignorer les chunks trop courts
                    docs.append(chunk)
                    ids.append(f"{path.stem}_{j}")
                    metas.append({"source": str(path), "chunk_start": j})
        if docs:
            embeds = self.embed_model.encode(docs, batch_size=64, show_progress_bar=True)
            self.collection.add(ids=ids, embeddings=embeds.tolist(),
                                documents=docs, metadatas=metas)
            print(f"Indexé : {len(docs)} chunks depuis {directory}")

    def retrieve(self, query: str, k: int = TOP_K) -> list[dict]:
        """Récupère les k chunks les plus pertinents."""
        q_embed = self.embed_model.encode(query).tolist()
        results = self.collection.query(
            query_embeddings=[q_embed], n_results=k,
            include=["documents", "distances", "metadatas"]
        )
        return [{"text": d, "source": m["source"], "score": 1-dist}
                for d, m, dist in zip(results["documents"][0],
                                      results["metadatas"][0],
                                      results["distances"][0])]

    def generate(self, query: str, context_chunks: list[dict]) -> str:
        """Génère une réponse en utilisant les chunks récupérés."""
        context = "  ".join([f"[Source: {c['source']}] {c['text']}" for c in context_chunks])
        prompt = f"""Contexte documentaire :
{context}

Question : {query}

Réponds en français en citant les sources pertinentes. Si l'information n'est pas dans le contexte, dis-le explicitement."""
        response = requests.post(OLLAMA_URL,
            json={"model": LLM_MODEL, "prompt": prompt, "stream": False})
        return response.json().get("response", "Erreur LLM")

    def query(self, question: str) -> str:
        """Pipeline complet : retrieve + generate."""
        chunks = self.retrieve(question)
        print(f"Chunks récupérés : {len(chunks)} (top score: {chunks[0]['score']:.3f})")
        return self.generate(question, chunks)

# Exemple d'utilisation
if __name__ == "__main__":
    rag = RAGPipeline("security_knowledge_base")
    # Première fois seulement : indexer vos documents
    # rag.index_directory("./mes_docs_securite")
    question = sys.argv[1] if len(sys.argv) > 1 else "Qu'est-ce que le Kerberoasting ?"
    answer = rag.query(question)
    print(f" Réponse : {answer}")

Ce pipeline est prêt à l'emploi. Pour indexer une documentation de sécurité de quelques centaines de fichiers, le temps d'indexation est de 2 à 5 minutes sur CPU. La recherche prend moins de 100ms. Le temps de génération dépend du LLM choisi (2 à 10 secondes avec Mistral 7B en local).

Pour approfondir les bases vectorielles et les alternatives à ChromaDB, le guide sur les bases de données vectorielles couvre Qdrant, Milvus, Weaviate et pgvector. Pour comprendre la théorie derrière les embeddings, Comprendre les embeddings IA pose les fondations mathématiques. Le comparatif embeddings vs tokens clarifie souvent une confusion fréquente chez les débutants.

pgvector : embeddings directement dans PostgreSQL

Pour les organisations qui ont déjà PostgreSQL en infrastructure et ne veulent pas ajouter une base vectorielle dédiée, l'extension pgvector transforme PostgreSQL en vector store performant.

-- Installation de l'extension (une fois)
CREATE EXTENSION IF NOT EXISTS vector;

-- Table avec colonne vector
CREATE TABLE security_embeddings (
    id SERIAL PRIMARY KEY,
    content TEXT NOT NULL,
    source VARCHAR(255),
    embedding vector(384),  -- 384 dimensions pour MiniLM
    created_at TIMESTAMP DEFAULT NOW()
);

-- Index HNSW pour la recherche rapide
CREATE INDEX ON security_embeddings
USING hnsw (embedding vector_cosine_ops);

-- Recherche par similarité cosinus
SELECT content, source,
       1 - (embedding <=> '[0.1, 0.2, ...384 valeurs...]') AS similarity
FROM security_embeddings
ORDER BY embedding <=> '[0.1, 0.2, ...]'
LIMIT 5;

Avec Python :

import psycopg2
from pgvector.psycopg2 import register_vector
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")

conn = psycopg2.connect("postgresql://user:password@localhost/security_db")
register_vector(conn)
cur = conn.cursor()

# Insérer un embedding
text = "Analyse forensique des artefacts Windows : prefetch, shimcache, amcache"
embedding = model.encode(text)
cur.execute("INSERT INTO security_embeddings (content, source, embedding) VALUES (%s, %s, %s)",
           (text, "dfir-guide.txt", embedding))
conn.commit()

# Recherche sémantique
query = "Quels fichiers Windows conservent l'historique des exécutions ?"
q_embed = model.encode(query)
cur.execute("""
    SELECT content, 1 - (embedding <=> %s) as similarity
    FROM security_embeddings
    ORDER BY embedding <=> %s
    LIMIT 3
""", (q_embed, q_embed))
for row in cur.fetchall():
    print(f"Score: {row[1]:.3f} | {row[0][:80]}")

pgvector est particulièrement attractif quand vos embeddings doivent cohabiter avec des données relationnelles — métadonnées d'articles, profils d'utilisateurs, historique d'incidents. Une seule base de données simplifie l'architecture et réduit les coûts d'infrastructure.

Optimiser les performances en production

Quelques optimisations critiques pour passer de "ça marche en dev" à "ça tient en prod" :

• Batch encoding : encoder les documents par batch de 64 à 512 plutôt qu'un par un. L'encodage de 10 000 phrases en un batch de 256 est 50 à 100 fois plus rapide que 10 000 appels individuels.
• Modèle en mémoire : charger le modèle sentence-transformers une seule fois au démarrage de l'application, pas à chaque requête. Le chargement coûte 1 à 3 secondes ; l'encodage coûte quelques millisecondes.
• Cache des embeddings fréquents : pour les requêtes utilisateurs répétées (mêmes questions dans un chatbot support), mettre en cache les embeddings des requêtes dans Redis ou en mémoire avec un TTL adapté.
• Normalisation des vecteurs : normaliser les embeddings à la sortie du modèle pour utiliser le produit scalaire (plus rapide) au lieu de la similarité cosinus (équivalent si normalisé).
• Dimensionnalité et latence : passer de 768 à 384 dimensions réduit la taille de l'index de 50% et la vitesse de recherche de 30 à 40% — souvent acceptable selon le cas d'usage.

Cas d'usage cybersécurité : clustering d'alertes SIEM

Un cas d'usage concret en sécurité : regrouper automatiquement des milliers d'alertes SIEM similaires pour réduire la fatigue d'alerte.

from sentence_transformers import SentenceTransformer
from sklearn.cluster import KMeans
import numpy as np

model = SentenceTransformer("all-MiniLM-L6-v2")

# Exemple d'alertes SIEM (en pratique, charger depuis votre SIEM)
alerts = [
    "Failed login attempt from 192.168.1.105 for user admin",
    "Multiple authentication failures detected from 192.168.1.105",
    "Brute force attack detected: 50 failed logins in 60 seconds",
    "Suspicious PowerShell execution: encoded command detected",
    "AMSI bypass attempted via PowerShell reflection",
    "PowerShell Invoke-Expression with encoded payload detected",
    "Lateral movement: SMB connection from WORKSTATION-01 to DC-01",
    "Unusual SMB traffic pattern between endpoints",
]

# Générer les embeddings
embeddings = model.encode(alerts)

# Clustering K-Means (3 clusters attendus : brute force, PowerShell, lateral movement)
n_clusters = 3
kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
labels = kmeans.fit_predict(embeddings)

# Afficher les clusters
for cluster_id in range(n_clusters):
    cluster_alerts = [alerts[i] for i, l in enumerate(labels) if l == cluster_id]
    print(f" Cluster {cluster_id} ({len(cluster_alerts)} alertes):")
    for alert in cluster_alerts:
        print(f"  - {alert[:70]}")

Ce clustering simple réduit visuellement 8 alertes à 3 groupes thématiques. Sur des milliers d'alertes réelles, c'est la différence entre un analyste SOC submergé et un analyste qui traite des groupes d'incidents cohérents. L'étape suivante : labelliser les clusters automatiquement en demandant à un LLM de décrire le pattern commun de chaque cluster.

Pour l'architecture RAG complète incluant le retrieval et la génération, le guide RAG en 2026 couvre tous les patterns d'architecture avancés.

Embedding pour la détection de doublons et la déduplication de documents

Un autre cas d'usage fréquent en enterprise : détecter les documents quasi-identiques dans un corpus. En cybersécurité, cela s'applique aux tickets d'incident dupliqués, aux alertes redondantes, ou aux rapports de vulnérabilité couvrant les mêmes CVE avec des formulations différentes.

from sentence_transformers import SentenceTransformer
import numpy as np
from itertools import combinations

model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")

# Exemple : tickets de support potentiellement dupliqués
tickets = [
    "Impossible de se connecter au VPN depuis ce matin",
    "VPN ne fonctionne plus depuis 8h, accès refusé",
    "Erreur d'authentification sur le portail web RH",
    "Le portail RH refuse mon mot de passe depuis la mise à jour",
    "Problème de connexion au VPN - authentication failed",
    "Ransomware détecté sur WORKSTATION-042",
]

embeddings = model.encode(tickets)

# Calcul des similarités cosinus entre toutes les paires
SIMILARITY_THRESHOLD = 0.85  # Seuil de duplication

for i, j in combinations(range(len(tickets)), 2):
    # Similarité cosinus via produit scalaire (vecteurs normalisés)
    sim = np.dot(embeddings[i], embeddings[j]) / (
          np.linalg.norm(embeddings[i]) * np.linalg.norm(embeddings[j]))
    if sim > SIMILARITY_THRESHOLD:
        print(f"DOUBLON POTENTIEL (sim={sim:.3f}):")
        print(f"  Ticket {i}: {tickets[i]}")
        print(f"  Ticket {j}: {tickets[j]}")

Sur 6 tickets, ce code identifie correctement les 2 groupes de doublons (tickets VPN et tickets portail RH) sans se laisser piéger par les différentes formulations. Sur un corpus de milliers de tickets, ce pattern réduit significativement la charge des équipes support et SOC.

Choisir la bonne dimension d'embedding : trade-offs concrets

La dimension des vecteurs n'est pas un choix anodin — elle impacte directement la mémoire, la vitesse de recherche, et la qualité du retrieval.

Pour la grande majorité des cas d'usage en cybersécurité (RAG sur documentation, recherche dans des logs, clustering d'alertes), 384 dimensions avec paraphrase-multilingual-MiniLM-L12-v2 offre le meilleur compromis. Ne pas tomber dans le piège de choisir "le plus grand modèle disponible" par défaut — la qualité supplémentaire de 1024 dimensions est souvent marginale pour votre cas d'usage spécifique, mais le coût en mémoire et en latence est substantiel.

Embedding et conformité RGPD : les bonnes pratiques

Un point que beaucoup oublient : les embeddings peuvent contenir de l'information personnelle identifiable (PII) de façon indirecte. Si vous embeddez des emails, des tickets de support contenant des noms, ou des rapports d'incident avec des données d'employés, les vecteurs résultants peuvent permettre une reconstruction partielle du texte original — pas une reconstruction exacte, mais suffisante pour poser des problèmes RGPD.

Les bonnes pratiques RGPD pour les pipelines d'embedding :

• Anonymisation avant embedding : remplacer les noms propres, adresses email, numéros d'employés par des tokens anonymes avant l'encodage. Des librairies comme spaCy (modèle fr_core_news_lg) permettent la détection et remplacement automatique des entités nommées.
• Durée de conservation : définir une politique de rétention pour les vecteurs stockés — un embedding d'un email contenant des PII reste soumis aux droits RGPD (droit à l'effacement).
• Base juridique : si vous embeddez des communications d'employés pour un RAG interne, vérifier la base juridique (intérêt légitime, accord individuel) et l'information préalable.
• Localisation des données : l'un des avantages des SLM et vector stores locaux (FAISS, ChromaDB, pgvector on-premise) — les embeddings ne quittent pas l'infrastructure de l'organisation, simplifiant la conformité.

Le guide sur la gouvernance LLM et conformité RGPD/AI Act couvre ces aspects réglementaires en détail.

Questions fréquentes

Quel modèle sentence-transformers choisir pour du contenu en français ?

Pour démarrer : paraphrase-multilingual-MiniLM-L12-v2 — rapide, support FR natif, 384 dimensions. Pour une qualité maximale sur le français avec plus de ressources disponibles : multilingual-e5-large-instruct (1024 dims) qui est actuellement le SOTA sur les benchmarks MTEB français. Éviter all-MiniLM-L6-v2 et all-mpnet-base-v2 pour le français — ces modèles sont entraînés principalement sur de l'anglais.

ChromaDB ou FAISS : lequel choisir ?

ChromaDB pour les prototypes et les corpus sous 500K documents — API simple, persistance automatique, pas de configuration. FAISS pour les corpus de production au-delà de 500K documents, surtout si vous avez besoin d'index IVF ou IVFPQ pour contrôler la mémoire. pgvector si vous êtes déjà sur PostgreSQL et que vos embeddings doivent être intégrés à vos données relationnelles existantes.

Comment mesurer la qualité des embeddings pour mon corpus spécifique ?

Construire un mini-benchmark avec 50 à 100 paires question/document de référence validées manuellement. Pour chaque paire, vérifier que le document de référence est dans le top-3 des résultats de recherche sémantique. Le taux de Recall@3 (proportion de documents de référence trouvés dans les 3 premiers résultats) est la métrique la plus directement utile pour évaluer la qualité du retrieval.

Les embeddings sentence-transformers sont-ils compatibles avec les bases vectorielles cloud (Pinecone, Weaviate Cloud) ?

Oui, les vecteurs numpy générés par sentence-transformers sont compatibles avec n'importe quel vector store — Pinecone, Weaviate, Qdrant Cloud, Milvus. La seule contrainte : vérifier que la dimension du vecteur correspond à la configuration de l'index dans la base cloud. Pour all-MiniLM-L6-v2 : déclarer un index de dimension 384. Pour multilingual-e5-large : dimension 1024.

Peut-on fine-tuner un modèle sentence-transformers sur un corpus spécialisé en cybersécurité ?

Oui, et c'est souvent utile pour les domaines très techniques. La librairie sentence-transformers supporte le fine-tuning via des paires (sentence1, sentence2, score) ou des triplets (anchor, positive, negative). Un fine-tuning sur 1000 à 5000 paires de documents cybersécurité annotés améliore typiquement le Recall@5 de 5 à 15 points sur votre domaine spécifique. Le guide de fine-tuning est disponible dans la documentation officielle sentence-transformers.

Conclusion

Ce sujet s'inscrit dans un contexte de menaces en constante évolution. La meilleure protection combine veille active, audits réguliers et sécurité by design. Pour approfondir ou évaluer votre exposition, consultez nos experts.