Paul Dosser
FREN
Retour a l'accueil

Etude de cas - Projet personnel

PipelineAI - Recherche autonome multi-agent

Un systeme qui decompose une question en 4-6 sous-questions, lance des researchers en parallele, fait relire un critic, puis synthetise. Quatre services Docker, un DAG live, et une discipline de couts qui evite les surprises de facturation.

Etapes du DAG
4
Services orchestres
4
Seuil cosine dedup
0.92
Rounds critic
2 max

Le brief

Un agent LLM seul est puissant mais limite. Donne-lui une question complexe, il fonce dans une seule direction, ignore les contradictions, et te rend un brouillon plausible mais opaque. PipelineAI explore l'autre approche : decomposer la question, paralleliser, faire critiquer, synthetiser.

Projet personnel pour pousser l'orchestration multi-agent dans un vrai systeme distribue (Go + Postgres + Redis + Next.js), pas un script Python single-thread.

Le defi

Quand tu lances N researchers en parallele sur la meme question, tu finis avec des doublons, des contradictions silencieuses, et une facture LLM qui explose. Il faut dedup les findings, surfacer les conflits sans les moyenner, et comptabiliser chaque token avant de tout perdre dans un loop infini.

Et le tout doit rester lisible : l'utilisateur veut voir le pipeline raisonner, pas attendre 90 secondes devant un spinner.

La solution

Un DAG a 4 etages (Planner → Researchers x N → Critic → Synthesizer), oriente par un cap dur : le critic peut relancer une investigation, mais jamais plus de 2 rounds. Les contradictions non resolues sortent dans le rapport final, jamais cachees.

Les findings sont embeddes (Voyage 1024d) et dedupliques contre la session via pgvector cosine ≥ 0.92. Les system prompts sont en cache Anthropic. Chaque appel est suivi par tier (input / output / cache-read / cache-write) avec une alerte de spend.

Le pipeline

Quatre etages, orchestres par le backend Go avec sync.WaitGroup pour la phase parallele. Les evenements sont publies sur Redis pub/sub puis streames en SSE vers le DAG visualizer cote front.

  1. Planner

    Etage 1

    Decompose la question initiale en 4 a 6 sous-questions independantes. Un seul appel Claude, sortie schema-validee.

  2. Researchers

    Etage 2 (parallele)

    N goroutines, chacune avec son propre loop web_search → extract claims → embed. Pas de locks : Postgres gere la concurrence et pgvector deduplique.

  3. Critic

    Etage 3

    Croise les findings, detecte les contradictions, peut declencher une re-investigation ciblee. Cape a 2 rounds pour eviter les boucles couteuses.

  4. Synthesizer

    Etage 4

    Assemble le rapport final : claims avec sources, score de confiance par claim, contradictions non resolues surfacees explicitement.

Capture du DAG visualizer de PipelineAI affichant les 4 etages du pipeline en cours d'execution
fig. 01 - DAG visualizer en cours d'execution

Patterns de conception

  • Goroutines + sync.WaitGroup pour la phase parallele : pas de locks, Postgres gere la concurrence
  • Dedup semantique via Voyage embeddings (1024d) + pgvector IVFFlat cosine ≥ 0.92
  • Prompt caching sur tous les system prompts (planner, researchers, critic, synthesizer)
  • Cost tracking par tier de tokens (input / output / cache-read / cache-write) avec alerte de spend configurable
  • SSE → DAG live : l'utilisateur voit chaque noeud changer de couleur en temps reel
  • Contradictions surface, jamais moyennees : le rapport final les rend explicites

Stack technique

  • Go 1.25 (API, orchestration, sync primitives)
  • Claude Sonnet 4.6 + outil web_search_20260209
  • Voyage embeddings (1024 dimensions)
  • PostgreSQL + pgvector (IVFFlat, cosine)
  • Redis (pub/sub + job queue)
  • Next.js 16 + EventSource (SSE) + DAG visualizer
  • Docker Compose + GitHub Actions → GHCR

Resultats

Pipeline complet livre en une journee : 4 agents, 4 services Docker, CI/CD vers GHCR, frontend avec DAG live et streaming SSE.

Demontre une approche systeme : multi-agent + concurrence Go + vector dedup + cost discipline. Pas un wrapper LLM de plus, mais un orchestrateur qui rend le raisonnement transparent.