Einen KI-Präsentationsagenten entwickeln: Vollständiger Entwickler-Leitfaden

KI-Agenten revolutionieren die Art und Weise, wie Software Inhalte erstellt. Ein KI-Präsentationsagent kann professionelle Folienpräsentationen generieren, anpassen und bereitstellen, als Teil automatisierter Workflows — von CRM-Pipelines bis hin zu internen Reporting-Tools.

Dieser Leitfaden führt Sie durch die Entwicklung eines produktionsreifen Präsentationsagenten mithilfe der 2Slides API.

Architekturübersicht

Ein Präsentationsagent folgt typischerweise diesem Ablauf:

Benutzeranfrage → Agentenlogik → 2Slides API → Job abfragen → Ergebnis liefern
                      ↓
               Kontextsammlung
               (Daten, Vorlagen, Marken-Assets)

Kernkomponenten

Input-Handler — empfängt Präsentationsanfragen (Text, Daten, Dateien)
Kontext-Builder — bereichert Anfragen mit Vorlagen, Markeninformationen, Daten
Generierungs-Engine — ruft die 2Slides API auf, um Folien zu erstellen
Status-Monitor — fragt den Job-Status bis zum Abschluss ab
Bereitstellungsschicht — gibt Download-Links zurück, versendet per E-Mail, postet auf Slack

Erste Schritte

1. API-Schlüssel erhalten

Registrieren Sie sich auf 2slides.com und erstellen Sie einen API-Schlüssel unter 2slides.com/api.

2. Abhängigkeiten installieren

npm install node-fetch dotenv

3. Grundlegende Agentenimplementierung

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);

Python-Implementierung

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']}")

Fortgeschrittene Muster

Muster 1: Vorlagenbasierte Generierung

Konfigurieren Sie Themen für verschiedene Anwendungsfälle vor:

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 });
}

Muster 2: Integration in Datenpipelines

Verbinden Sie sich mit Ihren Datenquellen:

async function weeklyReport(dataSource) {
  // 1. Fetch latest data
  const data = await dataSource.getWeeklyMetrics();

  // 2. Format as presentation input
  const topic = `Weekly Report: Revenue $${data.revenue}, Users ${data.users}, Churn ${data.churn}%`;

  // 3. Generate slides
  const result = await agent.generateSlides({ topic, themeId: 'mckinsey-id' });

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

Muster 3: Multi-Format-Ausgabe

Generieren Sie Folien + Erzählung + Video in einer Pipeline:

async function fullPresentation(topic) {
  // 1. Generate slides
  const slides = await agent.generateSlides({ topic });

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

  // 3. Download with 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();
}

Überlegungen für die Produktion

Ratenbegrenzung

Standard: 60 Anfragen/Minute
Behandeln Sie 429-Antworten mit exponentiellem Backoff
Verwenden Sie den Async-Modus für Batch-Operationen

Fehlerbehandlung

Umschließen Sie alle API-Aufrufe mit try/catch
Implementieren Sie eine Wiederholungslogik für vorübergehende Fehler
Protokollieren Sie Job-IDs zur Fehlerbehebung

Kostenmanagement

Verfolgen Sie die Kreditauslastung pro Generierung
Legen Sie Budgetwarnungen in Ihrem 2Slides-Dashboard fest
Verwenden Sie niedrigere Auflösungen für interne Inhalte/Entwürfe

Sicherheit

Speichern Sie API-Schlüssel in Umgebungsvariablen, niemals im Code
Verwenden Sie nur serverseitige API-Aufrufe — geben Sie Schlüssel niemals an Clients weiter
Implementieren Sie eine Anforderungssignatur für Webhook-Callbacks

Häufig gestellte Fragen

Kann ich ein SaaS-Produkt auf Basis der 2Slides API entwickeln?

Ja — die API ist für den Produktionseinsatz konzipiert. Es gibt keine Einschränkungen für kommerzielle Anwendungen.

Wie hoch ist die maximale Grenze für gleichzeitige Generierungen?

Die API verarbeitet gleichzeitige Anfragen über Ratenbegrenzung. Für hohe Volumenanforderungen kontaktieren Sie das 2Slides-Team für Enterprise-Limits.

Gibt es einen Webhook für den Job-Abschluss?

Derzeit erfolgt die Abfrage über den Jobs-Endpunkt. Webhook-Unterstützung ist in Planung.

Entwickeln Sie Ihren Präsentationsagenten — holen Sie sich Ihren API-Schlüssel bei 2Slides und beginnen Sie, Folien programmatisch zu generieren.