Communitygithub.com

ARYAN2302/liquid_researcher

Implementieren Sie Text-to-Speech-Funktionen (TTS) mit dem z-ai-web-dev-sdk. Verwenden Sie diesen Skill, wenn Sie Text in natürlich klingende Sprache umwandeln, Audioinhalte erstellen, sprachgesteuerte Anwendungen entwickeln oder gesprochene Audiodateien generieren möchten. Unterstützt mehrere Stimmen, einstellbare Geschwindigkeit und verschiedene Audioformate.

Was ist liquid_researcher?

Dieser Skill ermöglicht die Implementierung von Text-to-Speech (TTS) Funktionalität unter Verwendung des z-ai-web-dev-sdk-Pakets, um Text in natürlich klingende Sprachaudioausgabe umzuwandeln. Er richtet sich an Entwickler, die in ihren Anwendungen Sprachfunktionen hinzufügen möchten, wie z.B. Audiobücher, E-Learning-Narration, Barrierefreiheitslösungen oder interaktive Sprachassistenten. Der Skill unterstützt sowohl die CLI für schnelle, einfache Umwandlungen als auch das SDK für dynamischere und integrierte Anwendungen, und ist somit vielseitig für verschiedene Anwendungsfälle einsetzbar. Zu den wichtigsten Funktionen gehören mehrere Stimmen (z.B. tongtong, chuichui), einstellbare Geschwindigkeit (0,5-2,0) und Lautstärke, sowie mehrere Audioausgabeformate (wav, pcm, mp3) mit Streaming-Unterstützung für das PCM-Format. Es werden wichtige Einschränkungen behandelt, wie das Textlimit von 1024 Zeichen pro Anfrage und Validierungslogik zur Sicherstellung zuverlässiger Audiodaten. Zusätzlich enthält der Skill detaillierte Codebeispiele, Best Practices und Anleitungen zur Integration mit Frameworks wie Next.js und Express.js.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ARYAN2302/liquid_researcher/tree/HEAD/skills/TTS

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

TTS (Text-to-Speech) Skill

Dieser Skill führt in die Implementierung der Text-to-Speech (TTS) Funktionalität mit dem z-ai-web-dev-sdk-Paket ein und ermöglicht die Umwandlung von Text in natürlich klingende Sprachaudioausgabe.

Skills-Pfad

Skill-Speicherort: {project_path}/skills/TTS

Dieser Skill befindet sich unter dem oben genannten Pfad in Ihrem Projekt.

Referenzskripte: Beispielskripte zum Testen sind im Verzeichnis {Skill Location}/scripts/ für schnelles Testen und als Referenz verfügbar. Siehe {Skill Location}/scripts/tts.ts für ein funktionierendes Beispiel.

Überblick

Text-to-Speech ermöglicht es Ihnen, Anwendungen zu erstellen, die gesprochene Audioinhalte aus Texteingaben generieren und dabei verschiedene Stimmen, Geschwindigkeiten und Ausgabeformate für vielfältige Anwendungsfälle unterstützen.

WICHTIG: Das z-ai-web-dev-sdk MUSS nur im Backend-Code verwendet werden. Verwenden Sie es niemals im clientseitigen Code.

API-Einschränkungen und -Beschränkungen

Bevor Sie die TTS-Funktionalität implementieren, beachten Sie diese wichtigen Einschränkungen:

Einschränkungen des Eingabetextes

  • Maximale Länge: 1024 Zeichen pro Anfrage
  • Texte, die diese Grenze überschreiten, müssen in kleinere Teile aufgeteilt werden

Audioparameter

  • Geschwindigkeitsbereich: 0,5 bis 2,0
    • 0,5 = halbe Geschwindigkeit (langsamer)
    • 1,0 = normale Geschwindigkeit (Standard)
    • 2,0 = doppelte Geschwindigkeit (schneller)
  • Lautstärkebereich: Größer als 0, bis zu 10
    • Standard: 1,0
    • Werte müssen größer als 0 (exklusive) und bis zu 10 (inklusive) sein

Format und Streaming

  • Streaming-Einschränkung: Wenn stream: true aktiviert ist, wird nur das pcm-Format unterstützt
  • Nicht-Streaming: Unterstützt die Formate wav, pcm und mp3
  • Abtastrate: 24000 Hz (empfohlen)

Best Practice für lange Texte

function splitTextIntoChunks(text, maxLength = 1000) {
  const chunks = [];
  const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
  
  let currentChunk = '';
  for (const sentence of sentences) {
    if ((currentChunk + sentence).length <= maxLength) {
      currentChunk += sentence;
    } else {
      if (currentChunk) chunks.push(currentChunk.trim());
      currentChunk = sentence;
    }
  }
  if (currentChunk) chunks.push(currentChunk.trim());
  
  return chunks;
}

Voraussetzungen

Das z-ai-web-dev-sdk-Paket ist bereits installiert. Importieren Sie es wie in den folgenden Beispielen gezeigt.

CLI-Nutzung (Für einfache Aufgaben)

Für einfache Text-to-Speech-Umwandlungen können Sie die z-ai-CLI anstelle von Code verwenden. Dies ist ideal für schnelle Audioerzeugung, das Testen von Stimmen oder einfache Automatisierung.

Basis-TTS

# Text in Sprache umwandeln (Standard WAV-Format)
z-ai tts --input "Hallo, Welt" --output ./hallo.wav

# Mit Kurzoptionen
z-ai tts -i "Hallo, Welt" -o ./hallo.wav

Verschiedene Stimmen und Geschwindigkeiten

# Bestimmte Stimme verwenden
z-ai tts -i "Willkommen bei unserem Service" -o ./willkommen.wav --voice tongtong

# Sprechgeschwindigkeit anpassen (0,5-2,0)
z-ai tts -i "Dies ist eine schnellere Sprache" -o ./schnell.wav --speed 1.5

# Langsamere Sprache
z-ai tts -i "Dies ist eine langsamere Sprache" -o ./langsam.wav --speed 0.8

Verschiedene Ausgabeformate

# MP3-Format
z-ai tts -i "Hallo Welt" -o ./hallo.mp3 --format mp3

# WAV-Format (Standard)
z-ai tts -i "Hallo Welt" -o ./hallo.wav --format wav

# PCM-Format
z-ai tts -i "Hallo Welt" -o ./hallo.pcm --format pcm

Streaming-Ausgabe

# Audio-Streaming generieren
z-ai tts -i "Dies ist ein längerer Text, der gestreamt wird" -o ./stream.wav --stream

CLI-Parameter

  • --input, -i <text>: Erforderlich - Text, der in Sprache umgewandelt werden soll (max. 1024 Zeichen)
  • --output, -o <pfad>: Erforderlich - Ausgabedateipfad für die Audiodatei
  • --voice, -v <stimme>: Optional - Stimmentyp (Standard: tongtong)
  • --speed, -s <zahl>: Optional - Sprechgeschwindigkeit, 0,5-2,0 (Standard: 1,0)
  • --format, -f <format>: Optional - Ausgabeformat: wav, mp3, pcm (Standard: wav)
  • --stream: Optional - Streaming-Ausgabe aktivieren (unterstützt nur das pcm-Format)

Wann CLI vs. SDK verwenden

CLI verwenden für:

  • Schnelle Text-to-Speech-Umwandlungen
  • Testen verschiedener Stimmen und Geschwindigkeiten
  • Einfache Batch-Audiogenerierung
  • Befehlszeilen-Automatisierungsskripte

SDK verwenden für:

  • Dynamische Audiogenerierung in Anwendungen
  • Integration mit Webdiensten
  • Benutzerdefinierte Audioverarbeitungspipelines
  • Produktionsanwendungen mit komplexen Anforderungen

Grundlegende TTS-Implementierung

Einfaches Text-to-Speech

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function textToSpeech(text, outputPath) {
  const zai = await ZAI.create();

  const response = await zai.audio.tts.create({
    input: text,
    voice: 'tongtong',
    speed: 1.0,
    response_format: 'wav',
    stream: false
  });

  // ArrayBuffer aus dem Response-Objekt holen
  const arrayBuffer = await response.arrayBuffer();
  const buffer = Buffer.from(new Uint8Array(arrayBuffer));

  fs.writeFileSync(outputPath, buffer);
  console.log(`Audio gespeichert unter ${outputPath}`);
  return outputPath;
}

// Verwendung
await textToSpeech('Hallo, Welt!', './ausgabe.wav');

Mehrere Stimmenoptionen

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function generateWithVoice(text, voice, outputPath) {
  const zai = await ZAI.create();

  const response = await zai.audio.tts.create({
    input: text,
    voice: voice, // Verfügbare Stimmen: tongtong, chuichui, xiaochen, jam, kazi, douji, luodo
    speed: 1.0,
    response_format: 'wav',
    stream: false
  });

  // ArrayBuffer aus dem Response-Objekt holen
  const arrayBuffer = await response.arrayBuffer();
  const buffer = Buffer.from(new Uint8Array(arrayBuffer));

  fs.writeFileSync(outputPath, buffer);
  return outputPath;
}

// Verwendung
await generateWithVoice('Willkommen bei unserem Service', 'tongtong', './willkommen.wav');

Einstellbare Geschwindigkeit

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function generateWithSpeed(text, speed, outputPath) {
  const zai = await ZAI.create();

  // Geschwindigkeitsbereich: 0,5 bis 2,0 (API-Beschränkung)
  // 0,5 = halbe Geschwindigkeit (langsamer)
  // 1,0 = normale Geschwindigkeit (Standard)
  // 2,0 = doppelte Geschwindigkeit (schneller)
  // Werte außerhalb dieses Bereichs verursachen API-Fehler

  const response = await zai.audio.tts.create({
    input: text,
    voice: 'tongtong',
    speed: speed,
    response_format: 'wav',
    stream: false
  });

  // ArrayBuffer aus dem Response-Objekt holen
  const arrayBuffer = await response.arrayBuffer();
  const buffer = Buffer.from(new Uint8Array(arrayBuffer));

  fs.writeFileSync(outputPath, buffer);
  return outputPath;
}

// Verwendung - langsamere Erzählung
await generateWithSpeed('Dies ist eine wichtige Ankündigung', 0.8, './langsam.wav');

// Verwendung - schnellere Erzählung
await generateWithSpeed('Kurzes Update', 1.3, './schnell.wav');

Einstellbare Lautstärke

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function generateWithVolume(text, volume, outputPath) {
  const zai = await ZAI.create();

  // Lautstärkebereich: größer als 0, bis zu 10 (API-Beschränkung)
  // Werte müssen > 0 (exklusive) und <= 10 (inklusive) sein
  // Standard: 1.0 (normale Lautstärke)

  const response = await zai.audio.tts.create({
    input: text,
    voice: 'tongtong',
    speed: 1.0,
    volume: volume, // Optionaler Parameter
    response_format: 'wav',
    stream: false
  });

  // ArrayBuffer aus dem Response-Objekt holen
  const arrayBuffer = await response.arrayBuffer();
  const buffer = Buffer.from(new Uint8Array(arrayBuffer));

  fs.writeFileSync(outputPath, buffer);
  return outputPath;
}

// Verwendung - lautere Audioausgabe
await generateWithVolume('Dies ist eine Ankündigung', 5.0, './laut.wav');

// Verwendung - leisere Audioausgabe
await generateWithVolume('Geflüsterte Nachricht', 0.5, './leise.wav');

Fortgeschrittene Anwendungsfälle

Batch-Verarbeitung

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';
import path from 'path';

async function batchTextToSpeech(textArray, outputDir) {
  const zai = await ZAI.create();
  const results = [];

  // Sicherstellen, dass das Ausgabeverzeichnis existiert
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  for (let i = 0; i < textArray.length; i++) {
    try {
      const text = textArray[i];
      const outputPath = path.join(outputDir, `audio_${i + 1}.wav`);

      const response = await zai.audio.tts.create({
        input: text,
        voice: 'tongtong',
        speed: 1.0,
        response_format: 'wav',
        stream: false
      });

      // ArrayBuffer aus dem Response-Objekt holen
      const arrayBuffer = await response.arrayBuffer();
      const buffer = Buffer.from(new Uint8Array(arrayBuffer));

      fs.writeFileSync(outputPath, buffer);
      results.push({
        success: true,
        text,
        path: outputPath
      });
    } catch (error) {
      results.push({
        success: false,
        text: textArray[i],
        error: error.message
      });
    }
  }

  return results;
}

// Verwendung
const texts = [
  'Willkommen zu Kapitel eins',
  'Willkommen zu Kapitel zwei',
  'Willkommen zu Kapitel drei'
];

const results = await batchTextToSpeech(texts, './audio-ausgabe');
console.log('Generiert:', results.length, 'Audiodateien');

Dynamische Inhaltsgenerierung

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

class TTSGenerator {
  constructor() {
    this.zai = null;
  }

  async initialize() {
    this.zai = await ZAI.create();
  }

  async generateAudio(text, options = {}) {
    const {
      voice = 'tongtong',
      speed = 1.0,
      format = 'wav'
    } = options;

    const response = await this.zai.audio.tts.create({
      input: text,
      voice: voice,
      speed: speed,
      response_format: format,
      stream: false
    });

    // ArrayBuffer aus dem Response-Objekt holen
    const arrayBuffer = await response.arrayBuffer();
    return Buffer.from(new Uint8Array(arrayBuffer));
  }

  async saveAudio(text, outputPath, options = {}) {
    const buffer = await this.generateAudio(text, options);
    if (buffer) {
      fs.writeFileSync(outputPath, buffer);
      return outputPath;
    }
    return null;
  }
}

// Verwendung
const generator = new TTSGenerator();
await generator.initialize();

await generator.saveAudio(
  'Hallo, dies ist ein Test',
  './ausgabe.wav',
  { speed: 1.2 }
);

Beispiel einer Next.js-API-Route

import { NextRequest, NextResponse } from 'next/server';

export async function POST(req: NextRequest) {
  try {
    const { text, voice = 'tongtong', speed = 1.0 } = await req.json();

    // ZAI SDK importieren
    const ZAI = (await import('z-ai-web-dev-sdk')).default;

    // SDK-Instanz erstellen
    const zai = await ZAI.create();

    // TTS-Audio generieren
    const response = await zai.audio.tts.create({
      input: text.trim(),
      voice: voice,
      speed: speed,
      response_format: 'wav',
      stream: false,
    });

    // ArrayBuffer aus dem Response-Objekt holen
    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(new Uint8Array(arrayBuffer));

    // Audio als Antwort zurückgeben
    return new NextResponse(buffer, {
      status: 200,
      headers: {
        'Content-Type': 'audio/wav',
        'Content-Length': buffer.length.toString(),
        'Cache-Control': 'no-cache',
      },
    });
  } catch (error) {
    console.error('TTS-API-Fehler:', error);

    return NextResponse.json(
      {
        error: error instanceof Error ? error.message : 'Spracherzeugung fehlgeschlagen, bitte später erneut versuchen',
      },
      { status: 500 }
    );
  }
}

Best Practices

1. Textvorbereitung

function prepareTextForTTS(text) {
  // Übermäßige Leerzeichen entfernen
  text = text.replace(/\s+/g, ' ').trim();

  // Häufige Abkürzungen für bessere Aussprache erweitern
  const abbreviations = {
    'Dr.': 'Doktor',
    'Mr.': 'Herr',
    'Mrs.': 'Frau',
    'etc.': 'und so weiter'
  };

  for (const [abbr, full] of Object.entries(abbreviations)) {
    text = text.replace(new RegExp(abbr, 'g'), full);
  }

  return text;
}

2. Fehlerbehandlung

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function safeTTS(text, outputPath) {
  try {
    // Eingabe validieren
    if (!text || text.trim().length === 0) {
      throw new Error('Texteingabe darf nicht leer sein');
    }

    if (text.length > 1024) {
      throw new Error('Texteingabe überschreitet die maximale Länge von 1024 Zeichen');
    }

    const zai = await ZAI.create();

    const response = await zai.audio.tts.create({
      input: text,
      voice: 'tongtong',
      speed: 1.0,
      response_format: 'wav',
      stream: false
    });

    // ArrayBuffer aus dem Response-Objekt holen
    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(new Uint8Array(arrayBuffer));

    fs.writeFileSync(outputPath, buffer);

    return {
      success: true,
      path: outputPath,
      size: buffer.length
    };
  } catch (error) {
    console.error('TTS-Fehler:', error);
    return {
      success: false,
      error: error.message
    };
  }
}

3. SDK-Instanz wiederverwenden

import ZAI from 'z-ai-web-dev-sdk';

// Singleton-Instanz erstellen
let zaiInstance = null;

async function getZAIInstance() {
  if (!zaiInstance) {
    zaiInstance = await ZAI.create();
  }
  return zaiInstance;
}

// Verwendung
const zai = await getZAIInstance();
const response = await zai.audio.tts.create({ ... });

Häufige Anwendungsfälle

  1. Hörbücher & Podcasts: Schriftliche Inhalte in Audioformat umwandeln
  2. E-Learning: Erstellung von Erzählungen für Bildungsinhalte
  3. Barrierefreiheit: Bereitstellung von Audio-Versionen von Textinhalten
  4. Sprachassistenten: Generierung dynamischer Antworten
  5. Ansagen: Erstellung automatisierter Audio-Benachrichtigungen
  6. IVR-Systeme: Generierung von Telefonansagen
  7. Inhaltslokalisierung: Erstellung von Audio in verschiedenen Sprachen

Integrationsbeispiele

Express.js-API-Endpunkt

import express from 'express';
import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';
import path from 'path';

const app = express();
app.use(express.json());

let zaiInstance;
const outputDir = './audio-ausgabe';

async function initZAI() {
  zaiInstance = await ZAI.create();
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }
}

initZAI();

app.post('/tts', async (req, res) => {
  try {
    const { text, voice = 'tongtong', speed = 1.0 } = req.body;

    if (!text || text.length > 1024) {
      return res.status(400).json({
        error: 'Ungültige Eingabe. Text darf nicht leer sein und maximal 1024 Zeichen enthalten.'
      });
    }

    const outputFileName = `ausgabe_${Date.now()}.wav`;
    const outputPath = path.join(outputDir, outputFileName);

    const response = await zaiInstance.audio.tts.create({
      input: text,
      voice: voice,
      speed: speed,
      response_format: 'wav',
      stream: false
    });

    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(new Uint8Array(arrayBuffer));

    fs.writeFileSync(outputPath, buffer);

    res.json({
      success: true,
      message: 'Audio erfolgreich generiert',
      file: outputFileName,
      size: buffer.length,
      downloadUrl: `/audio/${outputFileName}`
    });
  } catch (error) {
    console.error('TTS-Fehler:', error);
    res.status(500).json({
      success: false,
      error: 'Fehler bei der Generierung von Audio'
    });
  }
});

app.listen(3000, () => {
  console.log('TTS-Server läuft auf Port 3000');
});

Fehlerbehebung

Häufige Fehler und Lösungen

FehlerUrsacheLösung
ERR_AUDIO_TOO_LONGText überschreitet 1024 ZeichenText in kleinere Teile aufteilen
ERR_INVALID_SPEEDGeschwindigkeit außerhalb des Bereichs 0,5-2,0Geschwindigkeit auf 0,5-2,0 begrenzen
ERR_INVALID_VOLUMELautstärke außerhalb des Bereichs >0 bis 10Lautstärke im gültigen Bereich festlegen
ERR_STREAM_FORMATStreaming mit nicht-PCM-FormatNur PCM-Format mit Streaming verwenden
ERR_NETWORKNetzwerkfehlerVerbindung prüfen und erneut versuchen

Sicherheitshinweise

  1. API-Schlüssel schützen: Bewahren Sie API-Schlüssel sicher in Umgebungsvariablen auf
  2. Eingabe validieren: Überprüfen und bereinigen Sie Texteingaben, bevor Sie sie an die TTS-API senden
  3. Ratenbegrenzung: Implementieren Sie Ratenbegrenzung, um übermäßige Nutzung zu verhindern
  4. Audiodatei-Speicherung: Sichern Sie generierte Audiodateien ordnungsgemäß und räumen Sie alte Dateien regelmäßig auf
  5. Inhaltsfilter: Implementieren Sie eine Inhaltsfilterung, um die Erzeugung unangemessener Audioinhalte zu verhindern

Nächste Schritte

Sobald diese grundlegende TTS-Implementierung abgeschlossen ist, sollten Sie:

  • Erweiterte Funktionen: Sprachauswahl, Stimmungsanpassung und mehrsprachige Unterstützung erkunden
  • Leistungsoptimierung: Implementieren Sie Zwischenspeicherung (Caching) für häufig verwendete Audioinhalte
  • Monitoring: Fügen Sie Überwachung und Analysen für die TTS-Nutzung hinzu
  • Tests: Erstellen Sie eine umfassende Testabdeckung für Audioqualität und Leistung
  • Dokumentation: Dokumentieren Sie die TTS-Funktionalität für andere Teammitglieder

Individual skills in this repo

This repo contains 8 individual skills — each has its own dedicated page.

ARYAN2302/liquid_researcher

Generate a single-file Chinese atelier-style portfolio website (horizontal-row list + hover-reveal thumb interaction, art lishu typography "Alimama DaoLiTi" via CDN, light/dark theme, hash-routed detail pages). Takes a natural-language description of the studio (name, director, discipline, works) and outputs ONE working .html file. Runs in BOTH Claude Code (writes to ~/Desktop) and GLM / online chat (outputs HTML inline). Trigger phrases include "做个中式工作室作品集", "做个隶书作品集", "lishu-portfolio-gen ...", "做个白屋风格的作品集", or when user drags this skill folder into chat asking for an atelier-style site.

ARYAN2302/liquid_researcher

Chinese-market SaaS pricing page template — soft sky-blue glass-morphism, 4-tier card grid with one elevated "recommended" tier, monthly/annual toggle, FAQ accordion, ¥ pricing with Inter numerals, careful CJK linebreaking, ICP filing footer.

ARYAN2302/liquid_researcher

Premium calm-tech SaaS landing template — bilingual (CN/EN) literary voice over a dark forest-night palette with warm gold accent, Cormorant + Noto Serif SC, Three.js procedural forest hero, station-based scrolling narrative, custom cursor. Built for ambient-AI / creative-tool / philosophical SaaS, not loud commercial launch.

ARYAN2302/liquid_researcher

Pro-camera HUD mockup template — full-viewport black canvas wrapping a real video with monospace overlays (corner brackets, top status bar, side AF/exposure columns, bottom timecode + aperture/shutter/ISO row, vertical 8-filter wheel, animated reticle). For cinematographer portfolios, camera-app demos, LUT pack previews, filter-look auditions. NOT a TikTok/Reels mockup, NOT a storyboard, NOT a shot list, NOT a script document. The chrome wraps real footage — never a div placeholder.

ARYAN2302/liquid_researcher

Premium pre-launch waitlist page template — dark charcoal canvas with subtle vignette, drifting portrait video-thumbnail cards, fade-up cascades, glass nav, live-updating join counter, single email form with success/error states. Built for creative-tool / AI / niche-SaaS invite-only launches with hushed exclusive tone, not loud growth-marketing.

ARYAN2302/liquid_researcher

Route design-related HTML artifact tasks to the right artifact skill, reference, design system generation, or export skill.

ARYAN2302/liquid_researcher

Implement AI-powered video generation capabilities using the z-ai-web-dev-sdk. Use this skill when the user needs to generate videos from text prompts or images, create video content programmatically, or build applications that produce video outputs. Supports asynchronous task management with status polling and result retrieval.

ARYAN2302/liquid_researcher

Implement specialized video understanding capabilities using the z-ai-web-dev-sdk. Use this skill when the user needs to analyze video content, understand motion and temporal sequences, extract information from video frames, describe video scenes, or perform video-based AI analysis. Optimized for MP4, AVI, MOV, and other common video formats.

Verwandte Skills