Service 02

Systèmes agentiques

Graphes d'agents IA : stateful, résilients, monitorés en production.

Livrables
  • Graphe d'agents testé, documenté, déployé
  • Monitoring opérationnel avec SLA défini
  • Suite de tests de résilience (timeouts, retries, fallbacks)
  • Documentation du graphe et runbook d'incident
  • Dashboards Langfuse (traces, coûts, alertes)
Méthode de travail
[phase] cartographie
agent(s)backend-api
skill(s)grill-me
inputdescription_processus · exemples_io · tolérance_risque
→modélise_processus_actuel()
→identifie_decisions_humaines()
→délimite_perimetre_automation()
outputcarte_processus · liste_noeuds · cas_limites[]
[phase] graph_design
agent(s)backend-api
skill(s)improve-codebase-architecture
inputcarte_processus
→define_nodes()
→define_edges(conditions)
→define_shared_state()
→define_guardrails()
outputgraph_spec · matrice_modele_tache
[phase] build_agent (×n)
agent(s)backend-api
skill(s)grill-me
inputnode_spec
→prompt_engineering()
→unit_test(input → output_attendu)
→integrate_in_graph()
↺if test.fail(): fix_prompt(); retry()
outputnode_validé · coverage_ok
[phase] test_resilience
agent(s)security-observability
inputgraph_complet
→simulate_timeout_llm()
→simulate_api_down()
→inject_malformed_output()
→test_guardrails()
↺if graph.fail(case): patch_node(); retest()
outputgraph_resilient · rapport_tests
[phase] integration
agent(s)backend-api
inputapis_client[] · credentials
→build_adapters()
→test_contrats_interface()
→validate_guardrails_irreversibles()
outputadapters_stables · pipeline_connecte
[phase] deploy
agent(s)devops-marketing
inputgraph_resilient · pipeline_connecte
→docker_build()
→scaleway_push()
→langfuse_activate()
→configure_alertes()
outputpipeline_production · dashboards · runbook
[phase] ticketing_continu
agent(s)backend-api·ui-dashboard·devops-marketing
skill(s)grill-me
inputfeature_requests[] · bugs[] · optimisations[]
→create_ticket(request)
→agent_prioritize(tickets[]) → ordered_backlog
→agent_spawn(ticket) → agent.resolve(ticket)
↺grill-me(ticket) → human_review() → if approved: merge_and_deploy()
outputpipeline_améliore_en_continu · zero_regression
Stack habituelle

LangGraph

Orchestration stateful : cycles, branches conditionnelles, checkpointing natif

Claude API (Sonnet / Haiku)

Routing par tâche : Haiku pour le triage rapide, Sonnet pour les décisions complexes

Python ou TypeScript

Selon le contexte existant : LangGraph supporte les deux nativement

Langfuse

Tracing LLM, coût par noeud, détection des noeuds qui échouent le plus souvent

Redis

Persistance d'état inter-sessions, queues de tâches, cache sur les outputs LLM coûteux

Docker + Scaleway

Déploiement reproductible, cloud fr-par, RGPD natif, billing à la seconde

Inputs client
  • Description du processus à automatiser (étapes, décisions, exceptions)
  • Exemples concrets d'inputs et d'outputs attendus
  • Accès aux APIs et systèmes existants (credentials, documentation)
  • Tolérance au risque : quelles actions peuvent être automatisées sans validation humaine
Orchestration

Graphe conditionnel LangGraph : chaque noeud retourne un état typé, l'orchestrateur route vers le noeud suivant selon les conditions. Boucles de correction sur les noeuds critiques : si le validateur rejette l'output, l'extracteur recommence. Guardrail systématique avant toute action externe : email, écriture ERP, paiement. Checkpointing natif : si le process crash, il reprend au dernier noeud stable.

Outputs attendus
  • Graphe d'agents opérationnel en production
  • Suite de tests couvrant les cas nominaux et dégradés
  • Documentation du graphe (noeuds, transitions, état, conditions)
  • Dashboards Langfuse configurés (traces, coûts, latences)
  • Runbook d'incident (pannes, rollback, escalade vers humain)
Mesure du ROI
Temps opérateur80-95% de réduction sur le processus automatisé
Erreurs de saisie0 erreur de saisie manuelle sur les cas nominaux
Disponibilité24/7 sans intervention humaine sur les cas couverts
Coût marginalDécroissant : optimisation continue des prompts via Langfuse
Boucles auto-apprenantes

Traces Langfuse → détection des noeuds fragiles. On identifie les noeuds avec le taux d'erreur ou la latence les plus élevés. Chaque cycle produit une version de prompt améliorée.

Optimisation continue coûts/latence. Les noeuds dont les outputs sont stables migrent vers Haiku. Ceux qui nécessitent du raisonnement restent sur Sonnet. Le coût par run baisse à chaque sprint.

Objectif final

Un pipeline qui tourne sans intervention humaine sur les cas nominaux, alerte sur les cas limites, et coûte de moins en moins cher à mesure que les prompts sont optimisés. L'humain reste dans la boucle pour les décisions à fort enjeu : pas pour les tâches répétitives.

Ressources liées

Automatiser un processus ?

Décrivez le processus. On vous dit ce qu'on peut automatiser.

Décrire mon projet →