RAG Expliqué Simplement : Architecture et Mise en Œuvre

1. Question utilisateur : "Quelle est la procédure de remboursement ?"
   ↓
2. Conversion en embedding : [0.23, -0.45, 0.67, ...] (768 dimensions)
   ↓
3. Recherche vectorielle : Top 5 chunks similaires dans la base
   → Chunk #142 (score: 0.89) : "La procédure de remboursement..."
   → Chunk #87  (score: 0.82) : "Délais de traitement..."
   ↓
4. Injection dans le prompt LLM :
   "Contexte: [chunks récupérés]
    Question: Quelle est la procédure de remboursement ?
    Réponds en te basant uniquement sur le contexte fourni."
   ↓
5. Génération de la réponse + citation des sources

# Prompt anti-hallucination
system_prompt = """
Tu es un assistant qui répond UNIQUEMENT basé sur le contexte fourni.
Si la réponse n'est pas dans le contexte, réponds EXACTEMENT :
"Je n'ai pas trouvé cette information dans la documentation."

NE PAS inventer d'information. NE PAS utiliser tes connaissances générales.
"""

// Exemple de réponse avec sources
{
  "answer": "La période de remboursement standard est de 14 jours ouvrés...",
  "sources": [
    {
      "document": "Politique_Remboursement_v2.3.pdf",
      "page": 5,
      "chunk_text": "Article 3.2 - Délais : Le client dispose...",
      "similarity_score": 0.89,
      "url": "https://docs.company.com/policies/refund"
    },
    {
      "document": "FAQ_Client_2024.md",
      "section": "Remboursements",
      "similarity_score": 0.82
    }
  ]
}

┌─────────────────────────────────────────────────────────┐
│                   PIPELINE INDEXATION                   │
│                        (Offline)                        │
└─────────────────────────────────────────────────────────┘

 Documents sources (PDF, DOCX, HTML, Markdown)
    ↓
 Document Loader & Parser (PyPDF2, Unstructured)
    ↓
 Text Splitter / Chunker (512 tokens, overlap 50)
    ↓
 Embedding Model (OpenAI text-embedding-3-small)
    ↓
 Vector Database (Qdrant, Pinecone, Weaviate)

┌─────────────────────────────────────────────────────────┐
│                    PIPELINE REQUÊTE                     │
│                        (Online)                         │
└─────────────────────────────────────────────────────────┘

 Question utilisateur
    ↓
 Query Transformation (optional: expansion, réécriture)
    ↓
 Embedding de la query (même modèle que indexation)
    ↓
 Vector Search (top-k chunks, k=5-10)
    ↓
 Reranking (optional: cross-encoder)
    ↓
 Context Assembly (concaténation des chunks)
    ↓
 Prompt Engineering (system + context + question)
    ↓
 LLM Generation (GPT-4o, Claude 3.5, Mistral Large)
    ↓
 Response + Sources

# Exemple LangChain
from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,
    chunk_overlap=50,
    separators=["\n\n", "\n", ".", " ", ""],
    length_function=len
)
chunks = text_splitter.split_documents(documents)

from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct, VectorParams, Distance

client = QdrantClient("localhost", port=6333)

# Création de la collection
client.create_collection(
    collection_name="documentation",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

# Insertion des vecteurs
points = [
    PointStruct(
        id=i,
        vector=embedding,
        payload={
            "text": chunk.text,
            "source": chunk.metadata["source"],
            "page": chunk.metadata["page"],
            "created_at": "2024-01-15"
        }
    )
    for i, (chunk, embedding) in enumerate(zip(chunks, embeddings))
]

client.upsert(collection_name="documentation", points=points)

query_embedding = openai.embeddings.create(
    model="text-embedding-3-small",
    input="Quelle est la procédure de remboursement ?"
).data[0].embedding

results = client.search(
    collection_name="documentation",
    query_vector=query_embedding,
    limit=10,  # top-k
    score_threshold=0.7  # filtrer les résultats peu pertinents
)

from sentence_transformers import CrossEncoder

reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

# Scorer chaque paire (query, chunk)
pairs = [[query, result.payload["text"]] for result in results]
scores = reranker.predict(pairs)

# Retrier selon les nouveaux scores
reranked = sorted(zip(results, scores), key=lambda x: x[1], reverse=True)[:3]

context = "\n\n---\n\n".join([
    f"[Document: {r.payload['source']}, Page: {r.payload['page']}]\n{r.payload['text']}"
    for r in top_results
])

prompt = f"""Tu es un assistant qui répond précisément basé sur le contexte fourni.

Contexte:
{context}

Question: {user_query}

Instructions:
- Réponds UNIQUEMENT avec les informations du contexte
- Cite les sources [Document: X, Page: Y]
- Si la réponse n'est pas dans le contexte, dis "Information non disponible"
"""

response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1  # Réponse factuelle, peu créative
)

┌──────────────────────────────────────────────────────────────────┐
│                         FRONTEND                                 │
│  Next.js App / React / Vue.js + WebSocket pour streaming        │
└────────────────────────────┬─────────────────────────────────────┘
                             │
                             ↓
┌────────────────────────────────────────────────────────────────┐
│                      API GATEWAY                               │
│  FastAPI / Express.js - Rate limiting, Auth, Logging          │
└────────────────────────────┬───────────────────────────────────┘
                             │
         ┌───────────────────┼───────────────────┐
         ↓                   ↓                   ↓
┌────────────────┐  ┌────────────────┐  ┌──────────────┐
│  Redis Cache   │  │  RAG Engine    │  │  PostgreSQL  │
│  (hot queries) │  │  (Python)      │  │  (metadata)  │
└────────────────┘  └────┬───────────┘  └──────────────┘
                         │
         ┌───────────────┼───────────────────┐
         ↓               ↓                   ↓
┌────────────┐  ┌─────────────────┐  ┌──────────────┐
│  Qdrant    │  │  OpenAI API     │  │  S3/MinIO    │
│  (vectors) │  │  (embeddings    │  │  (documents) │
│            │  │   + LLM)        │  │              │
└────────────┘  └─────────────────┘  └──────────────┘

┌────────────────────────────────────────────────────────────────┐
│                  MONITORING & OBSERVABILITY                    │
│  Prometheus + Grafana - Latency, cost, error rate             │
│  Sentry - Error tracking                                       │
│  LangSmith / Helicone - LLM call tracing                       │
└────────────────────────────────────────────────────────────────┘

from langchain.document_loaders import (
    PyPDFLoader,
    UnstructuredWordDocumentLoader,
    NotionDirectoryLoader,
    GitLoader,
    WebBaseLoader
)

# PDF
loader = PyPDFLoader("policy.pdf")
documents = loader.load()  # [Document(page_content="...", metadata={"source": ..., "page": 1}), ...]

# Confluence / Notion (via export)
loader = NotionDirectoryLoader("notion_export/")

# GitHub repo
loader = GitLoader(
    clone_url="https://github.com/company/docs",
    branch="main",
    file_filter=lambda file_path: file_path.endswith(".md")
)

from langchain.retrievers import EnsembleRetriever
from langchain.retrievers import BM25Retriever
from langchain.vectorstores import Qdrant

# Dense retriever
vector_retriever = qdrant.as_retriever(search_kwargs={"k": 10})

# Sparse retriever
bm25_retriever = BM25Retriever.from_documents(documents)
bm25_retriever.k = 10

# Hybrid avec pondération 70% dense / 30% sparse
ensemble_retriever = EnsembleRetriever(
    retrievers=[vector_retriever, bm25_retriever],
    weights=[0.7, 0.3]
)

SYSTEM_PROMPT = """
Tu es un assistant expert qui répond aux questions en te basant STRICTEMENT sur le contexte fourni.

RÈGLES OBLIGATOIRES :
1. Réponds UNIQUEMENT avec les informations présentes dans le contexte
2. Si l'information n'est pas dans le contexte, réponds : "Je n'ai pas trouvé cette information dans la documentation disponible."
3. Cite TOUJOURS tes sources au format [Doc: nom_fichier, Page: X]
4. Sois précis et concis (maximum 3 paragraphes)
5. Si plusieurs documents se contredisent, mentionne les deux versions
"""

USER_PROMPT_TEMPLATE = """
Contexte extrait de la documentation :

{context}

---

Question de l'utilisateur : {question}

Réponse (avec citations des sources) :
"""

# Core RAG
pip install langchain langchain-community langchain-openai

# Base vectorielle (choisir une)
pip install qdrant-client  # Qdrant
pip install pinecone-client  # Pinecone
pip install chromadb  # Chroma

# Document loaders
pip install pypdf unstructured python-docx

# Monitoring (optionnel)
pip install langsmith helicone-opentelemetry

# .env
OPENAI_API_KEY=sk-...
QDRANT_URL=https://your-cluster.qdrant.io
QDRANT_API_KEY=your-key

from langchain.document_loaders import DirectoryLoader, PyPDFLoader
import os

# Charger tous les PDF d'un dossier
loader = DirectoryLoader(
    "./documents/",
    glob="**/*.pdf",
    loader_cls=PyPDFLoader,
    show_progress=True
)

documents = loader.load()
print(f"Chargé {len(documents)} pages depuis {len(set([d.metadata['source'] for d in documents]))} fichiers")

# Exemple de document
# Document(
#     page_content="Procédure de remboursement...",
#     metadata={"source": "./documents/policy.pdf", "page": 5}
# )

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,
    chunk_overlap=50,
    length_function=len,
    separators=["\n\n", "\n", ". ", " ", ""]
)

chunks = text_splitter.split_documents(documents)
print(f"{len(chunks)} chunks créés depuis {len(documents)} documents")

# Exemple : 1000 pages → ~5000 chunks de 512 tokens

from langchain.embeddings import OpenAIEmbeddings

# Initialiser le modèle d'embeddings
embeddings_model = OpenAIEmbeddings(
    model="text-embedding-3-small",
    dimensions=1536
)

# Les embeddings seront générés automatiquement lors de l'insertion
# dans la base vectorielle (voir étape suivante)

from langchain.vectorstores import Qdrant
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams

# Connexion à Qdrant
client = QdrantClient(
    url=os.getenv("QDRANT_URL"),
    api_key=os.getenv("QDRANT_API_KEY")
)

# Création de la collection
collection_name = "documentation"

try:
    client.get_collection(collection_name)
    print(f"Collection {collection_name} existe déjà")
except:
    client.create_collection(
        collection_name=collection_name,
        vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
    )
    print(f"Collection {collection_name} créée")

# Indexation des chunks (avec génération automatique des embeddings)
vectorstore = Qdrant.from_documents(
    documents=chunks,
    embedding=embeddings_model,
    url=os.getenv("QDRANT_URL"),
    api_key=os.getenv("QDRANT_API_KEY"),
    collection_name=collection_name,
    force_recreate=False  # Ne pas écraser si existe
)

print(f"Indexation terminée : {len(chunks)} vecteurs")

from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA

# Initialiser le LLM
llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0.1,  # Réponses factuelles
    max_tokens=500
)

# Créer le retriever
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 5}  # Top 5 chunks
)

# Tester le retrieval
query = "Quelle est la procédure de remboursement ?"
relevant_docs = retriever.get_relevant_documents(query)

print(f"Trouvé {len(relevant_docs)} documents pertinents :")
for i, doc in enumerate(relevant_docs):
    print(f"\n[{i+1}] Source: {doc.metadata['source']}, Page: {doc.metadata.get('page', 'N/A')}")
    print(f"Extrait: {doc.page_content[:200]}...")

from langchain.prompts import PromptTemplate
from langchain.chains import RetrievalQA

# Prompt template personnalisé
prompt_template = """Tu es un assistant qui répond précisément basé sur le contexte fourni.

Contexte:
{context}

Question: {question}

Instructions:
- Réponds UNIQUEMENT avec les informations du contexte
- Cite les sources (nom de fichier et page)
- Si la réponse n'est pas dans le contexte, dis "Information non disponible dans la documentation"

Réponse:"""

PROMPT = PromptTemplate(
    template=prompt_template,
    input_variables=["context", "question"]
)

# Créer la chaîne RAG
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",  # Concatène tous les chunks dans le prompt
    retriever=retriever,
    return_source_documents=True,
    chain_type_kwargs={"prompt": PROMPT}
)

# Exécuter une requête
query = "Quelle est la procédure de remboursement ?"
result = qa_chain({"query": query})

print(f"Question: {query}")
print(f"\nRéponse: {result['result']}")
print(f"\nSources utilisées:")
for doc in result['source_documents']:
    print(f"- {doc.metadata['source']} (page {doc.metadata.get('page', 'N/A')})")

"""RAG Production-Ready avec LangChain + Qdrant + OpenAI"""
import os
from typing import List, Dict
import logging
from langchain.document_loaders import DirectoryLoader, PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Qdrant
from langchain.chat_models import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams
from dotenv import load_dotenv

load_dotenv()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class RAGSystem:
    def __init__(self):
        self.embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
        self.llm = ChatOpenAI(model="gpt-4o", temperature=0.1)
        self.collection_name = "documentation"
        self.vectorstore = None

    def index_documents(self, docs_path: str):
        """Phase d'indexation : charge, chunke et indexe les documents"""
        logger.info(f"Chargement des documents depuis {docs_path}")

        # 1. Load
        loader = DirectoryLoader(docs_path, glob="**/*.pdf", loader_cls=PyPDFLoader)
        documents = loader.load()
        logger.info(f"{len(documents)} pages chargées")

        # 2. Chunk
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=512, chunk_overlap=50
        )
        chunks = text_splitter.split_documents(documents)
        logger.info(f"{len(chunks)} chunks créés")

        # 3. Index dans Qdrant
        self.vectorstore = Qdrant.from_documents(
            documents=chunks,
            embedding=self.embeddings,
            url=os.getenv("QDRANT_URL"),
            api_key=os.getenv("QDRANT_API_KEY"),
            collection_name=self.collection_name
        )
        logger.info("Indexation terminée")

    def query(self, question: str, top_k: int = 5) -> Dict:
        """Phase de requête : recherche + génération"""
        if not self.vectorstore:
            # Reconnexion à une collection existante
            self.vectorstore = Qdrant(
                client=QdrantClient(
                    url=os.getenv("QDRANT_URL"),
                    api_key=os.getenv("QDRANT_API_KEY")
                ),
                collection_name=self.collection_name,
                embeddings=self.embeddings
            )

        retriever = self.vectorstore.as_retriever(
            search_kwargs={"k": top_k}
        )

        prompt = PromptTemplate(
            template="""Réponds précisément basé sur le contexte.

Contexte: {context}
Question: {question}

Réponse (avec sources):""",
            input_variables=["context", "question"]
        )

        qa_chain = RetrievalQA.from_chain_type(
            llm=self.llm,
            retriever=retriever,
            return_source_documents=True,
            chain_type_kwargs={"prompt": prompt}
        )

        result = qa_chain({"query": question})

        return {
            "answer": result["result"],
            "sources": [
                {
                    "file": doc.metadata["source"],
                    "page": doc.metadata.get("page"),
                    "excerpt": doc.page_content[:200]
                }
                for doc in result["source_documents"]
            ]
        }

# Usage
if __name__ == "__main__":
    rag = RAGSystem()

    # Phase 1 : Indexation (une fois)
    # rag.index_documents("./documents/")

    # Phase 2 : Requêtes
    result = rag.query("Quelle est la procédure de remboursement ?")
    print(f"Réponse: {result['answer']}")
    print(f"\nSources: {len(result['sources'])} documents")

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor

# Base retriever
base_retriever = vectorstore.as_retriever(search_kwargs={"k": 10})

# Compressor : extrait uniquement les passages pertinents
compressor = LLMChainExtractor.from_llm(llm)

compression_retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=base_retriever
)

# Les chunks retournés sont filtrés/compressés automatiquement

# Pseudo-code Self-RAG
def self_rag(query, vectorstore, llm):
    # 1. Le LLM décide si retrieval est nécessaire
    needs_retrieval = llm.predict(f"Cette question nécessite-t-elle de chercher des documents ? {query}")

    if needs_retrieval:
        docs = vectorstore.search(query)

        # 2. Vérifie si les docs sont pertinents
        relevance_scores = [llm.score_relevance(doc, query) for doc in docs]
        relevant_docs = [doc for doc, score in zip(docs, relevance_scores) if score > 0.7]

        if not relevant_docs:
            return "Information non disponible"

        # 3. Génère réponse
        answer = llm.generate(query, relevant_docs)

        # 4. Vérifie support par les docs
        is_supported = llm.check_support(answer, relevant_docs)

        if not is_supported:
            # Retry avec query réécrite ou retourner "incertain"
            pass

    else:
        answer = llm.generate_direct(query)

    return answer

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# 1. Décomposer la question
decompose_prompt = PromptTemplate(
    template="Décompose cette question en étapes : {question}",
    input_variables=["question"]
)
decomposer = LLMChain(llm=llm, prompt=decompose_prompt)

steps = decomposer.run("Qui est le CEO de l'entreprise qui a acquis Instagram ?")
# Output: ["1. Quelle entreprise a acquis Instagram ?", "2. Qui est le CEO de cette entreprise ?"]

# 2. Résoudre chaque étape
answers = []
for step in steps:
    docs = vectorstore.search(step)
    answer = llm.generate(step, docs)
    answers.append(answer)

# 3. Synthèse
final_answer = llm.synthesize(original_question, answers)

from langchain.chains import HypotheticalDocumentEmbedder

# Générer document hypothétique
hyde_prompt = f"""Génère une réponse plausible à cette question : {query}
(Pas besoin d'être factuel, juste vraisemblable)"""

hypothetical_doc = llm.predict(hyde_prompt)

# Embedder et chercher avec ce document
hyde_embedding = embeddings.embed_query(hypothetical_doc)
results = vectorstore.similarity_search_by_vector(hyde_embedding, k=5)

from langchain.retrievers.multi_query import MultiQueryRetriever

multi_query_retriever = MultiQueryRetriever.from_llm(
    retriever=vectorstore.as_retriever(),
    llm=llm
)

# Génère automatiquement des variantes et fusionne les résultats
docs = multi_query_retriever.get_relevant_documents(
    "Procédure de remboursement ?"
)
# Queries générées :
# - "Comment obtenir un remboursement ?"
# - "Quelle est la politique de retour ?"
# - "Délais de remboursement"
# - "Conditions de remboursement"

from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import BM25Retriever

# 1. Dense retriever (vectoriel)
vector_retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 10}
)

# 2. Sparse retriever (BM25)
# Extraire tous les documents pour construire l'index BM25
all_docs = [chunk.page_content for chunk in chunks]
bm25_retriever = BM25Retriever.from_texts(all_docs)
bm25_retriever.k = 10

# 3. Ensemble avec pondération
ensemble_retriever = EnsembleRetriever(
    retrievers=[vector_retriever, bm25_retriever],
    weights=[0.7, 0.3]  # 70% dense, 30% sparse
)

# Usage
docs = ensemble_retriever.get_relevant_documents("Article L1234-5")

from sentence_transformers import CrossEncoder
import numpy as np

# 1. Retrieval initial (top-10)
initial_results = vectorstore.similarity_search(query, k=10)

# 2. Reranking avec cross-encoder
reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

pairs = [[query, doc.page_content] for doc in initial_results]
scores = reranker.predict(pairs)

# 3. Retrier
ranked_indices = np.argsort(scores)[::-1]  # Descending
reranked_docs = [initial_results[i] for i in ranked_indices[:3]]

print(f"Top 3 après reranking :")
for i, (doc, score) in enumerate(zip(reranked_docs, sorted(scores, reverse=True)[:3])):
    print(f"{i+1}. Score: {score:.3f} | {doc.page_content[:100]}...")

from langchain.retrievers.document_compressors import (
    LLMChainExtractor,
    EmbeddingsFilter
)
from langchain.retrievers import ContextualCompressionRetriever

# Option 1 : Filtre par embeddings (rapide)
embeddings_filter = EmbeddingsFilter(
    embeddings=embeddings,
    similarity_threshold=0.76  # Garder uniquement si >76% similaire
)

# Option 2 : Extraction LLM (précis mais lent)
llm_extractor = LLMChainExtractor.from_llm(llm)

compression_retriever = ContextualCompressionRetriever(
    base_compressor=embeddings_filter,  # ou llm_extractor
    base_retriever=vectorstore.as_retriever(search_kwargs={"k": 10})
)

compressed_docs = compression_retriever.get_relevant_documents(query)
# Résultat : 3-5 docs au lieu de 10, avec uniquement les phrases pertinentes

# Indexation avec métadonnées
for chunk in chunks:
    chunk.metadata["category"] = extract_category(chunk)  # "HR", "Finance", "IT"
    chunk.metadata["date"] = extract_date(chunk)  # "2024-01-15"
    chunk.metadata["confidentiality"] = "public"  # "public", "internal", "confidential"

vectorstore.add_documents(chunks)

# Recherche avec filtres
from qdrant_client.models import Filter, FieldCondition, MatchValue, Range

filter_condition = Filter(
    must=[
        FieldCondition(
            key="metadata.category",
            match=MatchValue(value="Finance")
        ),
        FieldCondition(
            key="metadata.date",
            range=Range(gte="2024-01-01")  # Depuis 2024
        )
    ]
)

results = vectorstore.similarity_search(
    query,
    k=5,
    filter=filter_condition
)

import redis
import hashlib
import json

redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)

def cached_rag_query(query: str, ttl: int = 1800):  # 30 min
    # 1. Générer clé de cache
    cache_key = f"rag:{hashlib.md5(query.encode()).hexdigest()}"

    # 2. Vérifier cache
    cached = redis_client.get(cache_key)
    if cached:
        print("Cache HIT")
        return json.loads(cached)

    # 3. Exécuter RAG si cache MISS
    print("Cache MISS - Exécution RAG")
    result = rag_chain({"query": query})

    # 4. Sauvegarder dans cache
    redis_client.setex(
        cache_key,
        ttl,
        json.dumps(result)
    )

    return result

# Usage
result = cached_rag_query("Procédure de remboursement ?")

from langchain.cache import RedisSemanticCache

# Cache sémantique : questions similaires partagent la réponse
semantic_cache = RedisSemanticCache(
    redis_url="redis://localhost:6379",
    embedding=embeddings,
    score_threshold=0.85  # Si similarité >85%, réutiliser réponse
)

# Questions traitées comme identiques :
# "Comment obtenir un remboursement ?"
# "Procédure pour se faire rembourser ?"
# "Je veux un remboursement, comment faire ?"

# Exemple monitoring avec RAGAS
from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_precision

# Dataset d'évaluation
eval_dataset = {
    "question": ["Procédure de remboursement ?"],
    "answer": ["La procédure est décrite dans..."],
    "contexts": [["Le remboursement s'effectue...", "Délais de 14 jours..."]],
    "ground_truths": ["Pour un remboursement, veuillez..."]
}

# Évaluation
result = evaluate(
    dataset=eval_dataset,
    metrics=[faithfulness, answer_relevancy, context_precision]
)

print(f"Faithfulness: {result['faithfulness']:.3f}")
print(f"Answer Relevancy: {result['answer_relevancy']:.3f}")

import openai
from datetime import datetime
import redis

class CostController:
    def __init__(self, daily_budget: float = 100.0):
        self.daily_budget = daily_budget
        self.redis = redis.Redis()

    def check_budget(self, estimated_cost: float) -> bool:
        today = datetime.now().strftime("%Y-%m-%d")
        spent_key = f"daily_spend:{today}"
        current_spend = float(self.redis.get(spent_key) or 0)

        if current_spend + estimated_cost > self.daily_budget:
            return False  # Budget dépassé

        return True

    def record_spend(self, cost: float):
        today = datetime.now().strftime("%Y-%m-%d")
        spent_key = f"daily_spend:{today}"
        self.redis.incrbyfloat(spent_key, cost)
        self.redis.expire(spent_key, 86400)  # 24h

def safe_llm_call(prompt: str, cost_controller: CostController):
    # Estimer coût (approximatif)
    estimated_tokens = len(prompt.split()) * 1.3  # Rule of thumb
    estimated_cost = (estimated_tokens / 1000) * 0.03  # $0.03/1K tokens

    if not cost_controller.check_budget(estimated_cost):
        return "Budget journalier atteint. Veuillez ressayer demain."

    response = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}]
    )

    cost_controller.record_spend(estimated_cost)
    return response.choices[0].message.content

import hashlib
from datetime import datetime

class IncrementalIndexer:
    def __init__(self, vectorstore):
        self.vectorstore = vectorstore
        self.doc_hashes = {}  # Tracking des versions

    def compute_hash(self, document_path: str) -> str:
        with open(document_path, 'rb') as f:
            return hashlib.md5(f.read()).hexdigest()

    def needs_update(self, document_path: str) -> bool:
        current_hash = self.compute_hash(document_path)
        old_hash = self.doc_hashes.get(document_path)
        return current_hash != old_hash

    def update_document(self, document_path: str):
        if not self.needs_update(document_path):
            print(f"{document_path} - Pas de changement")
            return

        print(f"Mise à jour de {document_path}")

        # 1. Supprimer anciens chunks
        self.vectorstore.delete(filter={"source": document_path})

        # 2. Recharger et ré-indexer
        new_chunks = self.load_and_chunk(document_path)
        self.vectorstore.add_documents(new_chunks)

        # 3. Mettre à jour hash
        self.doc_hashes[document_path] = self.compute_hash(document_path)

        print(f"Indexé {len(new_chunks)} nouveaux chunks")

# Collections versionnées
collections = {
    "docs_v1": "2024-01-15",
    "docs_v2": "2024-01-20",  # Current
    "docs_v3": "2024-01-22"   # Staging
}

# Swap instantané en cas de problème
def rollback_to_previous():
    current = "docs_v2"
    previous = "docs_v1"
    # Update config to point to previous version
    update_config("active_collection", previous)

# Exemple alertes Prometheus
groups:
  - name: rag_alerts
    rules:
      - alert: HighLatency
        expr: histogram_quantile(0.95, rag_query_duration_seconds) > 2
        for: 5m
        annotations:
          summary: "RAG latency P95 > 2s"

      - alert: LowFaithfulness
        expr: avg_over_time(rag_faithfulness_score[10m]) < 0.8
        for: 5m
        annotations:
          summary: "Faithfulness score dropping"

      - alert: HighCosts
        expr: increase(llm_api_cost_total[1h]) > 50
        annotations:
          summary: "LLM costs >$50/hour"