Crée un agent IA qui génère des flipbooks

Et si “publier le rapport de ce mois sous forme de flipbook” était une tâche que ton ordinateur accomplissait tout seul — sans tableau de bord, sans import, sans copier-coller un lien de partage dans un e-mail ? C'est la promesse d'un agent IA pour tes documents : tu décris le résultat attendu, et l'agent appelle les bons outils dans le bon ordre pour y parvenir.

Ce tutoriel montre comment en créer un avec le serveur MCP FlipLink et Claude. L'agent va récupérer un rapport PDF fraîchement généré, en créer un flipbook, le publier et te renvoyer un lien de partage — le genre de chose que tu peux lancer selon une planification et oublier ensuite. On sera aussi honnête sur les limites réelles d'un agent entièrement autonome, et sur les cas où un simple script (le CLI) est l'outil le mieux adapté.

Le scénario : un rapport mensuel publié automatiquement

Imagine une tâche récurrente. Le premier de chaque mois, un pipeline produit report.pdf — des chiffres de vente, une newsletter, un board deck. Aujourd'hui, un humain l'importe dans le tableau de bord, le publie, copie le lien et le colle quelque part. On veut automatiser tout ça avec un agent capable de raisonner sur les étapes plutôt que de coder chacune d'elles en dur.

L'agent doit pouvoir : créer un flipbook à partir du fichier, le publier et récupérer le lien de partage. Avec le serveur MCP FlipLink connecté, ces actions correspondent à de vrais outils que le modèle peut appeler directement.

Étape 1 — Brancher le serveur MCP

Le Model Context Protocol, c'est la façon dont un client IA (Claude, Cursor et d'autres) découvre et appelle des outils externes. Le serveur MCP FlipLink expose l'API FlipLink sous forme d'un ensemble d'outils que le modèle peut utiliser dans une conversation.

Pour la marche à suivre complète, consulte Connecter FlipLink à Claude avec le serveur MCP. En résumé — rien à installer à la main, ton client le lance avec npx :

claude mcp add fliplink -e FLIPLINK_API_KEY=YOUR_API_KEY -- npx -y fliplink-mcp

Ou, sous forme d'un bloc de configuration mcpServers (Claude Desktop, Cursor, Codex) :

{
  "mcpServers": {
    "fliplink": {
      "command": "npx",
      "args": ["-y", "fliplink-mcp"],
      "env": { "FLIPLINK_API_KEY": "YOUR_API_KEY", "FLIPLINK_MCP_MODE": "safe" }
    }
  }
}

Les outils sont générés à partir de la spécification FlipLink et nommés <noun>_<verb> — l'agent verra donc flipbook_create_by_file, flipbook_publish, flipbook_get_share_link, et un contrôle de santé whoami au niveau supérieur, entre autres. Récupère ta clé en te connectant sur go.fliplink.me.

Étape 2 — Rédiger le prompt de l'agent

Un agent n'est en réalité qu'un modèle plus une boucle : il lit l'objectif, décide quel outil appeler, lit le résultat, puis décide de la suite jusqu'à ce que l'objectif soit atteint. La qualité de cette boucle vient presque entièrement d'un prompt clair qui nomme les outils, l'ordre et la condition de réussite.

Voici un prompt système/tâche réaliste pour l'agent de rapport mensuel :

SYSTEM:
You are a publishing agent for FlipLink. Your job is to turn a PDF report
into a published flipbook and return its share link. You have FlipLink MCP
tools available (names follow the pattern noun_verb).

Operating rules:
1. Start by calling `whoami` to confirm the API key works and check the
   remaining flipbook quota. If `whoami` fails, STOP and report the error.
2. Create the flipbook from the file with `flipbook_create_by_file`
   (field File = the PDF path; set Name and Title from the task).
3. Read the result. Every FlipLink response has a top-level `Result` field
   that is "OK" or "ERROR". If `Result` is "ERROR", STOP and report the
   `Message` — do NOT retry blindly or proceed.
4. On success, capture the returned flipbook ID.
5. Publish it with `flipbook_publish` using that ID. Check `Result` again.
6. Fetch the share link with `flipbook_get_share_link`.
7. Report back: the flipbook ID, the published share URL, and the quota left.

Never invent tool names or IDs. If a step has no clear next action,
stop and explain rather than guessing.

TASK:
Publish this month's report. File: ./reports/2026-06-report.pdf
Title: "June 2026 Report". Name: "june-2026-report".

Deux éléments rendent ce prompt efficace. D'abord, il dit à l'agent de se brancher sur le champ Result — FlipLink renvoie les erreurs applicatives sous forme de HTTP 200 avec Result: "ERROR", donc une vérification naïve du type “l'appel a-t-il renvoyé 200 ?” traiterait silencieusement des échecs comme des réussites. Ensuite, il fournit une condition d'arrêt explicite pour chaque chemin d'échec, ce qui évite qu'une exécution sans surveillance ne dérape en cascade de relances.

Étape 3 — Des garde-fous pour les exécutions sans surveillance

C'est là qu'il faut être lucide. Le mode MCP par défaut est safe (79 outils) : les lectures plus les écritures réversibles, sans suppression et sans outils commerciaux. Notre agent de rapport mensuel se contente de créer, publier et lire — toutes ces actions entrent dans le mode safe — donc pour cette tâche, tu peux laisser le réglage par défaut et l'agent s'exécute de bout en bout sans friction.

Les actions destructives, c'est une autre histoire. Si ton agent doit un jour supprimer un flipbook ou toucher à la tarification/aux ventes, il doit s'exécuter en mode full (87 outils). En mode full, les outils de suppression et liés à l'argent ne s'exécutent jamais au premier appel : le serveur renvoie un aperçu d'une ligne plus un confirm_token éphémère (lié aux arguments exacts, expirant au bout de 5 minutes), et l'assistant doit rappeler avec ce token. Ce garde-fou vit dans le serveur — l'API FlipLink elle-même reste inchangée.

Sois honnête sur ce que ça implique pour le “tout autonome” :

• Un agent qui lit, crée et publie en mode safe peut s'exécuter proprement sans surveillance. Rien de ce qu'il fait n'est soumis à un garde-fou.
• Un agent qui supprime des choses ne peut pas être à la fois sans friction et sans surveillance. Le garde-fou du confirm-token est là exprès. Soit un humain approuve l'étape destructive, soit ton harness s'exécute en mode full et gère explicitement dans le code la séquence aperçu → confirm-token → second appel. Ne conçois pas un pipeline qui suppose qu'un flipbook va se supprimer silencieusement sans confirmation — ça n'arrivera pas, et c'est tout l'intérêt.

Pour le détail complet des modes et du flux du confirm-token, consulte Sécurité et garde-fous du serveur MCP. Les outils portent aussi des annotations MCP (readOnlyHint, destructiveHint, idempotentHint) pour qu'un harness prudent puisse évaluer le risque avant d'appeler quoi que ce soit.

🚀

Essaie FlipLink gratuitement

Convertis ton PDF en quelques secondes. Sans inscription, sans carte bancaire — il suffit de téléverser.

Drop your PDF here or click to browse

Max 40 Mo

Les forfaits payants à partir de $39 font passer cette limite à 150 MB.

Étape 4 — Le planifier

Une fois que l'agent tourne de façon fiable à la main, mets-le sur un minuteur. La manière de faire dépend de ton client — une tâche cron qui invoque Claude sans interface avec le prompt de tâche, un workflow planifié, ou ta propre orchestration. Les détails techniques sortent du cadre ici ; l'important, c'est que ce sont le prompt et le mode qui rendent une exécution planifiée sûre, pas le planificateur lui-même. Garde l'agent en mode safe pour les tâches de création/publication, et l'exécution reste sans surveillance sans se heurter à un mur de confirmation.

Étape 5 — Vérifier le résultat

Ne te fie pas à “l'agent a dit que ça a marché”. Vérifie l'artefact réel :

• Le rapport final de l'agent doit inclure un identifiant de flipbook et une URL de partage. Ouvre l'URL — elle doit charger le flipbook publié.
• Vérifie le quota whoami avant et après, pour t'assurer que la création a bien consommé un slot plutôt que d'échouer silencieusement.
• Comme chaque résultat d'outil porte un champ Result, un agent bien conçu fait remonter le Message exact en cas d'échec. Si l'exécution renvoie Result: "ERROR", lis le message plutôt que de relancer — une limite de quota ou un fichier trop volumineux ne se corrigera pas tout seul à la prochaine tentative.

Quand le CLI est l'outil le mieux adapté

Voici le contre-point honnête à tout ce qui précède : pour une tâche sans interface et déterministe dans la CI, tu n'as généralement pas besoin d'un agent LLM du tout.

Un agent IA brille quand la tâche demande du jugement — décider du titre à donner à quelque chose, réagir à une entrée ambiguë, ou enchaîner des étapes que tu n'as pas entièrement détaillées. Mais “prends ce fichier précis, crée un flipbook, publie-le, affiche le lien” n'a aucune ambiguïté. Faire tourner un LLM pour ça ajoute du coût, de la latence et de la non-déterminisme sans aucun bénéfice, et tu dois quand même gérer le même branchement sur Result.

Pour ça, tourne-toi vers le CLI FlipLink. Il est généré à partir de la même spécification que le serveur MCP et l'API, donc il ne peut pas dériver, et il renvoie des codes de sortie propres (0 succès, 1 erreur de requête, 2 erreur applicative) sur lesquels la CI peut se brancher sans aucun parsing :

fliplink config set-key "$FLIPLINK_API_KEY"
ID=$(fliplink flipbook create ./reports/2026-06-report.pdf \
  --title "June 2026 Report" --name june-2026-report --json | jq -r '.ID')
fliplink flipbook publish "$ID"
fliplink flipbook share-link "$ID"

Voilà toute la tâche mensuelle, sans modèle requis. Pour un pipeline complet — y compris son exécution au sein de l'intégration continue — consulte Automatiser la publication de flipbooks en CI/CD.

Règle générale : utilise un agent IA quand la tâche demande du jugement ; utilise le CLI quand elle doit être identique à chaque fois. Beaucoup d'équipes utilisent les deux — l'agent pour les demandes ponctuelles du type “publie-moi ça”, le CLI pour les exécutions planifiées et mécaniques.

Commence à construire

Un agent IA pour tes documents supprime tout le travail manuel intermédiaire de la publication : tu énonces le résultat, il appelle les outils. Avec FlipLink MCP en mode safe, un agent de création et de publication s'exécute de bout en bout sans friction — et là où des actions destructives entrent en jeu, le garde-fou du confirm-token rend les exécutions sans surveillance honnêtes plutôt que dangereuses.

Prêt ? Connecte le serveur MCP, pointe un agent vers un rapport, et regarde-le publier. Pour le chemin CI déterministe, la documentation du CLI t'accompagne. Le catalogue complet des endpoints se trouve dans la référence de l'API.

Lectures complémentaires

• Connecter FlipLink à Claude avec le serveur MCP
• Sécurité et garde-fous du serveur MCP
• Automatisation de flipbooks en langage naturel
• Automatiser la publication de flipbooks en CI/CD
• La documentation du CLI FlipLink
• La référence de l'API FlipLink