Loo AI Esitlusagent: Täielik Arendaja Juhend

AI agendid muudavad viisi, kuidas tarkvara loob sisu. AI esitlusagent suudab genereerida, kohandada ja pakkuda professionaalseid slaidiesitlusi osana automatiseeritud töövoogudest — CRM-i torujuhtmetest kuni sisemiste aruandlustööriistadeni.

See juhend juhendab sind tootmisvalmis esitlusagendi loomise läbi kasutades 2Slides API-t.

Arhitektuuri Ülevaade

Esitlusagent järgib tavaliselt seda voogu:

Kasutaja Päring → Agendi Loogika → 2Slides API → Töö Küsitlus → Tulemuse Edastamine
                      ↓
               Konteksti Kogumine
               (andmed, mallid, brändi ressursid)

Põhikomponendid

Sisendi Töötleja — võtab vastu esitluste päringuid (tekst, andmed, failid)
Konteksti Ehitaja — rikastab päringuid mallidega, brändi infoga, andmetega
Genereerimise Mootor — kutsub 2Slides API-t slaidide loomiseks
Oleku Jälgija — küsitleb töö olekut kuni valmimiseni
Edastuskiht — tagastab allalaadimise lingid, saadab e-posti teel, postitab Slack'i

Alustamine

1. Hangi oma API võti

Registreeru aadressil 2slides.com ja loo API võti aadressil 2slides.com/api.

2. Installi sõltuvused

npm install node-fetch dotenv

3. Põhiline agendi rakendus

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' }) {
    // Samm 1: Alusta genereerimist
    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 || 'Genereerimine ebaõnnestus');

    // Samm 2: Küsi staatust kuni valmis
    return await this.waitForCompletion(job.jobId);
  }

```javascript
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('Genereerimine ebaõnnestus');

    await new Promise(r => setTimeout(r, 3000));
  }
  throw new Error('Genereerimise ajalõpp ületatud');
}

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

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

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

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

Python'i rakendamine

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

```python
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('Genereerimine ebaõnnestus')
        time.sleep(3)
    raise TimeoutError('Genereerimise aeg sai otsa')

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

Täiustatud Mustrid

Muster 1: Mallipõhine Genereerimine

Eelkonfigureeri teemad erinevate kasutusjuhtude jaoks:

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: Andmetorustiku Integratsioon

Ühenda oma andmeallikatega:

async function weeklyReport(dataSource) {
  // 1. Hangi viimased andmed
  const data = await dataSource.getWeeklyMetrics();

  // 2. Vorminda presentatsiooni sisendina
  const topic = `Nädalaraport: Tulu $${data.revenue}, Kasutajad ${data.users}, Lahkumine ${data.churn}%`;

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

  // 4. Edasta
  await slackBot.postMessage('#team-updates', `Nädalaraport valmis: ${result.downloadUrl}`);
}

Muster 3: Mitme Formaadi Väljund

Genereeri slaidid + jutustus + video ühes torustikus:

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

```typescript
// 2. Lisa hääleline jutustus
await agent.addNarration({ jobId: slides.jobId, mode: 'multi', voice: 'Charon' });

// 3. Laadi alla koos heliga
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();
}

Tootmise kaalutlused

Päringute piiramine

Vaikimisi: 60 päringut/minut
Käsitle 429 vastuseid eksponentsiaalse taganemisega
Kasuta pakktöötluste jaoks asünkroonset režiimi

Vigade käsitlemine

Pane kõik API väljakutsed try/catch plokki
Rakenda korduskatse loogikat ajutiste vigade korral
Logi töö ID-d silumise jaoks

Kulude haldamine

Jälgi krediidi kasutust genereerimise kohta
Sea 2Slides armatuurlaual eelarve hoiatused
Kasuta sisemise/mustandsisu jaoks madalamaid resolutsioone

Turvalisus

Hoia API võtmeid keskkonnamuutujates, mitte kunagi koodis
Kasuta ainult serveripoolseid API väljakutseid — ära kunagi avalda võtmeid klientidele
Rakenda webhook tagasihelistuste jaoks päringu allkirjastamist

Korduma Kippuvad Küsimused

Kas ma saan luua SaaS-toote 2Slides API baasil?

Jah — API on loodud tootmiskasutuseks. Kommertsrakendustele pole piiranguid.

Mis on maksimaalne samaaegne genereerimise limiit?

API töötleb samaaegseeid päringuid läbi kiiruspiirangute. Suuremahulisteks vajadusteks võtke ühendust 2Slides meeskonnaga ettevõtteliikmikute saamiseks.

Kas töö lõpetamiseks on webhook olemas?

Praegu kasutage päringute tegemist läbi jobs-endpointi. Webhookide tugi on teekaardil.

Ehitage oma esitluste agent — hankige oma API võti 2Slides-ist ja alustage slaidide programmilise genereerimisega.