Let's Build: Dokumentintelligenz-Pipeline mit Transloadit
Der Markt für Dokumentintelligenz boomt. Unternehmen wie Reducto.ai gewinnen an Bedeutung, indem sie Unternehmen dabei helfen, strukturierte Daten aus PDFs und gescannten Dokumenten zu extrahieren. Ihr Nutzenversprechen ist überzeugend: Dokument hochladen, Schema definieren, sauberes JSON zurückerhalten.
Wenn Sie jedoch Kontrolle auf Produktebene benötigen – individuelles Routing, Storage, Compliance und eine enge Integration mit Ihren übrigen Datei-Workflows – ist es oft leistungsstärker, eine eigene Reducto-ähnliche Experience auf Basis von Primitiven zu entwickeln.
Transloadit bietet alles, was Sie benötigen, um diese Primitiven bereitzustellen. In diesem Leitfaden zeigen wir Ihnen, wie Sie unsere Dokumentverarbeitungs-Robots mit 🤖 /ai/chat kombinieren, um eine flexible, schemagesteuerte Pipeline zu erstellen, die Sie zu Ihrem eigenen Dokument-KI-Produkt formen können.
Wenn Sie ein schlüsselfertiges Produkt suchen, kann ein spezialisierter Anbieter für Dokument-KI sehr gut passen. Wenn Sie jedoch Dokumentextraktion mit Uploads, Konvertierungen, Storage und nachgelagerten Workflows verbinden müssen, verschafft Ihnen Transloadit mehr Hebelwirkung.
Was Dokumentintelligenz wirklich bedeutet
Im Kern umfasst Dokumentintelligenz drei zentrale Fähigkeiten:
- Parsen – Text per OCR aus Dokumenten extrahieren und dabei Layout und Struktur bewahren.
- Aufteilen – mehrseitige Dokumente in handhabbare Abschnitte zerlegen.
- Extrahieren – strukturierte Daten gemäß einem vordefinierten Schema gewinnen.
Lassen Sie uns jede dieser Funktionen mit Transloadits vielseitigem Toolkit erstellen.
TypeScript-Projekt einrichten
Richten Sie zunächst ein Projekt mit dem Transloadit Node SDK ein:
yarn init -y
yarn add transloadit
Hinweis
Das v4 Node SDK erfordert Node.js 20 oder neuer. Wenn Sie von v3 oder CommonJS upgraden, lesen Sie den Migrationsleitfaden.
Erstellen Sie Ihren Client:
import { Transloadit } from 'transloadit'
const transloadit = new Transloadit({
authKey: process.env.TRANSLOADIT_AUTH_KEY!,
authSecret: process.env.TRANSLOADIT_AUTH_SECRET!,
})
Schritt 1: Dokument-Parsing mit OCR (optional)
Der 🤖 /document/ocr Robot extrahiert Text aus PDFs, einschließlich gescannter PDFs. Er unterstützt mehrere Anbieter und kann Ergebnisse mit Layout- Koordinaten oder als Klartext zurückgeben. Wenn Ihre Quelle kein PDF ist, konvertieren Sie sie zuerst mit dem 🤖 /document/convert Robot.
Wenn Sie ein PDF-fähiges Modell wie Claude Sonnet 4 verwenden, können Sie OCR überspringen und das PDF direkt an den 🤖 /ai/chat Robot senden. OCR ist weiterhin nützlich, wenn Sie Layout-Koordinaten benötigen oder Nicht-PDF-Dateien zuerst normalisieren möchten.
const parseResult = await transloadit.createAssembly({
params: {
steps: {
ocr_extract: {
robot: '/document/ocr',
use: ':original',
provider: 'gcp',
format: 'json',
granularity: 'full',
result: true,
},
},
},
files: {
document: './invoice.pdf',
},
waitForCompletion: true,
})
const ocrResults = parseResult.results.ocr_extract
Die Option granularity: 'full' gibt Bounding-Box-Koordinaten für jeden Textblock zurück. Das ist
hilfreich, um das Layout zu verstehen.
Schritt 2: Dokumente aufteilen
Für große Dokumente können Sie mit dem 🤖 /document/split Robot bestimmte Seiten extrahieren:
const splitResult = await transloadit.createAssembly({
params: {
steps: {
first_pages: {
robot: '/document/split',
use: ':original',
pages: ['1-5'],
},
remaining_pages: {
robot: '/document/split',
use: ':original',
pages: ['6-'],
},
},
},
files: {
document: './large-report.pdf',
},
waitForCompletion: true,
})
Schritt 3: Schemagesteuerte Datenextraktion mit KI
Hier passiert die Magie. Der 🤖 /ai/chat Robot kann
Dokumente verarbeiten und strukturiertes JSON zurückgeben, das Ihrem Schema entspricht. Das ist direkt vergleichbar
mit Reductos Extract API. Claude Sonnet 4 unterstützt PDFs, daher verwenden wir unten
model: 'anthropic/claude-4-sonnet-20250514'. Wenn Sie format: 'json' setzen, ist die Ausgabe eine
JSON-Datei in den Ergebnissen der Assembly.
Zod v4 enthält einen nativen z.toJSONSchema()-Helper. Die folgenden Snippets verwenden einen kleinen Helper, der ihn aufruft,
wenn er verfügbar ist, und für Zod-v3-Projekte auf zod-to-json-schema zurückfällt.
Wenn für Ihr Konto keine gemeinsamen KI-Zugangsdaten konfiguriert sind, erstellen Sie im Transloadit-Dashboard KI-Template
Credentials (für OpenAI, Anthropic oder Google) und referenzieren Sie diese
über credentials.
Für einen schnellen Start können Sie credentials weglassen und test_credentials: true setzen, um von
Transloadit bereitgestellte Test-Keys zu verwenden. Das ist praktisch für Demos, gemeinsame Keys können jedoch rate-limitiert sein;
Produktions-Workloads sollten daher eigene Zugangsdaten bereitstellen.
import { z } from 'zod'
import { zodToJsonSchema } from 'zod-to-json-schema'
const toJsonSchema = (schema: z.ZodTypeAny) =>
typeof (z as { toJSONSchema?: (schema: z.ZodTypeAny) => unknown }).toJSONSchema === 'function'
? (z as { toJSONSchema: (schema: z.ZodTypeAny) => unknown }).toJSONSchema(schema)
: zodToJsonSchema(schema)
const invoiceSchema = z.object({
invoice_number: z.string(),
vendor_name: z.string(),
vendor_address: z.string().optional(),
invoice_date: z.string().optional(),
due_date: z.string().optional(),
total_amount: z.number(),
currency: z.string().optional(),
line_items: z
.array(
z.object({
description: z.string(),
quantity: z.number().optional(),
unit_price: z.number().optional(),
total: z.number().optional(),
}),
)
.optional(),
tax_amount: z.number().optional(),
payment_terms: z.string().optional(),
})
const extractionResult = await transloadit.createAssembly({
params: {
steps: {
extract_data: {
robot: '/ai/chat',
use: ':original',
credentials: 'my_ai_credentials',
model: 'anthropic/claude-4-sonnet-20250514',
format: 'json',
schema: JSON.stringify(toJsonSchema(invoiceSchema)),
messages: `Extract all invoice data from this document.
Be precise with amounts and dates.
If a field is not present, omit it from the response.`,
result: true,
},
},
},
files: {
invoice: './invoice.pdf',
},
waitForCompletion: true,
})
const extractedFile = extractionResult.results.extract_data[0]
const invoiceData = await fetch(extractedFile.ssl_url).then((response) => response.json())
console.log(`Invoice #${invoiceData.invoice_number}: $${invoiceData.total_amount}`)
Eine vollständige Pipeline erstellen
Kombinieren wir nun alles zu einer produktionsreifen Pipeline, die:
- optional Text per OCR extrahiert,
- große Dateien aufteilt,
- strukturierte Daten mit KI extrahiert und
- Ergebnisse in S3 speichert.
import { z } from 'zod'
import { zodToJsonSchema } from 'zod-to-json-schema'
import { Transloadit } from 'transloadit'
const toJsonSchema = (schema: z.ZodTypeAny) =>
typeof (z as { toJSONSchema?: (schema: z.ZodTypeAny) => unknown }).toJSONSchema === 'function'
? (z as { toJSONSchema: (schema: z.ZodTypeAny) => unknown }).toJSONSchema(schema)
: zodToJsonSchema(schema)
const financialDocumentSchema = z.object({
document_type: z.enum(['invoice', 'receipt', 'statement', 'contract']),
document_date: z.string(),
parties: z.array(
z.object({
name: z.string(),
role: z.enum(['vendor', 'customer', 'signatory']),
address: z.string().optional(),
}),
),
amounts: z.array(
z.object({
description: z.string(),
value: z.number(),
currency: z.string(),
}),
),
key_terms: z.array(z.string()).optional(),
summary: z.string(),
})
type FinancialDocument = z.infer<typeof financialDocumentSchema>
const transloadit = new Transloadit({
authKey: process.env.TRANSLOADIT_AUTH_KEY!,
authSecret: process.env.TRANSLOADIT_AUTH_SECRET!,
})
async function processFinancialDocument(filePath: string) {
const result = await transloadit.createAssembly({
params: {
steps: {
pdf_verified: {
robot: '/file/filter',
use: ':original',
accepts: [['${file.mime}', '==', 'application/pdf']],
},
non_pdf: {
robot: '/file/filter',
use: ':original',
accepts: [['${file.mime}', '!=', 'application/pdf']],
},
pdf_converted: {
robot: '/document/convert',
use: 'non_pdf',
format: 'pdf',
},
extract_structured: {
robot: '/ai/chat',
use: ['pdf_verified', 'pdf_converted'],
credentials: 'ai_credentials',
model: 'anthropic/claude-4-sonnet-20250514',
format: 'json',
schema: JSON.stringify(toJsonSchema(financialDocumentSchema)),
messages: 'Extract the structured data from this document.',
result: true,
},
store_results: {
robot: '/s3/store',
use: [':original', 'extract_structured'],
credentials: 's3_credentials',
path: 'documents/${file.name}/',
},
},
},
files: {
document: filePath,
},
waitForCompletion: true,
})
if (result.ok !== 'ASSEMBLY_COMPLETED') {
throw new Error(`Assembly failed: ${result.error}`)
}
const extractedFile = result.results.extract_structured[0]
return fetch(extractedFile.ssl_url).then((response) => response.json())
}
const data = await processFinancialDocument('./contract.pdf')
console.log(`Processed ${data.document_type}: ${data.summary}`)
Der Pfad /document/convert → PDF unterstützt folgende Eingabetypen:
- Word:
.doc,.docx - PowerPoint:
.ppt,.pptx,.pps,.ppz,.pot - Excel:
.xls,.xlsx,.xla - OpenDocument:
.odt,.ott,.odd,.oda - Web/Markup:
.html,.xhtml,.xml, Markdown (.md) - Text & Rich Text:
.txt,.csv,.rtf,.rtx,.tex/LaTeX - Bilder:
.jpg,.jpeg,.png,.gif,.svg - Vektor/Druck:
.ai,.eps,.ps
Wenn Sie OCR-Ausgaben für layoutbewusste Workflows benötigen, fügen Sie einen /document/ocr-Step ein und
ändern Sie use: ':original' in use: 'ocr_text'. Nehmen Sie diesen Step anschließend in Ihre Storage-
Ziele auf.
Mehrere Dokumenttypen verarbeiten
Mit dem 🤖 /file/filter Robot können Sie PDFs
direkt an das Modell routen und alles andere zuerst in PDF konvertieren. Mit != wird der Nicht-PDF-
Zweig explizit:
// Reuse invoiceSchema + toJsonSchema from above.
const multiTypeResult = await transloadit.createAssembly({
params: {
steps: {
pdf_verified: {
robot: '/file/filter',
use: ':original',
accepts: [['${file.mime}', '==', 'application/pdf']],
},
non_pdf: {
robot: '/file/filter',
use: ':original',
accepts: [['${file.mime}', '!=', 'application/pdf']],
},
pdf_converted: {
robot: '/document/convert',
use: 'non_pdf',
format: 'pdf',
},
extract_data: {
robot: '/ai/chat',
use: ['pdf_verified', 'pdf_converted'],
credentials: 'ai_credentials',
model: 'anthropic/claude-4-sonnet-20250514',
format: 'json',
schema: JSON.stringify(toJsonSchema(invoiceSchema)),
messages: 'Extract data from this document.',
result: true,
},
},
},
files: {
doc1: './receipt.pdf',
doc2: './receipt-photo.jpg',
},
waitForCompletion: true,
})
Flow-Übersicht:
:original
├─ pdf_verified (file/filter: mime == pdf) ──▶ /ai/chat
└─ non_pdf (file/filter: mime != pdf) ──▶ /document/convert (pdf) ──▶ /ai/chat
Templates für Wiederverwendbarkeit nutzen
Für den Produktionseinsatz speichern Sie Ihre Assembly Instructions als Template und referenzieren es per ID:
const result = await transloadit.createAssembly({
params: {
template_id: 'your-invoice-extraction-template',
fields: {
custom_prompt: 'Focus on extracting payment terms and due dates.',
},
},
files: {
document: './invoice.pdf',
},
waitForCompletion: true,
})
Große Dokument-Batches verarbeiten
Um einen Batch mit vielen Dokumenten effizient zu verarbeiten, ist es am besten, die Parallelität begrenzt zu halten:
import pMap from 'p-map'
async function processBatch(files: string[]): Promise<Map<string, FinancialDocument>> {
const concurrency = 5
const batchResults = await pMap(
files,
async (file) => {
const result = await transloadit.createAssembly({
params: {
template_id: 'document-extraction-template',
},
files: { document: file },
waitForCompletion: true,
})
// Assumes the template includes a step named `extract_structured`.
const extractedFile = result.results.extract_structured[0]
const data = await fetch(extractedFile.ssl_url).then((response) => response.json())
return {
file,
data,
}
},
{ concurrency },
)
return new Map(batchResults.map(({ file, data }) => [file, data]))
}
Warum Teams Transloadit für Dokument-KI wählen
- Eine einzige API deckt Ingest, Konvertierung, OCR, KI-Extraktion und Auslieferung ab.
- Import-/Export-Integrationen für Cloud Storage (S3, Azure, Google Cloud Storage, Dropbox und mehr).
- Assembly Instructions ermöglichen Versionierung, Wiederverwendung und Verzweigung von Pipelines ohne Glue-Code.
- Ein einziger Anbieter für Dokumente und breitere Datei-Workloads (Previews, Thumbnails, Virenscans, Bild-/Audio-/Videoverarbeitung).
Transloadit vs. spezialisierte Dokument-KI-Plattformen
Betrachten Sie Reducto als fokussiertes Produkt und Transloadit als komponierbare Plattform. Sie können den zentralen Extraktions-Flow nachbilden und ihn anschließend um alles ergänzen, was dazugehört.
| Feature | Transloadit | Reducto.ai |
|---|---|---|
| OCR / Textextraktion | ✅ 🤖 /document/ocr (PDFs) | ✅ Parse API |
| Dokumentaufteilung | ✅ 🤖 /document/split | ✅ Split API |
| Schemabasierte Extraktion | ✅ 🤖 /ai/chat mit JSON-Schema | ✅ Extract API |
| Storage-Integrationen | ✅ Import/Export zu Cloud Storage | Externes Tooling |
| Workflow-Orchestrierung | ✅ Assembly Instructions + Templates | Externes Tooling |
| KI-Anbieter | ✅ OpenAI, Anthropic, Google (mit Zugangsdaten) | — |
| Breitere Datei-Workloads | ✅ Bild/Video/Audio + Previews + Sicherheit | Dokumentfokussierter Stack |
Wann Sie diesen Ansatz verwenden sollten
Dieser Transloadit-basierte Ansatz passt besonders gut, wenn:
- Sie Ihr eigenes Dokument-KI-Produkt oder eine interne Plattform entwickeln möchten,
- Sie einen Anbieter für Ingest, Konvertierung, Extraktion und Auslieferung suchen,
- Sie Dokumentintelligenz mit breiteren Medien-Workflows kombinieren müssen und
- Sie Flexibilität bei der Wahl von KI-Anbietern sowie planbare Preise wünschen.
Bereit zum Entwickeln?
Dokumentintelligenz muss nicht bedeuten, einen weiteren spezialisierten Anbieter einzubinden. Mit den 🤖 /document/ocr, 🤖 /document/split und 🤖 /ai/chat Robots können Sie anspruchsvolle Extraktions-Pipelines erstellen, die mit spezialisierten Plattformen mithalten.
Starten Sie mit unseren AI Robot docs und entdecken Sie, wie weit Sie Ihre Dokument-Workflows innerhalb einer einzigen Plattform bringen können.