L'IA & l'Automatisation de A à Z
Du Prompt à l'Agent autonome

Définition simple DÉBUTANT

L'IA générative, c'est une catégorie d'intelligence artificielle qui crée du contenu nouveau (texte, image, code, audio, vidéo) à partir d'une demande en langage naturel appelée prompt.

Le moteur central s'appelle un LLM (Large Language Model) : GPT-4, Claude, Gemini, Mistral, Llama… Ce sont des modèles entraînés sur des milliards de textes qui ont appris à prédire le mot suivant d'une séquence.

IA classique vs IA générative — La différence

Les 4 niveaux de maturité IA en entreprise

• Niveau 1 — Chat & assistants : ChatGPT, Claude, Copilot Microsoft 365. Productivité individuelle.
• Niveau 2 — IA intégrée : Chatbot sur site, assistant commercial, résumés automatiques dans un CRM.
• Niveau 3 — Workflows automatisés : Pipelines n8n/Make qui enrichissent des leads, classent des tickets, génèrent des contenus.
• Niveau 4 — Agents autonomes : IA qui prend des décisions, appelle des outils, planifie des actions sur plusieurs étapes.

En 2026, la majorité des entreprises françaises sont entre le niveau 1 et 2. Le vrai différentiel se joue sur les niveaux 3 et 4.

Les 5 acteurs à connaître

Comment choisir son modèle en pratique

J1 — Créer vos comptes 30 MIN

• ChatGPT Plus ou Claude Pro (~20€/mois) : votre terrain de jeu quotidien
• Compte API OpenAI ou Anthropic (crédit de 5-10€ pour tester)
• Compte gratuit sur n8n.cloud ou Make.com
• Installer Cursor ou Claude Code si vous codez

J2-J3 — Maîtriser le prompting ESSENTIEL

La compétence #1 de 2026. Cadre simple :

# Structure universelle d'un bon prompt
RÔLE       : Tu es un [expert métier précis]
CONTEXTE   : Voici la situation [données, historique]
TÂCHE      : Produis [livrable concret]
CONTRAINTES: Ton [formel/casual], longueur [mots],
              format [markdown/JSON/liste]
EXEMPLE    : Voici à quoi ça doit ressembler [exemple]

J4 — Premier appel API réussi INTERMÉDIAIRE

# Python — appel OpenAI le plus simple
from openai import OpenAI
client = OpenAI(api_key="sk-...")

reply = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Tu es un assistant commercial."},
        {"role": "user", "content": "Résume cet email en 3 puces."}
    ]
)
print(reply.choices[0].message.content)

Félicitations, vous venez de faire votre premier appel LLM programmatique. Tout le reste est une variation de ça.

J5 — Premier workflow automatisé 1H

Dans n8n ou Make, construisez ce scénario très simple :

Vous venez d'automatiser un cas d'usage réel en moins d'une heure.

J6-J7 — Premier RAG sur vos docs AVANCÉ

Choix simples pour commencer :

• No-code : GPTs personnalisés ChatGPT, Projets Claude (upload de PDF, le RAG est géré pour vous)
• Low-code : n8n + Qdrant/pgvector + node OpenAI Embeddings
• Code : LlamaIndex ou LangChain en Python/JS

📈 Comment prioriser ? La matrice « Gain / Faisabilité »

Règle : Commencez par 2 Quick Wins pour montrer la valeur, puis 1 Projet phare pour créer du différentiel.

L'analogie de l'examen

Un LLM sans RAG = un étudiant en examen à livre fermé. Il répond avec ce qu'il a appris à l'entraînement. Problème : il ne connaît pas votre entreprise, vos produits, vos process.

Un LLM avec RAG = un étudiant en examen à livre ouvert. Avant de répondre, on lui donne les bonnes pages à consulter. Résultat : réponses ancrées dans VOTRE documentation, moins d'hallucinations.

Comment ça marche en 4 étapes

1. Indexation : on découpe les documents en morceaux (chunks de 300-800 tokens), on les transforme en vecteurs (embeddings).
2. Stockage : dans une base vectorielle (Qdrant, Pinecone, pgvector, Chroma).
3. Recherche : la question est aussi vectorisée. On cherche les 3-5 chunks les plus proches.
4. Génération : on glisse ces chunks dans le prompt, le LLM répond en s'appuyant dessus.

Les pièges courants du RAG

Quand NE PAS faire de RAG

• Peu de documents (< 20 pages) → mettez tout dans le prompt (context window suffit)
• Questions factuelles simples → une base de données + SQL suffit
• Données structurées → SQL généré par LLM (Text-to-SQL)
• Besoin de calcul exact → tool calling vers une fonction, pas de RAG

Chatbot vs Agent : la différence

Le pattern ReAct (Reason + Act)

Le schéma fondateur des agents :

# Boucle ReAct
Thought : Je dois trouver le prix du produit X
Action  : search_catalog("produit X")
Observation : Prix trouvé = 49€

Thought : Maintenant je peux répondre au client
Action  : final_answer("Le prix est 49€.")

L'agent boucle jusqu'à ce qu'il ait la réponse finale. C'est ce qui lui donne son autonomie.

Les frameworks d'agents en 2026

⚠️ Risques spécifiques aux agents

• Boucles infinies : l'agent rappelle le même outil sans progression. Limitez le nombre d'itérations.
• Coûts : chaque itération = appel LLM facturé. Surveillez la consommation.
• Actions irréversibles : suppression fichier, envoi email, paiement. Exigez une confirmation humaine (human-in-the-loop).
• Prompt injection : si l'agent lit des emails / web, un attaquant peut glisser des instructions malicieuses.

Le rôle d'un orchestrateur

Un orchestrateur (aussi appelé outil d'iPaaS) permet de connecter des applications entre elles sans coder (ou presque). Il déclenche un workflow (trigger), passe par des étapes (steps), et exécute des actions.

Le match : n8n vs Make vs Zapier

Comment choisir ?

• n8n : si vous voulez la puissance, la souveraineté, et pouvez mettre les mains dans le cambouis. AVANCÉ
• Make.com : le meilleur compromis visuel/puissance pour les équipes métier. INTERMÉDIAIRE
• Zapier : si vous voulez le maximum de connecteurs sans complexité. DÉBUTANT

Workflows IA classiques à répliquer

1. Lead enrichment : Formulaire → Clearbit → LLM (scoring) → HubSpot
2. Ticket triage : Zendesk → LLM (catégorie + priorité) → Assign auto
3. Content pipeline : Notion brief → LLM (article) → LLM (SEO check) → Notion draft
4. Meeting summary : Fichier audio → Whisper → LLM (CR + tâches) → Slack + Asana
5. Invoice OCR : Email facture → LLM vision (extraction) → BDD compta

Les 4 primitives qu'il faut connaître

• Completion / Chat : l'appel principal pour générer du texte.
• Streaming : réception progressive du texte (UX type ChatGPT).
• Tool / Function calling : le LLM peut demander d'appeler une fonction.
• Structured outputs : forcer la sortie en JSON valide selon un schéma.

Pattern 1 — Structured output (extraction fiable)

# On demande au LLM d'extraire les infos d'un email
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": email_text}],
    response_format={"type": "json_schema", "json_schema": {
        "name": "contact_info",
        "schema": {
            "type": "object",
            "properties": {
                "nom": {"type": "string"},
                "email": {"type": "string"},
                "intention": {"type": "string",
                    "enum": ["devis", "support", "autre"]}
            }
        }
    }}
)

Zero parsing manuel : vous récupérez un objet JSON toujours valide.

Pattern 2 — Tool calling (donner des super-pouvoirs)

# Vous définissez des outils. Le LLM choisit quand les appeler.
tools = [{
    "type": "function",
    "function": {
        "name": "get_client_info",
        "description": "Récupère les infos d'un client par ID",
        "parameters": {"type": "object",
            "properties": {"id": {"type": "string"}}}
    }
}]

# Le LLM décide s'il appelle get_client_info ou pas

C'est la brique de base de tous les agents IA.

Maîtriser les coûts

• Utilisez le plus petit modèle qui fait le job. Haiku/mini pour 80% des cas.
• Activez le prompt caching (Anthropic, OpenAI) : 90% d'économie sur les prompts répétés.
• Coupez les context inutiles. Chaque token compte.
• Loggez tout : prompts, tokens, coût, latence. Outils : Langfuse, Helicone.

Le stack technique type en 2026

• SDK officiels : openai, anthropic, @google/generative-ai
• Abstraction multi-provider : LiteLLM, OpenRouter
• Framework agent : LangGraph, LangChain, LlamaIndex
• Vector DB : pgvector (simple), Qdrant (perf), Pinecone (SaaS)
• Observabilité : Langfuse, Helicone, LangSmith

Étape 1 — Définir un cas d'usage mesurable

• Quel problème métier on résout ?
• Quel KPI on améliore ? (temps, coût, taux de conversion)
• Qui est l'utilisateur final ?
• Quel est le baseline (performance actuelle) ?

Étape 2 — POC rapide (2-4 semaines)

• Prototype no-code si possible (Make, n8n, GPTs) pour aller vite
• Testez sur 20-50 cas réels, pas sur des jeux synthétiques
• Décision Go/No-Go basée sur 3 critères : qualité, coût, faisabilité

Étape 3 — Pilote avec utilisateurs réels (1-3 mois)

• Choisir 5-10 utilisateurs volontaires
• Mettre en place un système de feedback (pouce haut/bas, commentaires)
• Mesurer le taux d'adoption réel (pas les déclarations d'intention)
• Itérer très vite sur les prompts et le RAG

Étape 4 — Industrialisation (3-6 mois)

• Versioning des prompts (git + outils comme Langfuse)
• Monitoring : latence, coût, qualité, erreurs
• Tests de régression automatiques à chaque changement
• Guardrails : filtres PII, modération, rate limit
• Gouvernance : qui valide, qui monitore, qui assume le risque

Étape 5 — Scale & run

• Formation des utilisateurs — l'IA change les gestes métier
• Conduite du changement — ne pas sous-estimer les résistances
• Amélioration continue — cycle mensuel de review prompts/data
• Ouverture à de nouveaux cas d'usage

Mois 1 — Fondations DÉBUTANT

• Sem 1 : Maîtriser ChatGPT/Claude en usage quotidien, 20 prompts/jour
• Sem 2 : Suivre un cours prompt engineering (Anthropic Academy, DeepLearning.ai)
• Sem 3 : Premier appel API OpenAI/Anthropic en Python ou JS
• Sem 4 : Premier workflow n8n ou Make avec un nœud LLM

Mois 2 — Intégration INTERMÉDIAIRE

• Sem 5-6 : Premier RAG — indexer 20-50 documents, répondre dessus
• Sem 7 : Premier tool calling — faire appeler une API par le LLM
• Sem 8 : Premier agent ReAct simple — 2-3 outils, boucle limitée

Mois 3 — Projet réel AVANCÉ

• Sem 9-10 : Choisir un cas d'usage métier réel, faire le POC
• Sem 11 : Observabilité (Langfuse), tests, évaluation qualité
• Sem 12 : Présenter à un utilisateur réel, recueillir feedback, itérer

Ressources de référence à bookmarker