139 lignes
5.5 KiB
Python
139 lignes
5.5 KiB
Python
"""Petit RAG local pour Mind sur le serveur Minecraft : fiches Markdown + recherche BM25 en Python pur.
|
|
|
|
Aucune dépendance. Une fiche = un fichier .md :
|
|
# Titre
|
|
mots-cles: a, b, c
|
|
statut: verifie | brouillon
|
|
---
|
|
texte de la fiche
|
|
|
|
Usage :
|
|
base = Base.charger(dossier_fiches)
|
|
fiches = base.rechercher("combien de homes ?") # 0 à 4 fiches
|
|
bloc = bloc_contexte(fiches) # texte à injecter dans le prompt
|
|
"""
|
|
import math
|
|
import re
|
|
import unicodedata
|
|
from collections import Counter
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
|
|
MAX_FICHES = 4
|
|
SCORE_MIN = 2.2 # en dessous : la fiche n'est pas retenue (question hors serveur)
|
|
RAPPORT_MIN = 0.4 # une fiche doit valoir au moins 40 % de la meilleure
|
|
K1, B = 1.4, 0.75
|
|
POIDS_TITRE, POIDS_MOTS = 2, 3
|
|
RACINE = 5
|
|
|
|
VIDES = set("""le la les un une des du de d l au aux et ou a à en y est sont suis es etre ai as avons avez ont
|
|
je tu il elle on nous vous ils elles me te se lui leur mon ma mes ton ta tes son sa ses notre votre nos vos ce cet cette ces
|
|
que qui quoi quel quels quelle quelles quand comment pourquoi ou dont ne pas plus pour par sur sous avec sans dans chez vers
|
|
faut peut peux peuvent veux veut puis fait faire fais dit dis donc mais car si ca cela ici la
|
|
est-ce quoi moi toi font combien stp svp merci salut hello bonjour mind alors aussi trop tres bien the and how what
|
|
""".split())
|
|
_VIDES_N = set()
|
|
|
|
|
|
def normaliser(texte):
|
|
t = unicodedata.normalize("NFD", texte.lower().replace("’", "'"))
|
|
return "".join(c for c in t if unicodedata.category(c) != "Mn")
|
|
|
|
|
|
def _racine(mot):
|
|
# racinisation grossière : pluriel retiré puis troncature à 5 lettres
|
|
# (téléporter / téléportation / téléporte -> telep ; les noms de commandes courts restent intacts)
|
|
if len(mot) > 3 and mot.endswith(("s", "x")):
|
|
mot = mot[:-1]
|
|
return mot[:RACINE]
|
|
|
|
|
|
def jetons(texte):
|
|
global _VIDES_N
|
|
if not _VIDES_N:
|
|
_VIDES_N = {normaliser(m) for m in VIDES}
|
|
mots = re.findall(r"[a-z0-9]+", normaliser(texte).replace("'", " "))
|
|
return [_racine(m) for m in mots if m not in _VIDES_N and len(m) > 1]
|
|
|
|
|
|
@dataclass
|
|
class Fiche:
|
|
id: str
|
|
titre: str
|
|
mots_cles: list
|
|
statut: str
|
|
corps: str
|
|
|
|
def texte_indexe(self):
|
|
return (jetons(self.titre) * POIDS_TITRE
|
|
+ jetons(" ".join(self.mots_cles)) * POIDS_MOTS
|
|
+ jetons(self.corps))
|
|
|
|
|
|
def lire_fiche(chemin):
|
|
brut = Path(chemin).read_text(encoding="utf-8").replace("\r\n", "\n")
|
|
entete, _, corps = brut.partition("\n---\n")
|
|
titre, mots, statut = Path(chemin).stem, [], "verifie"
|
|
for ligne in entete.splitlines():
|
|
if ligne.startswith("# "):
|
|
titre = ligne[2:].strip()
|
|
elif ligne.startswith("mots-cles:"):
|
|
mots = [m.strip() for m in ligne.split(":", 1)[1].split(",") if m.strip()]
|
|
elif ligne.startswith("statut:"):
|
|
statut = ligne.split(":", 1)[1].strip()
|
|
return Fiche(Path(chemin).stem, titre, mots, statut, corps.strip())
|
|
|
|
|
|
class Base:
|
|
def __init__(self, fiches):
|
|
self.fiches = fiches
|
|
self.docs = [Counter(f.texte_indexe()) for f in fiches]
|
|
self.longueurs = [sum(d.values()) for d in self.docs]
|
|
self.moyenne = (sum(self.longueurs) / len(fiches)) if fiches else 1
|
|
n = len(fiches)
|
|
df = Counter(m for d in self.docs for m in d)
|
|
self.idf = {m: math.log(1 + (n - c + 0.5) / (c + 0.5)) for m, c in df.items()}
|
|
|
|
@classmethod
|
|
def charger(cls, dossier):
|
|
return cls([lire_fiche(p) for p in sorted(Path(dossier).glob("*.md"))])
|
|
|
|
def scores(self, question):
|
|
q = set(jetons(question))
|
|
res = []
|
|
for f, d, ln in zip(self.fiches, self.docs, self.longueurs):
|
|
s = 0.0
|
|
for m in q:
|
|
if m in d:
|
|
tf = d[m]
|
|
s += self.idf[m] * tf * (K1 + 1) / (tf + K1 * (1 - B + B * ln / self.moyenne))
|
|
res.append((s, f))
|
|
return sorted(res, key=lambda x: -x[0])
|
|
|
|
def rechercher(self, question, n_max=MAX_FICHES, score_min=SCORE_MIN, rapport_min=RAPPORT_MIN):
|
|
classes = self.scores(question)
|
|
if not classes or classes[0][0] < score_min:
|
|
return []
|
|
meilleur = classes[0][0]
|
|
return [f for s, f in classes[:n_max] if s >= score_min and s >= rapport_min * meilleur]
|
|
|
|
|
|
CONSIGNE_FICHES = (
|
|
"(Cette question concerne le serveur Minecraft : réponds UNIQUEMENT d'après les fiches ci-dessous, "
|
|
"en 2 à 4 phrases, texte simple sans Markdown, sans rien inventer. Si les fiches ne contiennent pas la "
|
|
"réponse, dis « je ne sais pas » et invite à demander à un admin. Une fiche « brouillon » n'est pas "
|
|
"validée : ne l'annonce jamais comme une règle. Ne promets aucune fonction qui n'est pas dans les fiches. "
|
|
"Ne donne jamais d'adresse, de mot de passe ni d'information sur d'autres joueurs.)")
|
|
|
|
CONSIGNE_SANS_FICHE = (
|
|
"(Si la question porte sur les commandes, les règles ou le fonctionnement de CE serveur Minecraft et que "
|
|
"tu n'as pas de fiche à ce sujet, réponds « je ne sais pas » et invite à demander à un admin : n'invente "
|
|
"ni commande, ni limite, ni règle.) ")
|
|
|
|
|
|
def bloc_contexte(fiches):
|
|
"""Texte à insérer dans le prompt : consigne stricte + fiches retenues."""
|
|
parts = [f"=== Fiche : {f.titre}" + (" [BROUILLON non validé]" if f.statut != "verifie" else "") + f" ===\n{f.corps}"
|
|
for f in fiches]
|
|
return CONSIGNE_FICHES + "\n\nFiches du serveur :\n" + "\n\n".join(parts) + "\n\nMessage : "
|