Dokumente mit KI in C# in PowerPoint-Präsentationen umwandeln

Dokumente mit KI in C# in PowerPoint-Präsentationen zu verwandeln ist mehr als eine Formatkonvertierung. Wenn ein 30-seitiger Bericht zu einem 10-Folien-Deck wird, bedeutet das, dass jemand das vollständige Dokument gelesen, entschieden hat, welche 90 % weggelassen werden, das Verbliebene zu einer Erzählung neu geordnet und visuelles Design angewendet hat. Das ist redaktionelle Synthese — der Teil, den traditionelle PowerPoint-Bibliotheken nicht leisten.

Das Interessante ist, was synthetisiert wird. In realen Arbeitsabläufen ist die Quelle selten eine einzelne Datei. Ein vierteljährliches Business Review zieht Zahlen aus einer Excel-Arbeitsmappe, Erzähltext aus einem Word-Bericht und eine signierte Rechnung aus einem PDF. Der Wert eines KI-Dokumentenagenten ist nicht „konvertiere eine .docx in .pptx“ — sondern „lies alle drei und gib mir ein Deck, das die Geschichte über sie hinweg erzählt.“ Dieser Artikel zeigt den einfachsten Weg, genau das mit Spire.Agent.Office in C# zu tun: Übergeben Sie dem Agenten jedes Dokument plus eine Anweisung, und lassen Sie ihn das Deck in einem einzigen Aufruf generieren.

1. Eine Anweisung, viele Quellen

Traditioneller Spire.Office-Code behandelt jedes Format als eine Insel. Um ein Deck aus einem Word-Bericht plus einem Excel-Blatt zu erstellen, würden Sie:

1. Spire.Doc verwenden, um die .docx zu öffnen und den gewünschten Text herauszuziehen.
2. Spire.XLS verwenden, um die Arbeitsmappe zu lesen und die Zahlen zu berechnen.
3. Spire.Pdf verwenden, wenn eine Quelle ein PDF ist.
4. Spire.Presentation verwenden, um Folien einzeln zu erstellen, jedes Textfeld und Diagramm zu positionieren und Layouts von Hand zu berechnen.

Das sind vier API-Oberflächen, ein Parser pro Format und eine manuelle Layout-Engine. In dem Moment, in dem sich die Struktur eines Dokuments ändert, bricht der Code.

Spire.Agent.Office reduziert das auf eine Anweisung. Sie übergeben dem Agenten alle Ihre Quelldateien und sagen ihm, welche Geschichte das Deck erzählen soll. Der Agent liest jedes Format, entscheidet, was über sie hinweg wichtig ist, und erzeugt die Folien — ohne manuellen Layout-Code.

Das mentale Modell ist ein einziger Schritt:

Anstatt einen Parser pro Format zu schreiben, lassen Sie den Agenten jede Datei lesen und das Deck direkt generieren. Ein Aufruf, eine Anweisungszeichenfolge, eine .pptx-Datei.

2. Was Sie benötigen

• .NET 6+ (das Beispiel zielt auf net10.0).
• Das NuGet-Paket Spire.Agent.Office. Es bringt transitiv Spire.Doc, Spire.Pdf, Spire.XLS und Spire.Presentation mit, sodass Sie diese nicht separat installieren müssen.
• Ein SpireToken (Spire.Agent.Office-API-Schlüssel). Der Agent kommuniziert mit dem KI-Dienst, daher ist für die eigentliche Generierung ein gültiges Token erforderlich.
• Namespace-Imports:

using Spire.Agent.Office.AI;        // AIOptions, AIDocumentProcessor, AIResult
using Spire.Agent.Office.Extensions;// presentation.AI(...) extension
using Spire.Presentation;           // Presentation

3. Das einfache Rezept: Ein Aufruf, ein Deck

Die Kernidee ist radikal einfach: Übergeben Sie jedes Quelldokument als Anhang, schreiben Sie eine natürlichsprachliche Anweisung und lassen Sie den Agenten alles erledigen — Lesen, Verstehen, Synthese, Layout — in einem einzigen ExecuteInstruction-Aufruf.

string[] sources = new[]
{
    Path.Combine(sampleDir, "AI-Powered Document Processing Report.docx"),
    Path.Combine(sampleDir, "purchase-orders.xlsx"),
    Path.Combine(sampleDir, "invoice_INV-2026-0815.pdf")
};

string instruction =
    "Create a concise Q3 business review summary from the provided documents. " +
    "1. Use a clean blue theme; " +
    "2. Summarize business review, project status, customer pilot research, and platform performance; " +
    "3. Keep each slide focused on one key finding or metric; " +
    "4. Generate 5 slides.";

AIResult result = processor.ExecuteInstruction(
    ppt, instruction, savePath, sources,
    autonomousOutput: true, maxTurns: null);

Das ist das ganze Rezept: ein Methodenaufruf, eine Anweisungszeichenfolge. Keine Parser pro Format, keine Zwischendateien, kein manueller Layout-Code. Der Agent liest jedes Format, entscheidet, was über sie hinweg wichtig ist, und schreibt das Deck direkt nach savePath.

Das Flag autonomousOutput: true ist es, was dies ermöglicht — es teilt dem Agenten mit, dass er Dateien schreiben darf (einschließlich der endgültigen .pptx), ohne bei jedem Schritt eine Bestätigung anzufordern. Setzen Sie maxTurns auf null (oder eine große Zahl), damit der Agent genügend Durchläufe hat, um fertig zu werden.

4. Vollständiges Beispiel: Ein Deck aus Word + PDF + Excel

Hier ist das vollständige Programm. Richten Sie es auf eine Datei oder einen Ordner, und es erstellt das Deck in einem einzigen KI-Aufruf:

using System;
using System.IO;
using System.Linq;
using Spire.Agent.Office.AI;
using Spire.Agent.Office.Extensions;
using Spire.Presentation;

class Program
{
    static void Main()
    {
        string instruction =
            "Create a concise Q3 business review summary from the provided documents. " +
            "1. Use a clean blue theme; " +
            "2. Summarize business review, project status, customer pilot research, and platform performance; " +
            "3. Keep each slide focused on one key finding or metric; " +
            "4. Generate 5 slides.";

        AIOptions options = new AIOptions { SpireToken = "sk-YourSpireToken", TimeoutMs = 1000000 };

        using (Presentation ppt = new Presentation())
        {
            AIResult result = ppt.AI(options).ExecuteInstruction(
                ppt, instruction, @"C:\Samples\Q3_Review.pptx", ResolveInputs(@"C:\Samples"),
                autonomousOutput: true, maxTurns: null);

            Console.WriteLine(result.Success ? "Success" : $"Error={result.ErrorMessage}");
        }
    }

    // Point at a file or a folder; a folder is filtered to supported document formats.
    static string[] ResolveInputs(string path) =>
        File.Exists(path) ? new[] { path }
        : Directory.GetFiles(path).Where(IsSupported).OrderBy(f => f).ToArray();

    static bool IsSupported(string file) =>
        new[] { ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".pdf", ".txt", ".md" }
            .Contains(Path.GetExtension(file).ToLowerInvariant());
}

Das ist das ganze Programm. Abgesehen vom Agent-Aufruf selbst ist der einzige Code ResolveInputs, das lediglich entscheidet, welche Dateien angehängt werden: Es liest oder parst niemals ein Dokument. Die Anweisung ist der einzige Teil, der das Design beschreibt (Thema, Folienanzahl, Fokus); das Lesen, Entscheiden und Layout sind die Aufgabe des Agenten.

Ein Aufruf, fünf Folien — das Deck, das das obige Programm erzeugt:

5. Wie es unter der Haube funktioniert

• AIDocumentProcessor wird über ppt.AI(options) aus einer Presentation abgerufen. Das Presentation-Objekt ist die Leinwand, auf die der Agent Folien zeichnet.
• AIOptions trägt die Konfiguration: SpireToken (Ihr Schlüssel) und TimeoutMs (setzen Sie ihn für echte Dokumente groß — die KI-Analyse großer Dokumente braucht Zeit).
• ExecuteInstruction führt den Agenten aus. Sie übergeben die Presentation, eine natürlichsprachliche instruction, den savePath für die Ausgabe-.pptx und ein string[] mit Quell-dateipfaden (jede Mischung aus Word, PDF, Excel, Markdown). Mit autonomousOutput: true darf der Agent Dateien schreiben — einschließlich des endgültigen Decks — ohne Bestätigung. Er gibt ein AIResult mit Success, ErrorMessage und OutputFiles zurück (alles, was der Agent erstellt hat).
• maxTurns steuert, wie viele Agent-Schritte erlaubt sind. Setzen Sie ihn auf null für kein Limit oder auf eine große Zahl (z. B. 80) für große Dokumentensätze.
• GeneratePresentation(sourcePath, instruction, savePath) ist die dedizierte Abkürzung, wenn Sie genau ein Quelldokument haben. Sie gibt ein PPTGenerationResult zurück (Success, GeneratedPages, TotalPages, OutputPath, ErrorMessage) statt eines AIResult. Ihr sourcePath ist eine einzelne Datei, weshalb dieser Artikel genau den Mehrfach-Anhang-Pfad ExecuteInstruction verwendet: Dieser ermöglicht es, dass ein Deck in einem einzigen Aufruf auf mehrere Quellen zurückgreift.

Warum nicht zuerst in Markdown zusammenführen? Sie können es — siehe Variante B in Abschnitt 6. Aber für die meisten Anwendungsfälle ist der Einzelaufruf-Ansatz einfacher, schneller und liefert dasselbe Ergebnis. Das Zwischen-Markdown ist nur dann nützlich, wenn Sie den zusammengeführten Inhalt überprüfen oder bearbeiten möchten, bevor Sie Token für das Deck ausgeben.

6. Präzise Steuerung

Das obige Rezept ist bewusst minimal gehalten. Wenn Sie mehr Kontrolle benötigen, bauen diese Variationen auf demselben ExecuteInstruction-Aufruf auf.

Stimmen Sie die Anweisung ab. Struktur, Länge, Thema und Diagramme des Decks werden alle durch die Anweisungszeichenfolge gesteuert. Seien Sie explizit:

// e.g. ask for a specific page count, theme, and a chart on a given slide
"Create a 12-slide deck. Light minimalist theme, accent colour #2E5AAC. " +
"Include a bar chart of monthly revenue on slide 5. Keep each slide to one key message.";

Variante A — fassen Sie jede Quelle selbst zusammen (vorhersehbarer). Wenn Sie lieber jedes Dokument einzeln ansprechen möchten, statt einer quellenübergreifenden Anweisung zu vertrauen, durchlaufen Sie SummarizeDocument in einer Schleife, was die Zusammenfassung einer einzelnen Datei durch den Agenten als string zurückgibt:

var sb = new StringBuilder();
foreach (var file in sources)
    sb.AppendLine($"## {Path.GetFileName(file)}\n\n{processor.SummarizeDocument(file)}");
File.WriteAllText(Path.Combine(workDir, "consolidated.md"), sb.ToString());

Übergeben Sie dann das zusammengeführte Markdown als einzige Quelle an ExecuteInstruction — Sie erhalten eine separate Zusammenfassung pro Dokument, die Sie vor der Generierung lesen und bearbeiten können.

Variante B — in Markdown zusammenführen und dann generieren (zweistufig). Für Fälle, in denen Sie eine überprüfbare Zwischendatei wünschen, teilen Sie die Arbeit in zwei Aufrufe auf. Schritt 1 verwendet ExecuteInstruction im autonomen Modus, um alle Quellen in eine Markdown-Datei zusammenzuführen; Schritt 2 führt dieses Markdown erneut ExecuteInstruction zu, um das Deck zu erstellen:

// Step 1 — merge all documents into one Markdown file
string consolidateInstruction =
    "Read all the attached files. Merge their content into a SINGLE Markdown " +
    "document named 'output_consolidated.md'. Use one top-level heading per source, " +
    "preserve key facts / figures / tables, and drop boilerplate. Output ONLY that file.";
processor.ExecuteInstruction(ppt, consolidateInstruction,
    Path.Combine(workDir, "output_consolidated.pptx"), sources,
    autonomousOutput: true, maxTurns: 40);

string consolidatedMd = Path.Combine(workDir, "output_consolidated.md");

// Step 2 — generate the deck from the consolidated Markdown
string genInstruction =
    "Create a 9-slide quarterly business review deck from the consolidated material. " +
    "Professional corporate blue, clear hierarchy, speaker notes per slide.";
processor.ExecuteInstruction(ppt, genInstruction,
    Path.Combine(workDir, "QBR_Deck.pptx"), new[] { consolidatedMd },
    autonomousOutput: true, maxTurns: 40);

Der Kompromiss: Variante B gibt Ihnen eine überprüfbare Markdown-Datei zwischen den beiden Aufrufen, was für das Debugging oder wenn die Zusammenführung eine menschliche Überprüfung erfordert, nützlich ist. Das Einzelaufruf-Rezept in Abschnitt 3 ist die empfohlene Standardeinstellung, weil es einfacher und schneller ist.

Das könnte Sie auch interessieren: Rechnungsverarbeitung mit einem KI-Agenten in .NET automatisieren — ein weiterer dokumentenlastiger Workflow, der dem Agenten einen Ordner mit Dateien übergibt und ein fertiges Dokument zurückbekommt.

7. Ergebnis zurücklesen und überprüfen

Öffnen Sie das Deck nach der Generierung erneut und überprüfen Sie es programmatisch:

using (Presentation deck = new Presentation())
{
    deck.LoadFromFile(savePath);
    Console.WriteLine($"Total slides: {deck.Slides.Count}");

    for (int i = 0; i < deck.Slides.Count; i++)
    {
        ISlide slide = deck.Slides[i];
        string title = slide.Title ?? "(no title)";
        Console.WriteLine($"Slide {i + 1}: {title}");
    }
}

Hier passt auch ein menschlicher Überprüfungsschritt hinein: Laden Sie das generierte Deck, prüfen Sie die Titel und verfeinern Sie die Anweisung, wenn etwas nicht stimmt.

8. FAQ

Das generierte Deck hat die falsche Anzahl von Folien. Wenn eine Quelle groß ist, kann die Analyse länger dauern als das Standard-Timeout und der Agent stoppt vorzeitig. Setzen Sie AIOptions.TimeoutMs auf einen großen Wert (z. B. 1000000 für ~17 Minuten) und geben Sie in der Anweisung einen Seitenbereich an, z. B. „Halten Sie das endgültige Deck auf 8–12 Folien.“

Der Agent nimmt keinen Inhalt aus einem der Dokumente auf. Komplexe Dokumente können einen einzelnen Durchlauf verwirren. Benennen Sie den gewünschten Inhalt explizit in der Anweisung („beziehen Sie die Erkenntnisse aus dem Word-Bericht ein“, „bewahren Sie die Tabelle aus dem Excel-Blatt“). Wenn das Problem weiterhin besteht, versuchen Sie den zweistufigen Ansatz (Variante B in Abschnitt 6), um das zusammengeführte Markdown vor der Generierung zu überprüfen.

Der Aufruf schlägt mit "401 Invalid token" fehl. Das SpireToken wird abgelehnt — stellen Sie sicher, dass es gültig, nicht abgelaufen und korrekt in AIOptions.SpireToken kopiert ist.

Wie übergebe ich mehrere Dokumente? ExecuteInstruction akzeptiert ein string[] mit Dateipfaden als viertes Argument. Übergeben Sie jede Quelldatei — jede Mischung aus .docx, .pdf, .xlsx, .md und mehr — und der Agent liest sie alle in einem Aufruf. Bei einem einzigen Quelldokument ist die dedizierte Abkürzung GeneratePresentation(sourcePath, instruction, savePath); der obige Mehrfach-Anhang-Aufruf ist es, was ein Deck aus mehreren Quellen möglich macht.

Holen Sie sich Ihren SpireToken-Schlüssel Kontaktieren Sie uns, um einen Test- oder kommerziellen API-Schlüssel anzufordern, oder beantragen Sie eine temporäre Lizenz. Konfigurieren Sie ihn im Code:

AIOptions options = new AIOptions();
options.SpireToken = "sk-YourSpireToken";
options.TimeoutMs  = 1000000;

Siehe auch

• Spire.Agent.Office Produktübersicht — das KI-Agent-SDK für Word, Excel, PowerPoint und PDF
• Erste Schritte mit Spire.Agent.Office — installieren Sie das SDK und führen Sie Ihre erste Anweisung aus
• PPT aus Dokumenten generieren — das offizielle Tutorial für die in diesem Artikel verwendete Präsentations-API
• Batch-Vertragsgenerierung mit Spire.Agent.Office — dasselbe anweisungsgesteuerte Muster, angewendet auf die Massendokumentengenerierung