Communitygithub.com

pattern-ai-labs/built-with-agentcall

Une collection de cas d'utilisation réels construits avec agentcall.dev — chaque dossier est un exemple fonctionnel autonome. Par Pattern AI Labs.

Qu'est-ce que built-with-agentcall ?

Cette compétence permet à un agent IA de rejoindre une réunion et de présenter un document (PDF, PowerPoint, Word) ou un sujet, en agissant comme un présentateur autonome. Elle transforme les entrées en un deck de diapositives, avec narration vocale générée par l'agent, et supporte deux modes d'affichage : le partage d'écran principal (par défaut) ou le mode avatar où le deck apparaît dans la vignette de la caméra. L'agent gère l'intégralité du flux : conversion du document, rédaction des notes de narration (obligatoire pour que le bot parle correctement), prévisualisation locale et lancement en direct dans des réunions Google Meet, Zoom ou Teams. Le contrôle vocal est entièrement piloté par l'agent : les participants peuvent parler au bot, et l'agent interprète les demandes pour avancer les diapositives, répondre aux questions ou suivre des consignes personnalisées (comme ignorer certains sujets). La compétence est conçue pour être robuste : elle refuse de présenter un deck sans notes, ne laisse jamais de bot orphelin en ligne, et protège le travail de rédaction effectué par l'agent. Elle est idéale pour les démonstrations commerciales, les présentations internes ou toutes les situations où un humain veut déléguer la présentation à un assistant IA fiable.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add pattern-ai-labs/built-with-agentcall

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Presenter — présenter un document (ou un sujet) lors d'une réunion

Un bot IA rejoint une réunion et présente : par défaut, le deck passe en grand sur la scène principale de la réunion en tant que partage d'écran, narré par la voix du bot et avançant automatiquement, avec le visage du bot dans une petite vignette de caméra. (Passez --avatar-mode — ou si l'utilisateur dit "rejoins en mode avatar" — pour afficher le deck sur la vignette de la caméra, l'aspect original à une seule vignette). Pas de télécommande non plus.

Modes d'affichage : screenshare est le mode par défaut (diapositives lisibles en plein écran + visage du présentateur) ; avatar mode (--avatar-mode) place le deck uniquement sur la vignette de la caméra. Tout le reste — commande vocale, télécommande compagnon, narration, questions-réponses — fonctionne de manière identique dans les deux modes.

Le cas d'utilisation principal : l'utilisateur fournit un lien de réunion et un document — PDF, PowerPoint ou Word — et le bot le présente. Vous pouvez également démarrer à partir d'un simple sujet.

À faire dans cet ordre (le flux complet — identique à chaque fois, sans détours)

0 · Pré-vol (une fois).

  • Clé API — vérifier dans cet ordre, et NE PAS demander si elle est déjà présente (une configuration, le MÊME fichier qu'utilise AgentCall ; c'est l'ordre exact utilisé par load_api_key) :
    1. ~/.agentcall/config.json existe avec une api_key ? → prêt.
    2. La variable d'environnement AGENTCALL_API_KEY est définie ? → prêt.
    3. Ni l'un ni l'autre ? → demander à l'utilisateur sa clé (gratuite sur agentcall.dev/api-keys) et l'écrire dans ~/.agentcall/config.json (voir Configuration) — en créant ce fichier exactement comme AgentCall le ferait — puis continuer.
  • Dépendances — pip install -r requirements.txt (rapide ; wheels Python purs, pas d'outils système).

1 · Transformer l'entrée en un deck. Vous (l'agent) possédez toujours la narration — ne laissez jamais le bot lire la diapositive à l'écran. Exécutez doc_to_deck.py d'abord, puis regardez ce qu'il a produit :

  • Un .pptx/.ppt, ou un PDF formaté comme des diapositives → afficher les vraies diapositives, mais la narration vous appartient :
    • Si le fichier contient des notes de l'orateur sur chaque diapositive (.pptx uniquement — les notes des .ppt hérités ne peuvent pas être lues ; demandez un .pptx), elles deviennent la narration — vous avez terminé, présentez simplement. Des notes sur SEULEMENT CERTAINES diapositives → le deck est signalé ; rédigez les notes manquantes.
    • S'il n'y a pas de notes, le deck revient signalé needs_narration avec toutes les notes vides (et un decks/<name>/source.json). Rédigez une ligne de notes parlée par diapositive (lisez source.json + jetez un œil aux images des diapositives) avant de présenter — present.py refuse de s'exécuter sur un deck converti non rédigé, donc il n'y a pas de raccourci. La rédaction EST la présentation.
  • Un .docx/.doc, un PDF de type rapport, ou un sujet → rédigez un deck : exécutez doc_to_deck.py --mode generate, lisez decks/<name>/source.json (son texte + les figures extraites) et écrivez decks/<name>/deck.json. N'essayez PAS d'ouvrir ou de rendre le fichier vous-même (pas de pdftoppm, pas d'outils d'image) — source.json est votre entrée. Gardez la rédaction serrée : une idée par diapositive, puces courtes, narration naturelle — ne sur-polissez pas.
  • Le travail rédigé est protégé — mais uniquement dans le dossier de deck PAR DÉFAUT. Réexécuter la conversion (ou present.py --deck <même document>) avec une source inchangée réutilise le deck.json rédigé dans decks/<name>/ — instantané, rien n'est retransformé, votre narration survit. Il ne reconvertit que lorsque le document lui-même a changé (puis rédigez à nouveau — le signal revient). NE PAS passer --out <un dossier différent> pour un document que vous allez rédiger et présenter — un nouveau dossier n'a pas de deck à réutiliser, donc vous obtenez un brouillon aux notes vides (et le véritable deck rédigé devient obsolète). --out est uniquement pour les conversions jetables/d'inspection. Rédigez, présentez et re-présentez à partir du decks/<name>/deck.json par défaut.
  • Détails complets + schéma du deck : sections A et B ci-dessous.

Règles strictes (chacune a déjà brûlé une session réelle — le code en applique la plupart, ne les combattez pas) :

  1. Ne jamais envoyer un document brut en un seul coup dans present.py et partir. Convertissez → vérifiez needs_narration → rédigez les notes → présentez. La sortie de refus (code 2) est votre signal pour rédiger, pas une erreur à contourner.
  2. Ne jamais écraser un deck.json rédigé en reconvertissant. Source inchangée → il est réutilisé automatiquement ; ne supprimez le dossier du deck que si l'utilisateur demande explicitement une nouvelle conversion.
  3. Ne jamais inventer un deck de remplacement ni vous excuser devant la caméra. Si la conversion échoue, present.py se ferme — corrigez l'entrée (ou installez LibreOffice) et relancez. Un bot qui ne rejoint jamais vaut mieux qu'un bot qui a l'air cassé.
  4. Ne jamais laisser un appel en cours d'exécution. present.py arrête la facturation sur chaque chemin de sortie lui-même — mais si VOUS l'avez lancé, confirmez que le processus s'est réellement terminé lorsque la présentation se termine.

1b · Honorez les instructions de l'utilisateur — ses directives façonnent le deck ET la façon dont vous le pilotez. Lorsque l'utilisateur dit quelque chose au-delà de "présente ceci", capturez-le et appliquez-le. Cela atterrit dans l'un des deux endroits :

  • Au moment de la rédaction (intégré dans deck.json) — tout ce qui concerne le contenu ou la diffusion :
    • "fais court / ~5 min / une ligne par diapositive" → écrivez des notes plus courtes ; la durée d'affichage de la diapositive est basée sur la longueur, donc des notes plus courtes = un discours plus rapide. "va en profondeur" → notes plus riches.
    • "dis ‹X› sur la diapositive des prix", "commence par une blague", "insiste sur ‹Y›" → mettez cette ligne dans les notes de cette diapositive spécifique afin qu'elle soit prononcée exactement là où prévu.
    • "saute la diapositive de la feuille de route" → supprimez-la/fusionnez-la lors de la rédaction.
  • Politique de conduite en direct (vous l'appliquez pendant l'exécution) — tout ce qui concerne la réaction dans la salle :
    • "ne réponds pas aux questions sur ‹Z› / les prix / les effectifs" → quand une telle question arrive via heard.jsonl, NE RÉPONDEZ PAS : répondez par une brève déviation ({"cmd":"say","text":"Bonne question — discutons-en en privé."}) au lieu d'une vraie réponse. "reporte toutes les questions-réponses à la fin" → reconnaissez et continuez à présenter plutôt que de répondre en cours de deck.
    • "fais une pause sur la diapositive 3 pour discussion", "n'avance que quand je le dis" → ajustez votre empressement à envoyer next/present. Gardez une courte note mentale de ces règles pour toute la session — elles persistent pendant tout l'appel, pas seulement la première diapositive. Si une demande est ambiguë, demandez à l'utilisateur avant de lancer.

2 · (facultatif) Aperçu — present.py --local --deck <deck> affiche une URL localhost pour le regarder avant de passer en direct.

3 · Lancez en direct, en arrière-plan — python scripts/present.py "<url>" --deck <deck> & (le nom/la voix proviennent de ~/.agentcall/config.json ; --name/--voice remplacent par exécution). Le bot met 30 à 90 secondes à apparaître, puis salue et attend.

4 · Pilotez-le — commencez à surveiller immédiatement. Taillez link/heard.jsonl et répondez dans link/commands.jsonl (protocole complet sous Commande vocale). Il ne démarrera pas tant que vous n'aurez pas répondu present à un "allez-y".

5 · Terminez — il quitte automatiquement et arrête la facturation lorsque tout le monde part, à la limite de temps, ou sur une commande leave. Si vous l'avez lancé, assurez-vous que le processus se termine.

Deux modes (c'est l'idée clé)

ModeCe qu'il faitPar défaut pour
showAffiche les VRAIES pages/diapositives du document sous forme d'images et les montre inchangées.pptx/.ppt, et PDF formatés comme des diapositives
generateAnalyse le document, puis VOUS rédigez un deck significatif (titres, puces, narration parlée) et intégrez les propres figures de la source.docx/.doc, PDF denses/rapports, et sujets

Règle empirique : un fichier qui est déjà un deck de diapositives → affichez-le. Un document (prose) → générez un deck à partir de celui-ci. auto (le mode par défaut) décide par type de fichier, et pour les PDF par la forme de la page (paysage + texte clairsemé = un deck → afficher ; portrait + dense = un document → générer). Remplacez avec --mode show|generate. L'intention de l'utilisateur prévaut toujours ("présente mes diapositives exactement" → afficher ; "résume ça en un deck" → générer).

A) Afficher un deck tel quel (PowerPoint, ou un PDF de type diapositive)

Le mode "show" conserve le design réel de chaque diapositive (une image en plein écran de la diapositive réelle). Ce qu'il dit dépend de si le fichier contient des notes de l'orateur :

python scripts/doc_to_deck.py "/chemin/deck.pptx"      # rendre les diapositives + détecter les notes
  • A des notes de l'orateur sur chaque diapositive (.pptx) → elles sont la narration. Il suffit de présenter :
    python scripts/present.py "<URL_DE_LA_RÉUNION>" --deck decks/deck/deck.json
    
  • Pas de notes — ou notes sur SEULEMENT CERTAINES diapositives → le deck est signalé needs_narration (les diapositives non annotées s'afficheraient autrement dans un silence mort). Rédigez une ligne de notes parlée pour chaque diapositive qui en manque (à partir de decks/<name>/source.json + les images des diapositives), puis présentez le deck.json rédigé. C'est ce qui en fait un présentateur et non un lecteur d'écran.

present.py REFUSE de présenter un deck needs_narration jusqu'à ce que chaque diapositive ait des notes (il se ferme avec une erreur vous pointant vers source.json). Il n'y a pas de repli de type "lire le texte de la diapositive à voix haute" — par conception. Ne donnez donc jamais un fichier brut sans notes à present.py en espérant qu'il parle : convertissez, rédigez les notes, puis présentez le deck.json rédigé. Le refus est le filet de sécurité ; la rédaction est le travail.

B) Générer un deck significatif (Word, PDF dense, ou un sujet)

Un document n'est pas des diapositives — afficher ses pages donne une mauvaise présentation. Donc vous construisez le deck.

  1. Convertissez pour obtenir le contenu source + les figures :
    python scripts/doc_to_deck.py "/chemin/fichier.docx" --mode generate
    # écrit decks/<name>/deck.json — un brouillon mécanique avec des notes VIDES, signalé needs_narration ;
    #   present.py le REFUSE jusqu'à ce que vous rédigiez les notes (c'est l'étape suivante, pas facultative)
    #    et decks/<name>/source.json  ← les sections analysées + les images extraites, pour que vous rédigiez à partir de cela
    #    et decks/<name>/img/         ← les propres figures du document, déjà extraites
    
  2. Rédigez deck.json à partir de source.json — c'est la partie importante. Faites-le bien :
    • Planifiez d'abord, puis remplissez. Créez une diapositive par idée principale. Construisez une checklist mentale des sections/titres du document et assurez-vous que chaque point clé atterrit sur une diapositive — ne laissez rien tomber.
    • Chaque diapositive : un title court, ≤6 bullets courtes, et notes = narration parlée naturelle (1 à 4 phrases ; acronymes épelés phonétiquement comme "A.P.I." pour que la synthèse vocale les prononce correctement).
    • Réutilisez les figures de la source. source.json liste les images extraites du document (dans sections[].images et all_images). Mettez l'image pertinente dans le champ image d'une diapositive — la diapositive affiche alors vos puces à côté de cette figure réelle (une mise en page divisée). N'inventez pas d'images.
    • Ouvrez avec une diapositive d'introduction d'une ligne ; fermez avec une conclusion (le bot part après la dernière diapositive).
  3. Aperçu et présentation (sections C et D). Pour un sujet sans fichier, sautez la conversion et rédigez directement decks/<name>.json.

Schéma JSON du deck (diapositive texte, diapositive image, ou les deux ensemble) :

{
  "title": "Mon exposé",
  "slides": [
    { "title": "Intro", "notes": "Introduction parlée." },
    { "title": "Un point", "bullets": ["phrase courte", "une autre"], "notes": "Narration." },
    { "title": "Avec une figure", "bullets": ["ce qu'elle montre"], "image": "fig1.png", "notes": "Narration." },
    { "image": "slide3.png", "notes": "Une vraie diapositive en plein écran (mode show)." }
  ]
}

(bullets/notes/image tous optionnels ; alias points→bullets, say→notes ; une diapositive avec seulement un titre est une couverture.)

C) Aperçu (recommandé)

python scripts/present.py --local --deck decks/<name>/deck.json     # ou decks/<name>.json, ou un fichier brut

Affiche une URL http://localhost:PORT/?ws=local — ouvrez-la pour voir les diapositives se rendre et avancer automatiquement, sans réunion.

D) Présenter en direct

python scripts/present.py "<URL_DE_LA_RÉUNION>" --deck <fichier-ou-deck> [--mode show|generate]

Les réunions en direct sont interactives par défaut (basées sur le consentement) : le bot rejoint, se présente et attend que quelqu'un lui dise de commencer. Deux façons de le diriger :

  • Par la voix → acheminée vers VOUS (le cerveau). Il n'y a aucune correspondance de mot-clé dans le code. Tout ce qu'un participant dit — une fois qu'il s'adresse au bot par son nom, ou pendant une courte fenêtre de suivi — vous est transmis pour interprétation, et vous répondez avec une commande. Protocole ci-dessous.
  • Par la page de contrôle compagnon (directe). Une page téléphone/navigateur (Préc. / Pause / Suiv. / taper-une-diapo / Redémarrer / Ignorer) dont le lien est déposé par le bot dans le chat de la réunion, et également imprimé dans la console (▸ Page de contrôle : …) — transmettez l'URL de la console directement à l'utilisateur ; la livraison par chat sur Meet peut être peu fiable. Les boutons sont sans ambiguïté et agissent dans le processus, instantanément (ils ne passent pas par vous), ils sont donc le repli fiable et la façon de piloter sans agent attaché.

Le bot quitte automatiquement et arrête la facturation lorsque tout le monde part, à une limite stricte, ou lors d'une sortie propre — un bot orphelin ne peut pas faire grimper les coûts. Ajoutez --auto pour présenter immédiatement sans demander ; --pace <s> définit l'intervalle entre les diapositives.

Commande vocale — VOUS êtes le cerveau (la partie importante)

En mode interactif, le bot transmet ce qu'il entend dans un fichier lien et exécute la commande que vous écrivez en retour. Pas de phrases codées en dur : vous comprenez la demande et décidez de l'action. Exécutez-le en arrière-plan et bouclez :

  1. Démarrez-le (l'interactif est le mode par défaut pour le direct) : python scripts/present.py "<url>" --deck <fichier> & Il imprime deux chemins : link/heard.jsonl (bot → vous) et link/commands.jsonl (vous → bot). Commencez à surveiller immédiatement — le message d'accueil se joue tout seul, mais la présentation ne démarrera pas tant que vous n'aurez pas répondu au premier "allez-y". Lisez uniquement les NOUVELLES lignes (suivez un décalage d'octets/lignes, ou bloquez sur le fichier — ne retraitez pas les anciennes lignes), et répondez dans les ~45 s (après cela, le deck reprend tout seul). La façon efficace, semblable à un événement, de surveiller, sans sondage actif :
    tail -n +1 -f link/heard.jsonl     # diffuse chaque nouvelle phrase comme une ligne ; traitez-la, puis ajoutez votre réponse à link/commands.jsonl
    
    (&/tail sont POSIX — sous Windows, utilisez votre outil d'exécution en arrière-plan et Get-Content link/heard.jsonl -Wait.) present.py exécute tout ce que vous ajoutez à commands.jsonl en ~0,3 s.
  2. Lorsque le bot est interpellé par son nom ("Présentateur, …") — ou pendant la courte fenêtre de suivi après qu'il a fini de parler (le bot écrit "last_spoke_at" dans heard.jsonl) — lisez ce que le participant a dit, interprétez-le et écrivez une réponse sous la forme d'une commande JSON sur sa propre ligne dans commands.jsonl. Ne devinez jamais simplement ce que la personne va demander — si vous n'êtes pas sûr, posez une question de clarification à haute voix :
    {"cmd":"say","text":"J'ai bien compris ? Vous voulez que j'aille à la diapositive 4 ?"}
    
    Utilisez say pour parler ; ne répondez que par une commande à la fois et attendez la prochaine entrée heard avant d'en envoyer une autre.
  3. Gardez une boucle d'interprétation mentale : heard → interprétez → décidez → commands → attendez heard. C'est la boucle qui fait de vous un présentateur.

Protocole commands.jsonl (par ligne, JSON d'objet racine) :

  • {"cmd":"next"} — avance immédiatement d'une diapositive.
  • {"cmd":"prev"} — recule d'une diapositive.
  • {"cmd":"goto","slide":3} — va à un numéro de diapositive spécifique (1-indexé).
  • {"cmd":"pause"} — met la présentation en pause (le bot attend).
  • {"cmd":"resume"} — reprend après une pause.
  • {"cmd":"present"} — commence la présentation (nécessaire après le message d'accueil).
  • {"cmd":"say","text":"…"} — fait dire une phrase au bot immédiatement (ne change pas la diapositive, ne remplace pas la narration). Utile pour les clarifications, les apartés, les blagues.
  • {"cmd":"leave"} — met fin à la présentation et quitte la réunion.
  • {"cmd":"restart"} — revient à la diapositive 1 et recommence.

Protocole heard.jsonl (un objet par ligne, champs clés) :

  • text — la transcription (le bot peut faire des erreurs, surtout sur les noms ou le jargon ; travaillez avec la transcription, ne jugez pas).
  • speaker — un identifiant (nom, étiquette, "vous" si le bot l'a reconnu).
  • slide_at_time — la diapositive visible lorsque la personne a parlé (utile pour "sur cette diapositive…").

Ne répondez JAMAIS à une question sensible en la lisant à voix haute. Au lieu de cela, rédigez une réponse prudente dans "say" — ou, si vos règles le disent, déviez via un court {"cmd":"say","text":"Bonne question — prenons cela hors ligne."}. Vous êtes un présentateur, pas un orateur non filtré.

Configuration (une seule fois, partagée avec AgentCall)

pip install -r requirements.txt                    # dépendances
python scripts/doc_to_deck.py --help               # options et modes de conversion
python scripts/present.py --help                   # options de présentation

Fichier de configuration : ~/.agentcall/config.json (le même fichier exact qu'utilise AgentCall ; si vous avez déjà exécuté un bot AgentCall, les clés et la voix sont déjà là). Contenu par défaut :

{
  "api_key": "votre-clé-ici",
  "name": "Présentateur",
  "voice": "default"
}

Créez-le comme indiqué à l'étape 0 si la clé API n'est pas encore configurée.

Activation de la voix — le bot lit votre nom et votre voix par défaut à partir de ce fichier. Remplacez par exécution avec --name et --voice ; la politique de tarif/redimensionnement de la voix est gérée par AgentCall (le fichier de configuration de l'agent contrôle l'équilibre qualité/coût). Rien d'autre à faire.

Skills associés