Rechercher les documents pertinents

Tu as tes chunks dans une base vectorielle. Quand l'utilisateur pose une question, tu dois trouver les chunks les plus pertinents. C'est la recherche semantique : au lieu de chercher des mots exacts, tu cherches des idees proches.

Avec ChromaDB, c'est une seule ligne :

resultats = collection.query(
query_texts=["comment poser un conge"],
n_results=3
)

La reponse contient les documents trouves, leurs metadonnees, et un score de distance (plus c'est petit, plus c'est similaire).

En production, tu ne renvoies pas juste les textes. Tu renvoies un resultat structure avec le texte, la source, et le score. Ca permet d'afficher "Source : faq.txt, pertinence : 0.92" dans l'interface, ce qui donne confiance a l'utilisateur.

Ecris une fonction rechercher(collection, question, k=3) qui utilise ChromaDB pour trouver les k chunks les plus pertinents. Elle renvoie une liste de dictionnaires avec les cles "texte", "source" et "score" (la distance convertie en score de similarite entre 0 et 1 : score = 1 - distance, borne a 0 minimum).

Pour les tests dans le sandbox, ecris aussi une fonction rechercher_simple(base, question, k=3) qui prend la base simulee de l'exercice precedent et fait une recherche naive : elle compte combien de mots de la question apparaissent dans chaque document, et renvoie les k documents avec le plus de mots en commun. Le score est le nombre de mots trouves divise par le nombre de mots de la question.

Exemple :

base = {
"documents": ["Les conges sont de 25 jours par an.", "Le teletravail est possible 3 jours par semaine.", "La cantine ferme a 14h."],
"metadatas": [{"source": "rh.txt"}, {"source": "rh.txt"}, {"source": "pratique.txt"}],
"ids": ["chunk_0", "chunk_1", "chunk_2"],
"count": 3,
}
rechercher_simple(base, "combien de jours de conges", k=2)
renvoie quelque chose comme [
{"texte": "Les conges sont de 25 jours par an.", "source": "rh.txt", "score": 0.6},
{"texte": "Le teletravail est possible 3 jours par semaine.", "source": "rh.txt", "score": 0.2}
]

Tests (4/5)

Retourne les k meilleurs resultats

base = {
    "documents": ["Les conges sont de 25 jours.", "Le teletravail est autorise.", "La cantine ouvre a midi.", "Les reunions sont le lundi."],
    "metadatas": [{"source": "rh.txt"}, {"source": "rh.txt"}, {"source": "pratique.txt"}, {"source": "orga.txt"}],
    "ids": ["c0", "c1", "c2", "c3"],
    "count": 4,
}
r = rechercher_simple(base, "combien de jours de conges", k=2)
assert isinstance(r, list), "La fonction doit retourner une liste"
assert len(r) == 2, f"Avec k=2, on attend 2 resultats, pas {len(r)}"

Format des resultats

base = {
    "documents": ["Document test"],
    "metadatas": [{"source": "test.txt"}],
    "ids": ["c0"],
    "count": 1,
}
r = rechercher_simple(base, "test", k=1)
assert "texte" in r[0], "Chaque resultat doit avoir une cle 'texte'"
assert "source" in r[0], "Chaque resultat doit avoir une cle 'source'"
assert "score" in r[0], "Chaque resultat doit avoir une cle 'score'"

Les resultats sont tries par score decroissant

base = {
    "documents": ["Chat et chien", "Python et code et fonction", "La meteo est belle"],
    "metadatas": [{"source": "a.txt"}, {"source": "b.txt"}, {"source": "c.txt"}],
    "ids": ["c0", "c1", "c2"],
    "count": 3,
}
r = rechercher_simple(base, "code Python fonction", k=3)
assert r[0]["score"] >= r[1]["score"] >= r[2]["score"], "Les resultats doivent etre tries par score decroissant"

Score entre 0 et 1

base = {
    "documents": ["Mot1 mot2 mot3", "Autre chose"],
    "metadatas": [{"source": "a.txt"}, {"source": "b.txt"}],
    "ids": ["c0", "c1"],
    "count": 2,
}
r = rechercher_simple(base, "mot1 mot2 mot3 mot4", k=2)
for res in r:
    assert 0 <= res["score"] <= 1, f"Le score doit etre entre 0 et 1, obtenu {res['score']}"

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

def rechercher(collection, question, k=3):
    resultats = collection.query(
        query_texts=[question],
        n_results=k,
    )
    reponses = []
    for i in range(len(resultats["documents"][0])):
        distance = resultats["distances"][0][i] if "distances" in resultats else 0
        score = max(0, 1 - distance)
        reponses.append({
            "texte": resultats["documents"][0][i],
            "source": resultats["metadatas"][0][i].get("source", "inconnu"),
            "score": round(score, 4),
        })
    return reponses

def rechercher_simple(base, question, k=3):
    mots_question = set(question.lower().split())
    scores = []
    for i, doc in enumerate(base["documents"]):
        mots_doc = set(doc.lower().split())
        mots_communs = mots_question & mots_doc
        score = len(mots_communs) / len(mots_question) if mots_question else 0
        scores.append({
            "texte": doc,
            "source": base["metadatas"][i].get("source", "inconnu") if isinstance(base["metadatas"][i], dict) else "inconnu",
            "score": round(score, 4),
        })
    scores.sort(key=lambda x: x["score"], reverse=True)
    return scores[:k]

← Creer une base vectorielle ChromaDB Assembler le pipeline RAG →

solution.py

Bravo!

Rechercher les documents pertinents

Tests (4/5)

Indices (3 disponibles)

Solution officielle