Communitygithub.com

Mintii-Labs/ozor-skills

Verwandle ein echtes Dokument (PDF, PPTX, DOCX, Keynote-Export, Pitchdeck, Angebot, Whitepaper, Bericht) mit dem Ozor MCP in ein fertiges, KI-generiertes Video.

Was ist ozor-skills?

Diese Fähigkeit (Skill) ist für KI-Agenten wie Claude Code, Cursor oder Codex gedacht, um aus einem hochgeladenen oder referenzierten Dokument ein professionelles KI-Video zu erstellen. Sie ist die Brücke zwischen statischen Dateien (PDF, PPTX, DOCX, Keynote-Exporte, Whitepapers, Berichte) und dem Ozor.ai-Videoproduktionsdienst. Der Skill implementiert einen planbasierten Workflow, der die visuelle Struktur des Dokuments (z.B. Folien, Layouts) bewahrt. Der Prozess gliedert sich in die Analyse des Dokuments durch Ozor → Präsentation des strukturierten Plans (Szenen, Erzählung) an den Benutzer → Möglichkeit für Bearbeitungen durch den Benutzer → Videogenerierung aus dem Plan → Export und Einbettung. Der Skill nutzt spezifische MCP-Tools wie `analyze_document`, `update_plan`, `generate_from_plan` und `export_video`. Entscheidend ist, dass der Agent den Plan immer zuerst dem Benutzer vorlegt und auf Freigabe wartet, bevor er die teure Generierung startet. Er ist optimiert für Dokumente und nicht für kurze Textvorgaben (dafür gibt es `ozor-generate`) oder URLs (dafür gibt es `ozor-url-to-video`). Der Skill behandelt sowohl öffentliche URLs als auch lokale Dateien (Upload über `prepare_document_upload`) und gibt die fertigen Freigabe-, Bearbeitungs- und Download-Links sowie den HTML-Einbettungscode aus.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Mintii-Labs/ozor-skills/tree/main/skills/ozor-document-video

In Ihrer bevorzugten KI fragen

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

Dokumentation

Ozor Dokument-zu-Video

End-to-End-Dokument-zu-Video auf Ozor.ai. Nimmt eine echte Datei (PDF, PPTX, DOCX, etc.), analysiert sie auf Ozors Seite, um einen strukturierten Plan zu erstellen, lässt den Benutzer den Plan genehmigen/bearbeiten und generiert und exportiert dann ein fertiges Video – wobei die visuellen Elemente der Folien erhalten bleiben.

Wann verwenden

Verwende diesen Skill, wenn die Eingabe ein Dokument/eine Datei ist. Anzeichen:

  • Der Benutzer hat eine PDF, PPTX, DOCX, Keynote-Export, Pitchdeck, Angebot, Whitepaper, Bericht oder ein Einseiter angehängt oder referenziert
  • "Mach ein Video aus diesem Deck"
  • "Erstelle ein Video aus dieser PDF"
  • "Video aus meinem Pitch / Angebot / Bericht"

Verwende diesen Skill NICHT, wenn:

  • Die Eingabe eine kurze kreative Textvorgabe ist → ozor-generate
  • Die Eingabe eine URL oder Landing Page ist → ozor-url-to-video
  • Der Benutzer nur einen geschriebenen Ozor-Prompt möchte → ozor-doc-to-video (nur Prompt-Skill)
  • Der Benutzer bestehende Videos verwalten möchte → ozor-video-library

Erforderliche MCP-Tools

  • mcp__ozor__analyze_document — analysiert das Dokument, gibt eine planId plus den strukturierten Plan zurück
  • mcp__ozor__prepare_document_upload — erhält eine per Curl hochladbare URL für lokale Dateien ohne öffentliche URL (der häufigste Weg)
  • mcp__ozor__get_plan — ruft den aktuellen Plan-Status ab
  • mcp__ozor__update_plan — wendet Benutzerbearbeitungen am Plan vor der Generierung an
  • mcp__ozor__generate_from_plan — startet den Videobau aus dem genehmigten Plan, gibt projectId zurück
  • mcp__ozor__export_video — startet das Rendern (verwende die projectId als videoId)
  • mcp__ozor__wait_for_export — blockiert, bis der Render bereit ist
  • mcp__ozor__get_embed_code — gibt das <iframe> HTML zurück

Wenn das Ozor MCP nicht verbunden ist, informiere den Benutzer und stoppe. Extrahiere den Inhalt nicht selbst und greife nicht auf generate_video mit einem selbstgeschriebenen Skript zurück – das verliert die Folienvisualisierungen und überschreitet das 2000-Zeichen Prompt-Limit. Der planbasierte Ablauf ist für Dokumente zwingend erforderlich.

Workflow

Schritt 1 — Das Dokument zu Ozor bringen

Wähle die beste Quelle, in Prioritätsreihenfolge:

  1. Öffentliche URL → übergib url direkt an analyze_document. Kein Größenlimit, keine Token-Kosten. Am besten, wann immer verfügbar.
  2. Lokale Datei (der häufige Fall) → rufe mcp__ozor__prepare_document_upload auf, führe dann den zurückgegebenen Curl-Befehl aus, um die Bytes direkt in Ozors Speicher zu übertragen. Bytes durchlaufen nie einen Tool-Aufruf, daher funktionieren Dateien bis zu ~50 MB. Verwende dies für alle Multi-MB PDF/PPTX/DOCX, die der Benutzer in das Gespräch hochgeladen hat.
  3. fileBase64 + fileName bei analyze_document → nur für kleine Dateien (≲ ein paar hundert KB). Vermeide für große Decks – es verbraucht Tokens.

Wenn prepare_document_upload nicht in der Tool-Liste ist, sind Uploads auf diesem Server deaktiviert – falle auf eine URL oder kleines Base64 zurück.

Schritt 2 — Das Dokument analysieren

Sobald Ozor die Datei hat, rufe auf:

mcp__ozor__analyze_document({
  url | uploadId | fileBase64+fileName,
  ...optionale Hinweise: targetDuration, format (16:9 / 9:16), audience, tone
})

Dies gibt { planId, plan } zurück. Der Plan enthält die vorgeschlagenen Szenen, Erzählung, visuelle Notizen und welche Folien/Seiten welchen Szenen zugeordnet sind.

Schritt 3 — Den Plan dem Benutzer präsentieren und STOPPEN

Dies ist der kritische Schritt. Überspringe die Generierung nicht. Zeige dem Benutzer eine prägnante Darstellung des Plans:

📋 Ozor-Plan für "<Dokumentname>"

**Format:** 16:9 (oder 9:16)
**Geschätzte Dauer:** ~X Sekunden
**Szenen:** N

(1) <Szenentitel> — <einzellige Erzählung / Visual>
(2) <Szenentitel> — <einzellige Erzählung / Visual>
...

Soll ich das so generieren, oder möchtest du etwas ändern? Du kannst:
- Eine Szene bearbeiten ("Szene 2 ändern zu ...")
- Szenen neu anordnen / löschen / hinzufügen
- Ton, Länge oder Format ändern
- Genehmigen und generieren

Dann warte auf die Genehmigung des Benutzers oder auf Bearbeitungswünsche. Rufe generate_from_plan nicht aus eigener Initiative auf – der Plan ist der Kontrollpunkt des Benutzers für Kosten und kreative Kontrolle.

Schritt 4 — Bearbeitungen anwenden (falls vorhanden)

Wenn der Benutzer Änderungen wünscht, rufe mcp__ozor__update_plan({ planId, ... }) mit den Bearbeitungen auf. Hole den Plan mit get_plan erneut ab und zeige den aktualisierten Plan erneut an. Wiederhole den Vorgang, bis der Benutzer zustimmt.

Schritt 5 — Aus dem Plan generieren

Wenn der Benutzer zustimmt:

mcp__ozor__generate_from_plan({ planId })

Dies gibt { projectId } zurück. Verwende projectId als videoId für jeden nachfolgenden Aufruf.

Wenn die Antwort eine jobId enthält, warte mit wait_for_job({ videoId: projectId, jobId }) darauf. Andernfalls fahre mit dem Export fort.

Schritt 6 — Exportieren

mcp__ozor__export_video({ videoId: projectId })
mcp__ozor__wait_for_export({ videoId: projectId })

Gibt shareUrl, editorUrl, downloadUrl zurück.

Schritt 7 — Einbetten

mcp__ozor__get_embed_code({ videoId: projectId })

Schritt 8 — Ergebnisse präsentieren

🎬 Video fertig aus "<Dokumentname>"

**Teilen:** <shareUrl>
**Editor:** <editorUrl>
**Herunterladen:** <downloadUrl>

**Einbettung:**
```html
<iframe ...></iframe>

Möchtest du einen 9:16 Social Cut aus demselben Plan? Ich kann neu generieren.


## Hinweise, die an `analyze_document` übergeben werden können

Übergib diese, wenn der Benutzer sie erwähnt hat oder sie aus dem Dokument offensichtlich sind:

- `targetDuration` — z.B. `"60s"`, `"90s"`. Standard ~60s für Angebote/Decks, ~30s für Einseiter.
- `format` — `"16:9"` (Standard) oder `"9:16"` für soziale Medien.
- `audience` — Investoren, Kunden, Entwickler, internes Team, ...
- `tone` — selbstbewusst, warm, technisch, energiegeladen, ...
- `focus` — optional, eine einzeilige Notiz wie "Konzentriere dich auf die Metriken auf Folie 4" oder "Überspringe die Teamfolie".

## Anpassung nach Dokumenttyp

| Dokument | Standarddauer | Format | Ton | Fokus |
|----------|---------------|--------|-----|-------|
| Pitchdeck | 60–90s | 16:9 | Selbstbewusst | Problem → Lösung → Traktion → CTA |
| Angebot (DOCX) | 60s | 16:9 | Professionell | Ergebnisse + Preis + nächster Schritt |
| Whitepaper / Bericht | 60–90s | 16:9 | Autoritär | 3 wichtigste Erkenntnisse, Link zum vollständigen Dokument im CTA |
| Vertriebs-Einseiter | 30–45s | 16:9 | Knackig | Haken → 3 Vorteile → CTA |
| Versionshinweise | 30–45s | 16:9 | Energiegeladen | Eine Szene pro Funktion |
| Schulung / SOP | 90s+ | 16:9 | Ruhig, klar | Nummerierte Schritte, in eine Reihe aufteilen, wenn > 7 Szenen |

Im Zweifelsfall schlage einen Standard in deinem ersten Aufruf vor und lass den Benutzer nach dem Ansehen des Plans überschreiben.

## Iterieren nach der Generierung

Wenn das gerenderte Video Änderungen benötigt:
- Kleine Anpassungen an Erzählung/Kopie → `update_plan` + neu generieren (dies wird vom Plan aus neu ausgeführt, kein erneutes Analysieren des Dokuments erforderlich)
- Neue Szenenreihenfolge oder Ton → derselbe Weg
- Neuer Fokus oder neue Zielgruppe → es kann günstiger sein, `analyze_document` mit stärkeren Hinweisen erneut aufzurufen

## Fehler und Wiederherstellung

- **`analyze_document` schlägt fehl, weil die Datei zu groß ist** → verwende `prepare_document_upload` anstelle von Base64.
- **Der Plan hat fehlende oder falsche Inhalte** → rufe `update_plan` mit Korrekturen auf, anstatt neu zu starten.
- **`generate_from_plan` schlägt fehl** → der Fehler weist normalerweise auf eine bestimmte Szene hin. Behebe den Fehler über `update_plan`, wiederhole den Vorgang.
- **Export hängt** → es ist sicher, `wait_for_export` erneut aufzurufen; er wird fortgesetzt.

## Regeln

1. **Gehe immer zuerst den Planweg.** Rufe niemals `generate_video` mit handgeschriebener Prosa auf, die aus dem Dokument extrahiert wurde. Der ganze Sinn dieses Skills ist, dass Ozor die Folien direkt sieht.
2. **Zeige dem Benutzer immer den Plan und warte auf Genehmigung**, bevor du `generate_from_plan` aufrufst. Die Generierung ist der teure Schritt; der Plan ist der Kontrollpunkt.
3. **Für lokale Dateien verwende `prepare_document_upload` + Curl.** Base64 ist nur für winzige Dateien.
4. **Verwende überall nach `generate_from_plan` `projectId` als `videoId`.** Es ist dieselbe Kennung.
5. **Gib jede URL an** — Teilen, Editor, Herunterladen, Einbettung.
6. **Fasse das Dokument nicht selbst zusammen** — Ozors `analyze_document` macht das und bewahrt die Visualisierungen. Deine Aufgabe ist es, das MCP zu orchestrieren und den Plan zu kuratieren, nicht den Inhalt neu zu schreiben.

Individual skills in this repo

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

Mintii-Labs/ozor-skills

Generate an AI video end-to-end on Ozor.ai from a short text brief. Use this skill whenever the user wants to actually create a video (not just write a prompt) from a creative description, idea, or short brief — e.g. 'make me a video about X', 'generate a launch video for Y', 'create an explainer for Z', 'render a video', 'produce a 30s ad about ...', 'spin up a quick video for our new feature'. This skill runs the full Ozor MCP pipeline: generate_video → wait_for_job → export_video → wait_for_export → get_embed_code, and returns the shareUrl, editorUrl, downloadUrl, and a ready-to-paste <iframe> embed. Do NOT use this skill when the input is a document/PDF/PPTX/deck/URL — use ozor-document-video or ozor-url-to-video instead.

Mintii-Labs/ozor-skills

Turn any URL — landing page, blog post, product page, documentation page, changelog, public PDF, or web article — into a finished AI-generated video using the Ozor MCP. Use this skill whenever the user gives a link and wants a video from its content: 'make a video from this URL', 'video from my landing page', 'turn this blog post into a video', 'video from https://...', 'video from our homepage', 'generate a video from this product page', 'create a video from this article'. This skill runs analyze_document with the url parameter (no scraping needed on our side), presents the resulting plan to the user, then generates → exports → embeds. Do NOT use this skill for a short text brief (use ozor-generate) or for an attached local file (use ozor-document-video).

Mintii-Labs/ozor-skills

Browse, inspect, re-export, embed, or iterate on videos that already exist in the user's Ozor.ai account. Use this skill whenever the user wants to work with past or in-progress Ozor videos rather than create a new one — e.g. 'list my Ozor videos', 'show my recent videos', 'what's the status of my last video', 'get the embed code for that video', 'download my last Ozor video', 'share link for the explainer I made', 'check on the export', 'send a follow-up edit to that video', 'show the plan for video X', 'render that video again at 9:16', 'is the job done yet'. This skill orchestrates list_videos, get_video, get_job, get_plan, update_plan, send_message, wait_for_job, export_video, wait_for_export, and get_embed_code. Do NOT use this skill to create a new video from scratch — use ozor-generate, ozor-document-video, or ozor-url-to-video.

Verwandte Skills