Alternative F : BM25 + embedding + reranker + validator

Flux

raw chunkText  
  -> BM25 top 80  
  -> embedding top 80  
  -> union des candidats  
  -> le reranker compare directement le raw chunk avec chaque candidat JSONL  
  -> renvoie le top JSONL  
  -> le validateur Qwen direct‑evidence effectue la vérification directe des preuves

Répartition des rôles

BM25:

Trouver la chaîne exacte / le candidat du jeton API.

code embedding:

Compléter les candidats dont l'expression diffère mais dont le sens est proche.

reranker:

BM25 et embedding réorganisent les candidats en les comparant aux morceaux bruts.

Validateur de preuves directes Qwen :

Vérifiez s'il existe une correspondance directe de chaîne/modèle dans le JSONL pour le chunk actuel.  
Les JSONL sans preuve sont rejetés.

Alignement attendu dans le chunk de référence

Candidats à faire remonter en haut :

first_2d_game / coding_the_player
same page / clamp and AnimatedSprite2D explanation

Candidats à réduire :

first_3d_game / player_movement_code
unrelated api_mapping
unrelated label_prototypes

Simulation PoC

Supposons que le chunk de référence soit intégré dans le flux de recommandation final.

raw chunkText
  -> BM25 top 80
  -> voyage-code-3 embedding top 80
  -> candidat union
  -> reranker
  -> Qwen direct-evidence validator

Étape 1 : Candidats BM25

Candidats que BM25 va récupérer :

A. first_2d_game / coding_the_player
   reason: Input.is_action_pressed, move_left, move_right, AnimatedSprite2D.play/stop

B. first_2d_game / clamp section
   reason: position.clamp, Vector2.ZERO, screen_size

C. first_3d_game / player_movement_code
   reason: Input.is_action_pressed, move_left, move_right, normalized

2ème étape : candidats d'embedding

candidats que l'embedding apportera :

D. first_2d_game / movement explanation
   reason: 2D movement, keyboard input, animation

E. first_2d_game / screen bounds explanation
   reason: keep player inside screen

F. first_3d_game / movement
   reason: player movement semantic similarity

Étape 3 : union des candidats

Après l'union, les doublons sont fusionnés.

A/D -> first_2d_game / coding_the_player
B/E -> first_2d_game / clamp/screen bounds
C/F -> first_3d_game / player_movement

Étape 4 : réordonnancement du reranker

Le reranker examine le raw chunk et les candidats ensemble.

Rerank prévu :

rerank	candidat	raison
1	`first_2d_game / coding_the_player`	Traitement des entrées, velocity, AnimatedSprite2D play/stop sont directement corrects

| 2 | first_2d_game / clamp/screen bounds | position.clamp, Vector2.ZERO, screen_size correspondent directement | | 3 | first_3d_game / player_movement | L'entrée/le déplacement est similaire mais c'est un contexte 3D et il n'y a pas d'AnimatedSprite2D/screen_size |

Étape 5 : Qwen direct‑evidence validator

Le validateur Qwen demande comme suit.

En examinant le SOURCE_CODE et le JSONL récupéré,  
le JSONL contient-il une correspondance directe de chaîne/appel d'API/pattern avec le SOURCE_CODE ?  
Déterminez d'abord par Oui ou Non.

Contenu manquant : aucun fragment Markdown fourni.

first_2d_game / coding_the_player:
  validator = oui
  direct evidence = Input.is_action_pressed, AnimatedSprite2D.play, AnimatedSprite2D.stop

first_2d_game / clamp/screen bounds:
  validator = oui
  direct evidence = position.clamp, Vector2.ZERO, screen_size

first_3d_game / player_movement:
  validator = non ou pertinence faible
  reason = l'entrée de mouvement est similaire mais il s'agit d'une documentation 3D et il n'y a aucune preuve directe d'AnimatedSprite2D/screen_size

Journaux à vérifier dans le PoC

Cette alternative comporte de nombreuses étapes, il faut donc tout voir sur un seul écran.

1. raw chunkText  
2. candidats BM25 et termes correspondants  
3. candidats d'embedding et similarité  
4. résultat de l'union  
5. score du reranker et changement de rang  
6. validateur Qwen oui/non  
7. JSONL d'acceptation/rejet final

Conclusion visible :

BM25 et l'embedding rassemblent largement les candidats.  
Le reranker corrige l'ordre des candidats similaires.  
Le validateur Qwen supprime définitivement le JSONL sans preuve directe.

Avantages

Il est très probable que la qualité soit la meilleure.
Il est possible de réduire les faux positifs BM25.
Il est également possible de réduire les faux positifs d'embedding.
Les conditions de raw chunk sont maintenues.
La dépendance au codage en dur est faible.
On peut supprimer les JSONL sans justification directe à la fin avec le validateur Qwen.

Inconvénients

Cela engendre des coûts.
Cela introduit de la latence.
Si l’on ajoute trop de candidats, cela devient lent.
Le reranker n'étant pas un vérificateur de preuves, un validateur final est nécessaire.

Jugement

Recommandation finale : Qualité prioritaire

La recommandation finale de la note originale est proche de cette structure.