RAG — Retrieval-Augmented Generation

embed("Comment reduire ma facture d'electricite ?")
→ [0.23, -0.41, 0.87, 0.12, ...]  (1536 dimensions)

embed("Je paye trop cher mon courant, que faire ?")
→ [0.21, -0.39, 0.85, 0.14, ...]  (tres proche ! meme sens)

embed("Quelle est la capitale de la France ?")
→ [0.78, 0.33, -0.21, 0.67, ...]  (tres loin — sujet different)

distance("facture", "courant") = 0.05  → tres similaire
distance("facture", "capitale") = 1.42 → tres different

import { embed, embedMany } from "ai";

// Embedder un seul texte
const { embedding } = await embed({
  model: "openai/text-embedding-3-small",
  value: "Comment changer de fournisseur d'electricite ?",
});
// embedding = number[] (1536 dimensions)

// Embedder plusieurs textes d'un coup (plus efficace)
const { embeddings } = await embedMany({
  model: "openai/text-embedding-3-small",
  values: [
    "Guide pour changer de fournisseur",
    "Tarifs electricite 2026",
    "Comment lire son compteur Linky",
  ],
});
// embeddings = number[][] (3 vecteurs)

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# Simulons des embeddings (en vrai, ils viennent d'un modele)
# Ici on utilise sentence-transformers (pip install sentence-transformers)
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-MiniLM-L6-v2")  # leger, 384 dims

phrases = [
    "Comment reduire ma facture d'electricite ?",
    "Je paye trop cher mon courant, que faire ?",
    "Quelle est la capitale de la France ?",
]
embeddings = model.encode(phrases)  # → np.array shape (3, 384)

# Matrice de similarite
sim_matrix = cosine_similarity(embeddings)
print(f"facture ↔ courant  : {sim_matrix[0][1]:.3f}")  # → 0.82 (tres proche !)
print(f"facture ↔ capitale : {sim_matrix[0][2]:.3f}")  # → 0.13 (rien a voir)

# Trouver le document le plus proche d'une question
question = model.encode(["Je veux payer moins cher"])
scores = cosine_similarity(question, embeddings)[0]
best = np.argmax(scores)
print(f"Meilleur match : '{phrases[best]}' (score: {scores[best]:.3f})")

Document original (2000 tokens):
"## Changer de fournisseur
Pour changer de fournisseur d'electricite, il suffit de souscrire
une nouvelle offre. L'ancien fournisseur sera resilie automatiquement...
[500 tokens]

## Les tarifs reglementes
Le tarif reglemente de vente (TRV) est fixe par les pouvoirs publics...
[600 tokens]

## Le compteur Linky
Le compteur Linky permet de relever votre consommation a distance...
[900 tokens]"

Apres chunking recursif (max 500 tokens, overlap 50):
→ Chunk 1: "## Changer de fournisseur
Pour changer..." (480 tokens)
→ Chunk 2: "## Les tarifs reglementes
Le tarif..." (520 tokens → re-decoupe)
  → Chunk 2a: "## Les tarifs reglementes
Le tarif..." (300 tokens)
  → Chunk 2b: "...fixe par les pouvoirs publics..." (270 tokens)
→ Chunk 3: "## Le compteur Linky
Le compteur..." (450 tokens)
→ Chunk 4: "...relever votre consommation a distance..." (500 tokens)

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,       # max 500 caracteres par chunk
    chunk_overlap=50,     # 50 caracteres de chevauchement
    separators=["\n## ", "\n\n", "\n", ". ", " "],  # priorite de coupure
)

texte = """## Changer de fournisseur
Pour changer de fournisseur d'electricite, il suffit de souscrire
une nouvelle offre. La resiliation est automatique et gratuite.

## Les tarifs reglementes
Le tarif reglemente de vente (TRV) est fixe par les pouvoirs publics.
Il change deux fois par an, en fevrier et en aout."""

chunks = splitter.split_text(texte)
for i, chunk in enumerate(chunks):
    print(f"Chunk {i} ({len(chunk)} chars): {chunk[:60]}...")

// Cosine similarity entre deux vecteurs
function cosineSimilarity(a: number[], b: number[]): number {
  let dot = 0, normA = 0, normB = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i];
    normA += a[i] * a[i];
    normB += b[i] * b[i];
  }
  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
}

// Chercher les K chunks les plus proches
function search(query: number[], chunks: { text: string; embedding: number[] }[], k = 3) {
  return chunks
    .map(chunk => ({
      text: chunk.text,
      score: cosineSimilarity(query, chunk.embedding),
    }))
    .sort((a, b) => b.score - a.score)
    .slice(0, k);
}

// Utilisation
const queryEmbedding = await embed({ model, value: "Comment changer de fournisseur ?" });
const results = search(queryEmbedding.embedding, indexedChunks, 3);
// → [
//   { text: "Pour changer de fournisseur...", score: 0.89 },
//   { text: "La procedure de changement...", score: 0.82 },
//   { text: "Les delais de changement...", score: 0.76 },
// ]

import { embed, embedMany, generateText } from "ai";

// ── 1. Donnees (en prod, ca viendrait d'une DB ou de fichiers) ──

const faq = [
  {
    question: "Comment changer de fournisseur d'electricite ?",
    answer: "Il suffit de souscrire une offre chez un nouveau fournisseur. La resiliation de l'ancien contrat est automatique et gratuite. Le changement prend environ 3 semaines. Vous n'aurez aucune coupure d'electricite pendant la transition.",
  },
  {
    question: "Qu'est-ce que le numero PDL ?",
    answer: "Le PDL (Point de Livraison) est un numero a 14 chiffres qui identifie votre compteur electrique. Vous le trouvez sur votre facture d'electricite, sur votre compteur Linky, ou en appelant Enedis au 09 72 67 50 XX (XX = votre departement).",
  },
  {
    question: "Quels documents faut-il pour souscrire ?",
    answer: "Pour souscrire un contrat d'electricite, vous avez besoin de : votre adresse exacte, votre numero PDL (ou PCE pour le gaz), un RIB pour le prelevement, et une estimation de votre consommation annuelle en kWh.",
  },
  // ... 200 autres Q/R
];

// ── 2. Indexation (une seule fois au demarrage) ──

const texts = faq.map(f => f.question + " " + f.answer);
const { embeddings } = await embedMany({
  model: "openai/text-embedding-3-small",
  values: texts,
});

const index = faq.map((f, i) => ({
  text: f.question + "\n" + f.answer,
  embedding: embeddings[i],
}));

// ── 3. Recherche (a chaque question utilisateur) ──

const userQuestion = "J'ai besoin de quoi pour ouvrir un contrat ?";

const { embedding: queryVec } = await embed({
  model: "openai/text-embedding-3-small",
  value: userQuestion,
});

// Trouver les 3 Q/R les plus pertinentes
const results = index
  .map(item => ({ ...item, score: cosineSimilarity(queryVec, item.embedding) }))
  .sort((a, b) => b.score - a.score)
  .slice(0, 3);

// ── 4. Generation avec contexte ──

const response = await generateText({
  model: "anthropic/claude-sonnet-4.6",
  system: "Tu es l'assistant Selectra. Reponds en te basant UNIQUEMENT sur les documents fournis. Si l'info n'est pas dans les documents, dis-le.",
  prompt: `Documents pertinents :
---
${results.map(r => r.text).join("\n---\n")}
---

Question du client : ${userQuestion}

Reponds en citant les sources.`
});