2b1b20cd49
Le RAG n'avait tourne que sur une base a une seule instance -- le cas ou le
post-filtrage HNSW ne se voit pas. 14 tests Testcontainers sur l'image de
`Deployment/Dockerfile.postgres`, donc le meme PostGIS + pgvector que la
prod. Ils se sautent proprement (SkippableFact) sans demon Docker.
Ce que ca etablit :
- pgvector 0.8.6 : `SET hnsw.iterative_scan` est accepte. Ce SET est pose a
chaque recherche par SearchAsync et n'existe qu'a partir de 0.8 -- sur une
version anterieure, toute recherche echouait en production.
- Les extensions vector et postgis sont bien creees par les migrations.
- A deux instances, l'une saturant l'axe de la question a 30 contre 1,
SearchAsync rend le bon nombre de resultats, tous de la bonne instance.
Aucune fuite d'un client vers un autre.
⚠️ DEUX RESULTATS INATTENDUS, contraires a ce que le plan supposait.
1. Ce qui protege du post-filtrage n'est PAS le parcours iteratif, c'est
l'index sur (InstanceId, ContentType). Le planificateur filtre par
instance d'abord et trie exactement : l'index HNSW n'est jamais touche,
donc il n'y a rien a post-filtrer. Verifie a 620 lignes (test) et a
22 000 hors suite, avec 2 000 lignes pour l'instance cible. Un test fige
ce plan -- si cet index disparaissait, la recherche se degraderait sans
qu'aucune erreur ne le dise.
2. Et si on retire cet index, `hnsw.iterative_scan = relaxed_order` NE
RATTRAPE RIEN : le parcours s'epuise apres ~335 lignes sans avoir atteint
l'instance minoritaire, et rend zero. Le meme jeu de donnees avec l'index
HNSW construit APRES l'insertion rend bien ses 20 lignes -- c'est donc la
connectivite du graphe qui decide, et nos migrations creent l'index sur
une table vide. Le SET de SearchAsync est donc une assurance qui ne couvre
pas ce qu'on croyait ; on le garde (il est correct et sans cout), mais
c'est l'index qui fait le travail.
Deux notes d'outillage :
- Testcontainers est epingle en 3.10.0 : la 4.x parle l'API Docker 1.44 et
l'engine local plafonne a 1.43.
- L'image est construite par le CLI docker, pas par le constructeur d'images
de Testcontainers : celui-ci relit le FROM pour pre-tirer l'image de base
et ne sait pas parser `tag@sha256:`. Ce digest protege la base d'un
changement de glibc sous ses index -- il ne se retire pas pour un test.
S'ajoutent 4 tests de GetSummary contre le vrai Postgres, qui levent le
caveat du commit precedent : le provider InMemory evalue tout cote client,
donc il ne disait rien de la traduction SQL. Les agregats du plan de base,
ceux du plan avance, le filtre appType et la fenetre vide traduisent tous.
dotnet test 200/200, aucun saute.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
69 lines
2.7 KiB
C#
69 lines
2.7 KiB
C#
using ManagerService.Data;
|
|
using ManagerService.Services;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace ManagerService.Tests.Infrastructure
|
|
{
|
|
/// <summary>
|
|
/// Embeddings déterministes, sans appel réseau. Le texte pilote directement la
|
|
/// direction du vecteur, ce qui permet d'écrire « ce morceau est proche de cette
|
|
/// question » comme un fait vérifiable plutôt que comme une supposition.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Convention : un texte préfixé <c>axis:N</c> produit le vecteur unitaire de l'axe N,
|
|
/// éventuellement mêlé d'un peu de bruit stable (<c>axis:N#seed</c>). Deux textes sur
|
|
/// des axes différents sont donc quasi orthogonaux — distance cosinus proche de 1.
|
|
/// Ce qui suit les chiffres du seed est ignoré : cela permet d'écrire des textes
|
|
/// distincts qui partagent un même vecteur, sans quoi la déduplication par texte de
|
|
/// <c>SearchAsync</c> écraserait les lignes et fausserait tout comptage de résultats.
|
|
/// </remarks>
|
|
public class FakeEmbeddingService : IEmbeddingService
|
|
{
|
|
public int Dimensions => ContentEmbedding.Dimensions;
|
|
|
|
public Task<float[]> EmbedAsync(string text, CancellationToken cancellationToken = default) =>
|
|
Task.FromResult(Embed(text));
|
|
|
|
public Task<IReadOnlyList<float[]>> EmbedBatchAsync(IReadOnlyList<string> texts, CancellationToken cancellationToken = default) =>
|
|
Task.FromResult<IReadOnlyList<float[]>>(texts.Select(Embed).ToList());
|
|
|
|
public float[] Embed(string text)
|
|
{
|
|
var vector = new float[Dimensions];
|
|
|
|
var axis = 0;
|
|
var seed = 0;
|
|
|
|
if (text != null && text.StartsWith("axis:"))
|
|
{
|
|
var payload = text.Substring("axis:".Length);
|
|
var hash = payload.IndexOf('#');
|
|
if (hash >= 0)
|
|
{
|
|
var digits = new string(payload.Substring(hash + 1).TakeWhile(char.IsDigit).ToArray());
|
|
int.TryParse(digits, out seed);
|
|
payload = payload.Substring(0, hash);
|
|
}
|
|
int.TryParse(payload, out axis);
|
|
}
|
|
else
|
|
{
|
|
axis = Math.Abs((text ?? "").GetHashCode()) % Dimensions;
|
|
}
|
|
|
|
vector[axis % Dimensions] = 1f;
|
|
|
|
// Bruit stable : deux morceaux du même axe ne sont pas strictement identiques,
|
|
// sinon HNSW n'aurait aucun ordre à produire entre eux.
|
|
if (seed != 0)
|
|
vector[(axis + 1 + (seed % 16)) % Dimensions] = 0.01f * (seed % 10);
|
|
|
|
return vector;
|
|
}
|
|
}
|
|
}
|