Documentation vivante · carte technique

Comment LIA est construite, couche par couche

Les couches du système, de l'écran à la base de données, ce que fait chaque brique, avec quelles technologies, où elle vit dans le dépôt, et les chemins qu'emprunte une requête.

  • 59briques techniques
  • 10couches
  • 7parcours commentés
  • 57modules d'infrastructure
  • 63domaines métier servis

Version 4.6.010 novembre 2026tenue à jour à chaque commit, depuis les données du dépôt

Vue d'ensemble

Les couches du système

De l'écran à la base de données. Survole une brique pour tracer ses liens, clique pour ses technologies, ses fichiers et ses décisions.

s'appuie surutilisée par

Clients

Ce que la personne touche : l'application web, son mode hors ligne, les coques mobiles et les canaux de messagerie.

Bordure

Ce qui se tient entre Internet et l'application : tunnel, politique de contenu, débit, sessions.

API et socle applicatif

L'API FastAPI découpée en domaines métier, son flux SSE, son démarrage ordonné et sa configuration.

Orchestration des agents

Le graphe LangGraph : routage, planification ou boucle ReAct, validation humaine, outils et réponse.

Modèles et coûts

L'accès aux modèles de chaque fournisseur, le raisonnement, les sorties structurées, les embeddings, et la comptabilité de chaque appel.

Intégrations

Les clients des services externes, les protocoles ouverts, le bac à sable et les canaux de voix.

Tâches de fond

Ce qui tourne sans requête : ordonnanceur à leader unique, moteur proactif, tâches durables, auto-diagnostic.

Données

Où vit l'état : PostgreSQL et pgvector, Redis, fichiers, et les registres de ce que LIA a fait, lu et décidé.

Observabilité

Mesurer, voir, alerter, relire : métriques, tableaux de bord, alertes, journaux, traces.

Livraison

Comment le code devient un service : images, intégration continue et ses gardes, release qualifiée, installateur, démonstrateur.

Parcours

Choisis un scénario : ses étapes s'allument une à une sur la carte.

Couches

Clique une couche pour l'isoler.

Les parcours

Le chemin d'une requête, d'un appel, d'une livraison

Chaque étape nomme la brique qui agit et ce qu'elle garantit.

Le parcours d'un message de chat

Du clavier à l'écran, en passant par le graphe : une requête, un flux, aucun jeton exposé.

  1. Application web
    Le navigateur envoie le message à l'API de sa propre origine.
  2. Tunnel, CSP et débit
    Le tunnel l'achemine ; le débit de l'appelant est vérifié.
  3. Sessions et authentification
    Le cookie de session est validé côté serveur.
  4. API FastAPI par domaines
    La route du chat ouvre un flux et démarre le graphe.
  5. Graphe LangGraph
    L'état de la conversation est rechargé depuis son checkpoint.
  6. Routeur
    La demande est classée, les outils notés.
  7. Planificateur et exécuteur
    Un plan est écrit, validé, exécuté en parallèle.
  8. Outils et manifestes
    Chaque outil passe la porte d'autorité et s'inscrit au registre.
  9. Clients connecteurs
    Le fournisseur est appelé, sans transaction de base ouverte.
  10. Synthèse de la réponse
    La réponse est synthétisée depuis les résultats.
  11. Streaming SSE
    Elle arrive mot à mot, avec son coût, sur le même flux.

Un appel de modèle, de bout en bout

Borné avant, traduit pour le fournisseur, tarifé à son instant, tracé après.

  1. Prompts versionnés
    Le prompt est assemblé : le stable d'abord, une seule frontière de cache.
  2. Comptabilité et plafonds
    Les deux plafonds — compte et instance — sont interrogés avant la dépense.
  3. Raisonnement
    L'intention de raisonnement est traduite pour ce modèle précis.
  4. Fabrique de modèles
    Le client natif du fournisseur envoie la requête.
  5. Sorties structurées
    Une sortie coupée par la limite de jetons devient un refus explicite.
  6. Comptabilité et plafonds
    L'usage est lu une seule fois et tarifé à la plage horaire de l'appel.
  7. Registres traçables
    Les paramètres réellement envoyés rejoignent le registre de l'appel.
  8. Métriques
    Jetons, latence et coût deviennent des métriques.

Une tâche de fond proactive

Un seul leader, une gigue, une revendication, un envoi soldé depuis son résultat.

  1. Ordonnanceur à leader unique
    Le leader déclenche le balayage, décalé par sa gigue.
  2. Moteur proactif
    Les comptes éligibles sont sélectionnés sous toutes les règles.
  3. Clients connecteurs
    Les sources sont lues, chacune dans une transaction courte.
  4. Fabrique de modèles
    Le message est rédigé sous les plafonds de dépense.
  5. Registres traçables
    L'envoi est revendiqué avant de partir.
  6. Notifications push
    La notification part vers le navigateur ou le téléphone.
  7. Registres traçables
    L'effet est soldé depuis le résultat réel de l'envoi.

Une session Live déléguée

Le parcours délégué : le navigateur parle au fournisseur et chaque demande revient au graphe.

  1. Application web
    La personne ouvre une session Live.
  2. Transports Live
    L'API émet un identifiant à usage unique et rend le mandat de la voix.
  3. Transports Live
    Le navigateur ouvre le transport du fournisseur (WebSocket ou WebRTC).
  4. API FastAPI par domaines
    Une demande déléguée devient un tour de chat ordinaire.
  5. Graphe LangGraph
    Le graphe l'exécute avec ses validations et ses registres.
  6. Transports Live
    La réponse, bornée et aplatie, est rendue à la voix.
  7. Tâches durables
    À la fin, une clôture unique archive, chiffre et relaie.

Du commit à la production

Chaque garde tourne avant le push ; rien n'est publié sans qualification.

  1. Intégration continue et gardes
    Le hook et la CI exécutent les mêmes commandes Task : lint, ratchets, tests.
  2. Intégration continue et gardes
    Sur le tag, les images candidates sont construites et étiquetées par empreinte.
  3. Release, déploiement et installateur
    Une installation jetable qualifie le candidat.
  4. Release, déploiement et installateur
    La release vérifie les preuves et publie les étiquettes de version.
  5. Images et composition
    Les images épinglées sont tirées sur le serveur.
  6. Release, déploiement et installateur
    Le déploiement détaché écrit son verdict dans un fichier relu.
  7. Démonstrateur
    Le démonstrateur est redéployé et vérifié.

Voir, alerter, se diagnostiquer

Chaque signal a un lecteur ; une alerte a un runbook ; LIA lit ses propres preuves.

  1. Métriques
    Les processus publient leurs métriques, mémoire comprise.
  2. Journaux
    Les journaux structurés, sans donnée personnelle, rejoignent Loki.
  3. Tableaux de bord
    Grafana montre chaque sous-système.
  4. Alertes
    Une alerte part avec son runbook.
  5. Auto-diagnostic
    LIA rassemble les preuves de l'incident et le diagnostique.

Exécuter une commande applicative

Identité durable et préconditions actuelles ; une continuation ouverte reste une attente.

  1. Application web
    Le client utilise le catalogue d'opérations proposé à ce compte.
  2. Outils et manifestes
    La déclaration fixe l'opération, le schéma, sa portée et ses capacités requises.
  3. Commandes applicatives durables
    La préparation lie valeurs avant/après, digest, acteur, origine et expiration dans une commande chiffrée.
  4. Validation et brouillons
    Le gate d'effets vérifie l'approbation exacte lorsque l'opération la requiert.
  5. Commandes applicatives durables
    L'exécution relit les droits et capacités ; claim protégé par jeton et compare-and-set du service source protègent leurs frontières respectives.
  6. Sessions et authentification
    Une continuation privée est liée à la session et, si nécessaire, au périphérique adressé ; les secrets restent hors du modèle.
  7. Commandes applicatives durables
    Committed, waiting, conflit, échec et annulation restent des résultats distincts ; une réponse perdue n'est pas rejouée automatiquement.
  8. Application web
    Un signal adressé invalide les ressources concernées ; le client relit leurs requêtes authentifiées.