Rubrique
IA
Agents, modèles et intégration dans des produits réels.
Articles
46 articles
API ou GPU : le point mort honnête
Le calcul complet du coût par million de tokens d'un modèle auto-hébergé, pourquoi le taux d'utilisation décide de tout, et les raisons autres que le prix qui justifient, ou non, de louer un GPU.
7 minMembres
Étiqueter des images avec un modèle local
Concevoir un étiquetage d'images par un modèle de vision auto-hébergé : vocabulaire fermé, mesure par étiquette, calcul du débit et du coût, et les cas où une API ou un simple classifieur font mieux.
8 minMembres
Rerankers : 200 ms pour combien de points de rappel ?
Ce qu'un reranker peut et ne peut pas améliorer, comment chiffrer son gain en rappel contre son coût en latence, et le calcul qui dit s'il a sa place dans votre pipeline.
8 minMembres
Le RAG n'est pas mort, votre recherche est mauvaise
Pourquoi ni les grandes fenêtres de contexte ni les agents ne suppriment la recherche, comment mesurer le rappel séparément de la génération, et les fondamentaux à corriger avant de changer d'architecture.
7 minMembres
Recherche hybride sur corpus français : ce qu'il faut mesurer
Où la recherche lexicale et la recherche vectorielle cassent chacune sur du français, comment combiner leurs résultats dans PostgreSQL, et le protocole de mesure qui vous dit si l'hybride vaut son coût sur votre corpus.
8 minLecture libre
Identité des agents : qui agit, au nom de qui ?
Pourquoi un agent doté d'un compte de service large devient un adjoint confus, et comment faire porter à chaque appel d'outil l'autorité de l'utilisateur, réduite à la tâche, avec un journal qui nomme les deux.
7 minMembres
Vos descriptions d'outils sont votre vrai prompt
Pourquoi le nom, la description, les paramètres et les retours d'un outil pilotent le comportement d'un agent plus sûrement que le prompt système, et comment les écrire et les tester comme tels.
7 minMembres
Boucle d'agent : conditions d'arrêt et boucles folles
Quelles conditions d'arrêt poser sur une boucle d'agent, comment reconnaître une boucle folle avant la facture, et quoi faire de la session au moment où vous la coupez.
7 minMembres
Grep contre embeddings dans les agents de code
Pourquoi un agent qui persévère avec grep fait souvent aussi bien qu'un index sémantique sur du code, ce que cette persévérance coûte en tours et en tokens, et les cas où l'index redevient nécessaire.
7 minMembres
Mode automatique : classer les actions au lieu de demander
Pourquoi la demande de permission systématique ne protège plus au bout d'une heure, ce qu'un classifieur d'actions rattrape et ce qu'il laisse passer, et comment décider quelles actions lui confier.
8 minMembres
Contrôle d'accès dans un index vectoriel
Pourquoi filtrer après la recherche vectorielle perd des résultats ou fuit, ce que coûte chaque façon de filtrer avant, et comment choisir entre index partagé, partition et index par tenant.
8 minLecture libre
Multi-agents : l'isolation de contexte se paie en coordination
Ce que des sous-agents achètent vraiment, ce qu'ils coûtent en tokens et en coordination, et la règle qui réconcilie « tout dans un seul fil » et « un agent par tâche » : paralléliser la lecture, jamais la décision.
7 minMembres
Sorties structurées : la contrainte dégrade-t-elle la réponse ?
Ce que le décodage contraint garantit et ce qu'il ne garantit pas, les quatre façons dont un schéma mal conçu abîme la réponse, et comment mesurer l'écart entre validité et qualité sur vos propres cas.
7 minMembres
Notes de 1 à 5 : pourquoi le binaire gagne
Une échelle de 1 à 5 déplace le désaccord dans la moyenne, où plus personne ne le voit. Pourquoi un verdict conforme/non conforme par critère se mesure mieux, ce qu'il coûte et où une échelle reste le bon outil.
7 minMembres
Rejouer une session d'agent : journal ou snapshot
Ce qu'un journal d'événements permet sur une session d'agent et qu'un tableau de messages sérialisé interdit, ce que ce journal coûte, et quand le snapshot seul suffit.
6 minMembres
Migrer de modèle sans régression
Pourquoi un prompt n'est pas portable d'un modèle à l'autre, quel protocole d'évaluation suivre avant de basculer, et comment déployer le changement pour pouvoir revenir en arrière.
7 minMembres
Workflow ou agent : le coût de l'autonomie
Ce que vous payez quand vous laissez le modèle choisir l'étape suivante, comment chaque option casse, et la règle pour décider où l'autonomie est justifiée.
7 minLecture libre
Exfiltration par rendu Markdown et liens
Comment un assistant sans aucun outil d'envoi fait sortir des données par une image ou un lien rendus dans votre interface, et pourquoi la parade se place dans le composant de rendu et la politique de contenu plutôt que dans le prompt.
7 minMembres
L'humain dans la boucle : une attente durable, pas un `await`
Comment modéliser une validation humaine pour qu'elle survive aux déploiements, à trois jours d'attente et au double clic, et quand préférer l'annulation à l'approbation.
6 minMembres
Serveurs MCP : une chaîne d'approvisionnement non inventoriée
Pourquoi un serveur MCP est une dépendance qui écrit dans votre prompt et s'exécute avec vos droits, et comment l'inventorier, l'épingler et le relire sans bloquer l'équipe.
8 minMembres
Empoisonnement de mémoire : l'injection qui persiste
Comment une injection lue un jour devient une consigne suivie des semaines plus tard, pourquoi l'analyse session par session ne la voit pas, et quelles règles d'écriture et de lecture ferment le passage.
7 minMembres
Idempotence des appels d'outils
Pourquoi une étape d'agent rejouée envoie deux fois le mail, d'où tirer la clé d'idempotence, et quels outils méritent ce traitement.
6 minLecture libre
L'économie unitaire d'une fonctionnalité LLM
Calculer ce que coûte réellement une requête, une conversation et un utilisateur, pourquoi la moyenne ment, et comment choisir entre forfait, quota et unités vendues pour que la marge survive aux gros consommateurs.
8 minMembres
Quantification : ce que vous perdez vraiment
Ce que la quantification retire à un modèle, pourquoi la perplexité ne le montre pas, et le protocole par paires qui mesure la perte sur votre tâche avant de choisir entre 4 bits, 8 bits ou un modèle plus petit.
8 minMembres
Bac à sable pour agents de code : le réseau avant les fichiers
Pourquoi l'isolation du système de fichiers ne protège pas vos secrets tant que la sortie réseau est libre, et comment construire un bac à sable dont le contrôle d'egress tient, avec ce qu'il coûte au quotidien.
7 minMembres
Cache sémantique : rapide et faux
Pourquoi deux questions proches dans l'espace des embeddings peuvent exiger des réponses opposées, ce qu'un faux succès de cache coûte vraiment, et les rares périmètres où un cache sémantique est défendable.
8 minMembres
Évaluer la recherche avant la génération
Dans un système à recherche documentaire, le rappel de la recherche plafonne la qualité des réponses. Comment mesurer cet étage seul, attribuer chaque échec au bon composant, et éviter de régler un prompt sur un bug de recherche.
7 minMembres
La trifecta létale comme revue de conception
Une revue de trente minutes pour repérer les agents qui cumulent données privées, contenu non fiable et canal de sortie, et choisir laquelle des trois jambes retirer.
8 minLecture libre
Trop d'outils : découverte progressive ou exécution de code
Ce que coûte un catalogue d'outils chargé en entier à chaque tour, et comment choisir entre trois sorties : élaguer, faire découvrir les outils à la demande, ou laisser l'agent écrire du code qui les appelle.
7 minLecture libre
Mémoire d'agent : une écriture fausse vit des mois
Pourquoi une erreur écrite en mémoire persistante est plus grave qu'une erreur de contexte, et le schéma minimal (provenance, date, portée, expiration) pour gérer la fraîcheur, la contradiction et l'oubli.
7 minMembres
Données synthétiques : utiles, puis toxiques
Les requêtes générées par un modèle permettent d'évaluer avant d'avoir des utilisateurs, puis faussent la mesure dès qu'il y en a. Où elles s'écartent du réel, comment mesurer l'écart et quand les retirer.
7 minMembres
CI non déterministe : combien d'essais avant de bloquer un merge ?
L'arithmétique binomiale d'une porte de CI sur des sorties de modèle : pourquoi « tout doit passer » bloque presque toujours, pourquoi « deux essais sur trois » laisse passer les régressions, et quoi bloquer à la place.
7 minMembres
Le bruit d'infrastructure dans vos benchmarks d'agents
Mémoire, CPU, quotas d'API et parallélisme déplacent le score d'un benchmark d'agents de plusieurs points. Comment séparer l'échec du modèle de l'échec de la machine, et mesurer le plancher de bruit avant de comparer.
7 minMembres
Votre juge LLM n'est pas calibré
Un juge LLM est un classifieur : tant que son accord avec un expert n'a pas été mesuré, son taux de réussite ne dit rien. Comment le mesurer, corriger le chiffre affiché, et quand s'en passer.
7 minLecture libre
Routage de modèles : économies réelles, régressions cachées
Un routeur de modèles est un classifieur : comment calculer l'économie qu'il peut rendre, où ses erreurs se concentrent, et quelle évaluation exiger avant de le mettre devant votre trafic.
8 minMembres
« Difficile à évaluer » est un défaut de conception produit
Quand personne ne sait dire si une sortie de modèle est bonne, le problème vient du cadrage de la fonctionnalité, pas de l'outillage. Cinq façons de la recadrer pour qu'elle soit vérifiable, ce qu'on y perd, et quand il faut assumer le flou.
8 minMembres
Anatomie d'une régression silencieuse
Pourquoi une baisse de qualité d'un système à base de LLM ne déclenche aucune alerte, d'où elle vient le plus souvent, et quels signaux et quel hash de version enregistrer pour la voir en heures plutôt qu'en semaines.
7 minMembres
La compaction perd de l'information : laquelle ?
Les six catégories d'information qu'un résumé de conversation laisse tomber, pourquoi ce sont précisément celles dont l'agent a besoin ensuite, et ce qu'il faut écrire hors du contexte pour qu'elles survivent.
7 minLecture libre
Cache de prompt : pourquoi votre taux de succès plafonne
Les trois causes d'un cache de prompt qui ne rend pas (préfixe instable, trafic trop clairsemé pour la durée de vie, ordre des blocs) et le calcul qui dit si le cache vous fait gagner ou perdre de l'argent.
8 minMembres
L'analyse d'erreurs, l'étape que tout le monde saute
Lire cent traces et nommer ce qui casse dit quoi mesurer, ce qu'un tableau de bord de métriques génériques ne dira jamais. La méthode, son coût réel et les façons de la rater.
7 minLecture libre
Garde-fous ou évals : ne pas confondre
Un garde-fou bloque en ligne et se paie en latence et en faux positifs ; une éval mesure hors ligne et ne protège personne. L'arithmétique du taux de base, le coût sur le streaming et la grille pour décider où placer chaque contrôle.
8 minMembres
Pourquoi aucun filtre n'arrête l'injection de prompt
Pourquoi un détecteur probabiliste perd contre un attaquant qui relance autant qu'il veut, ce qu'un filtre apporte malgré tout, et où placer la défense qui tient : dans ce que l'agent a le droit de faire.
7 minLecture libre
Quand le modèle sait qu'il est évalué
Un jeu de test public finit dans les données d'entraînement, et un cas de test trop reconnaissable change le comportement du modèle. Comment détecter les deux effets, construire un jeu privé et décider quand il vaut son coût.
8 minMembres
Le harnais périme plus vite que le modèle
Chaque pièce du harnais d'un agent encode une hypothèse de faiblesse du modèle. Comment les inventorier, les tester par ablation à chaque changement de modèle, et distinguer les béquilles des garde-fous, qui ne périment pas.
7 minMembres
Planifier puis exécuter : un patron de sécurité et ce qu'il interdit
Ce que garantit un plan figé avant toute lecture de contenu non fiable, ce qu'il ne garantit pas sur les arguments, et les fonctionnalités auxquelles il faut renoncer pour en bénéficier.
7 minMembres
GraphRAG : la facture d'indexation et quand elle se rembourse
Le calcul du coût d'un index en graphe construit par un modèle, les deux seules familles de questions qui le remboursent (globales et multi-sauts), et les alternatives moins chères à essayer d'abord.
8 minMembres