Construire un agent de présentation IA : Guide complet du développeur

Les agents IA transforment la manière dont les logiciels créent du contenu. Un agent de présentation IA peut générer, personnaliser et livrer des présentations professionnelles dans le cadre de flux de travail automatisés — des pipelines CRM aux outils de reporting interne.

Ce guide vous accompagne dans la construction d'un agent de présentation prêt pour la production en utilisant l'API 2Slides.

Vue d'ensemble de l'architecture

Un agent de présentation suit généralement ce flux :

User Request → Agent Logic → 2Slides API → Poll Job → Deliver Result
                  ↓
           Context Gathering
           (data, templates, brand assets)

Composants principaux

Gestionnaire d'entrée — reçoit les requêtes de présentation (texte, données, fichiers)
Constructeur de contexte — enrichit les requêtes avec des modèles, des informations de marque, des données
Moteur de génération — appelle l'API 2Slides pour créer des diapositives
Moniteur de statut — interroge le statut de la tâche jusqu'à son achèvement
Couche de livraison — renvoie les liens de téléchargement, envoie par e-mail, publie sur Slack

Pour commencer

1. Obtenez votre clé API

Inscrivez-vous sur 2slides.com et créez une clé API sur 2slides.com/api.

2. Installez les dépendances

npm install node-fetch dotenv

3. Implémentation de base de l'agent

import fetch from 'node-fetch';

class PresentationAgent {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://2slides.com/api/v1';
  }

  async generateSlides({ topic, themeId, language = 'en', resolution = '2K' }) {
    // Step 1: Start generation
    const response = await fetch(`${this.baseUrl}/slides/generate`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        userInput: topic,
        themeId,
        responseLanguage: language,
        resolution,
        mode: 'async'
      })
    });

    const job = await response.json();
    if (!response.ok) throw new Error(job.error || 'Generation failed');

    // Step 2: Poll until complete
    return await this.waitForCompletion(job.jobId);
  }

  async waitForCompletion(jobId, maxWait = 300000) {
    const start = Date.now();
    while (Date.now() - start < maxWait) {
      const response = await fetch(`${this.baseUrl}/jobs/${jobId}`, {
        headers: { 'Authorization': `Bearer ${this.apiKey}` }
      });
      const status = await response.json();

      if (status.status === 'success') return status;
      if (status.status === 'failed') throw new Error('Generation failed');

      await new Promise(r => setTimeout(r, 3000));
    }
    throw new Error('Generation timed out');
  }

  async generateFromFile({ fileUrl, prompt, themeId }) {
    const response = await fetch(`${this.baseUrl}/slides/create-pdf-slides`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        fileUrl,
        userInput: prompt,
        themeId,
        mode: 'async'
      })
    });

    const job = await response.json();
    return await this.waitForCompletion(job.jobId);
  }

  async generateWithDesign({ topic, referenceImageUrl, resolution = '2K' }) {
    const response = await fetch(`${this.baseUrl}/slides/create-like-this`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        userInput: topic,
        designStyle: {
          global: { referenceImageUrl }
        },
        resolution,
        mode: 'async'
      })
    });

    const job = await response.json();
    return await this.waitForCompletion(job.jobId);
  }

  async addNarration({ jobId, mode = 'single', voice = 'Charon' }) {
    const response = await fetch(`${this.baseUrl}/slides/generate-narration`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ jobId, mode, voice, contentMode: 'concise' })
    });

    return await response.json();
  }
}

// Usage
const agent = new PresentationAgent('sk-2slides-xxx');

const result = await agent.generateSlides({
  topic: 'Q1 2026 Business Review',
  themeId: 'mckinsey-theme-id',
  resolution: '2K'
});

console.log('Download:', result.downloadUrl);

Implémentation en Python

import requests
import time

class PresentationAgent:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = 'https://2slides.com/api/v1'
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }

    def generate_slides(self, topic, theme_id=None, language='en', resolution='2K'):
        response = requests.post(
            f'{self.base_url}/slides/generate',
            headers=self.headers,
            json={
                'userInput': topic,
                'themeId': theme_id,
                'responseLanguage': language,
                'resolution': resolution,
                'mode': 'async'
            }
        )
        response.raise_for_status()
        job = response.json()
        return self._wait_for_completion(job['jobId'])

    def generate_from_file(self, file_url, prompt, theme_id=None):
        response = requests.post(
            f'{self.base_url}/slides/create-pdf-slides',
            headers=self.headers,
            json={
                'fileUrl': file_url,
                'userInput': prompt,
                'themeId': theme_id,
                'mode': 'async'
            }
        )
        response.raise_for_status()
        job = response.json()
        return self._wait_for_completion(job['jobId'])

    def _wait_for_completion(self, job_id, max_wait=300):
        start = time.time()
        while time.time() - start < max_wait:
            response = requests.get(
                f'{self.base_url}/jobs/{job_id}',
                headers=self.headers
            )
            status = response.json()
            if status['status'] == 'success':
                return status
            if status['status'] == 'failed':
                raise Exception('Generation failed')
            time.sleep(3)
        raise TimeoutError('Generation timed out')

# Usage
agent = PresentationAgent('sk-2slides-xxx')
result = agent.generate_slides('AI Trends 2026', resolution='4K')
print(f"Download: {result['downloadUrl']}")

Modèles avancés

Modèle 1 : Génération basée sur des modèles

Pré-configurez des thèmes pour différents cas d'utilisation :

const TEMPLATES = {
  'pitch-deck': { themeId: 'apple-id', resolution: '2K' },
  'quarterly-review': { themeId: 'mckinsey-id', resolution: '2K' },
  'training': { themeId: 'corporate-id', resolution: '1K' },
  'social-media': { themeId: 'saul-bass-id', resolution: '4K', aspectRatio: '1:1' },
};

async function generateByType(type, topic) {
  const config = TEMPLATES[type];
  return agent.generateSlides({ topic, ...config });
}

Modèle 2 : Intégration de pipeline de données

Connectez-vous à vos sources de données :

async function weeklyReport(dataSource) {
  // 1. Récupérer les dernières données
  const data = await dataSource.getWeeklyMetrics();

  // 2. Formater comme entrée de présentation
  const topic = `Weekly Report: Revenue $${data.revenue}, Users ${data.users}, Churn ${data.churn}%`;

  // 3. Générer les diapositives
  const result = await agent.generateSlides({ topic, themeId: 'mckinsey-id' });

  // 4. Livrer
  await slackBot.postMessage('#team-updates', `Weekly report ready: ${result.downloadUrl}`);
}

Modèle 3 : Sortie multi-format

Générez des diapositives + narration + vidéo dans un seul pipeline :

async function fullPresentation(topic) {
  // 1. Générer les diapositives
  const slides = await agent.generateSlides({ topic });

  // 2. Ajouter une narration vocale
  await agent.addNarration({ jobId: slides.jobId, mode: 'multi', voice: 'Charon' });

  // 3. Télécharger avec l'audio
  const download = await fetch(`${agent.baseUrl}/slides/download-slides-pages-voices`, {
    method: 'POST',
    headers: agent.headers,
    body: JSON.stringify({ jobId: slides.jobId })
  });

  return download.json();
}

Considérations pour la production

Limitation de débit

Par défaut : 60 requêtes/minute
Gérez les réponses 429 avec un backoff exponentiel
Utilisez le mode asynchrone pour les opérations par lots

Gestion des erreurs

Enveloppez tous les appels API dans des blocs try/catch
Implémentez une logique de réessai pour les échecs transitoires
Enregistrez les ID de tâche pour le débogage

Gestion des coûts

Suivez l'utilisation des crédits par génération
Définissez des alertes budgétaires dans votre tableau de bord 2Slides
Utilisez des résolutions inférieures pour le contenu interne/brouillon

Sécurité

Stockez les clés API dans des variables d'environnement, jamais dans le code
Utilisez uniquement des appels API côté serveur — n'exposez jamais les clés aux clients
Implémentez la signature des requêtes pour les rappels de webhook

Questions fréquentes

Puis-je créer un produit SaaS basé sur l'API 2Slides ?

Oui — l'API est conçue pour une utilisation en production. Il n'y a aucune restriction sur les applications commerciales.

Quelle est la limite maximale de générations simultanées ?

L'API gère les requêtes concurrentes via la limitation de débit. Pour les besoins à volume élevé, contactez l'équipe 2Slides pour les limites d'entreprise.

Existe-t-il un webhook pour l'achèvement des tâches ?

Actuellement, utilisez le polling via le point de terminaison des tâches (jobs endpoint). Le support des webhooks est sur la feuille de route.

Construisez votre agent de présentation — obtenez votre clé API chez 2Slides et commencez à générer des diapositives par programmation.