Construyamos: un pipeline de inteligencia documental con Transloadit
El mercado de la inteligencia documental está en auge. Empresas como Reducto.ai están ganando terreno al ayudar a las empresas a extraer datos estructurados de archivos PDF y documentos escaneados. Su propuesta de valor es convincente: sube un documento, define un esquema y recibe JSON limpio.
Dicho esto, si quieres control a nivel de producto —enrutamiento personalizado, almacenamiento, cumplimiento normativo y una estrecha integración con el resto de tus flujos de trabajo de archivos—, suele ser más eficaz crear tu propia experiencia al estilo de Reducto a partir de primitivas.
Transloadit tiene todo lo necesario para proporcionarte esas primitivas. En esta guía, te mostraremos cómo combinar nuestros Robots de procesamiento de documentos con 🤖 /ai/chat (English) para crear un pipeline flexible basado en esquemas que puedas convertir en tu propio producto de IA documental.
Si quieres un producto listo para usar, un proveedor especializado en IA documental puede ser una excelente opción. Pero si necesitas combinar la extracción de documentos con subidas, conversiones, almacenamiento y flujos de trabajo posteriores, desarrollar sobre Transloadit te brinda mayor flexibilidad.
Qué significa realmente la inteligencia documental
En esencia, la inteligencia documental implica tres capacidades clave:
- Analizar: extraer texto de documentos mediante OCR, conservando el diseño y la estructura.
- Dividir: separar documentos de varias páginas en fragmentos manejables.
- Extraer: obtener datos estructurados que coincidan con un esquema predefinido.
Construyamos cada una de estas capacidades con el versátil conjunto de herramientas de Transloadit.
Configura tu proyecto de TypeScript
Primero, configura un proyecto con el SDK de Node de Transloadit:
yarn init -y
yarn add transloadit
Nota
El SDK de Node v4 requiere Node.js 20 o una versión posterior. Si estás actualizando desde v3 o CommonJS, consulta la guía de migración.
Crea tu cliente:
import { Transloadit } from 'transloadit'
const transloadit = new Transloadit({
authKey: process.env.TRANSLOADIT_AUTH_KEY!,
authSecret: process.env.TRANSLOADIT_AUTH_SECRET!,
})
Paso 1: análisis de documentos con OCR (opcional)
El 🤖 /document/ocr (English) Robot extrae texto de archivos PDF, incluidos los PDF escaneados. Es compatible con varios proveedores y puede devolver resultados con coordenadas de diseño o como texto sin formato. Si tu archivo de origen no es un PDF, conviértelo primero con el 🤖 /document/convert Robot.
Si usas un modelo compatible con PDF, como Claude Sonnet 4, puedes omitir el OCR y enviar el PDF directamente al 🤖 /ai/chat (English) Robot. El OCR sigue siendo útil cuando necesitas coordenadas de diseño o quieres normalizar primero archivos que no son PDF.
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
La opción granularity: 'full' devuelve las coordenadas del cuadro delimitador de cada bloque de texto, lo que resulta
útil para comprender el diseño.
Paso 2: división de documentos
Para documentos grandes, el 🤖 /document/split (English) Robot te permite extraer páginas específicas:
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,
})
Paso 3: extracción de datos con IA basada en esquemas
Aquí es donde ocurre la magia. El 🤖 /ai/chat (English) Robot puede
procesar documentos y devolver JSON estructurado que coincida con tu esquema. Esto es directamente comparable
con la API Extract de Reducto. Claude Sonnet 4 es compatible con PDF, así que usaremos
model: 'anthropic/claude-4-sonnet-20250514' a continuación. Cuando configuras format: 'json', el resultado es un
archivo JSON en los resultados de la Assembly.
Zod v4 incluye una función auxiliar nativa z.toJSONSchema(). Los fragmentos siguientes usan una pequeña función auxiliar que la invoca
cuando está disponible y recurre a zod-to-json-schema para proyectos con Zod v3.
Si tu cuenta no tiene configuradas credenciales de IA compartidas, crea Template
Credentials de IA en el panel de Transloadit (para OpenAI, Anthropic o Google) y haz referencia a ellas
mediante credentials.
Para comenzar rápidamente, puedes omitir credentials y configurar test_credentials: true para usar
claves de prueba proporcionadas por Transloadit. Aunque esto es práctico para demostraciones, las claves compartidas pueden tener límites de solicitudes,
por lo que las cargas de trabajo de producción deberían proporcionar sus propias credenciales.
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}`)
Crea un pipeline completo
Ahora combinemos todo en un pipeline listo para producción que permita:
- extraer texto opcionalmente con OCR,
- dividir archivos grandes,
- extraer datos estructurados con IA y
- almacenar resultados en S3.
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}`)
La ruta /document/convert → PDF admite los siguientes tipos de entrada:
- Word:
.doc,.docx - PowerPoint:
.ppt,.pptx,.pps,.ppz,.pot - Excel:
.xls,.xlsx,.xla - OpenDocument:
.odt,.ott,.odd,.oda - Web/marcado:
.html,.xhtml,.xml, Markdown (.md) - Texto y texto enriquecido:
.txt,.csv,.rtf,.rtx,.tex/LaTeX - Imágenes:
.jpg,.jpeg,.png,.gif,.svg - Vectores/impresión:
.ai,.eps,.ps
Si necesitas resultados de OCR para flujos de trabajo que tienen en cuenta el diseño, inserta un Step /document/ocr y
cambia use: ':original' por use: 'ocr_text'; luego incluye ese Step en tus destinos de
almacenamiento.
Procesa varios tipos de documentos
Con el 🤖 /file/filter Robot, puedes enviar los PDF
directamente al modelo y convertir primero todo lo demás a PDF. Usar != hace explícita la
rama para archivos que no son PDF:
// 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,
})
Descripción general del flujo:
:original
├─ pdf_verified (file/filter: mime == pdf) ──▶ /ai/chat
└─ non_pdf (file/filter: mime != pdf) ──▶ /document/convert (pdf) ──▶ /ai/chat
Usa Templates para facilitar la reutilización
Para producción, guarda tus Assembly Instructions como un Template y haz referencia a este mediante su 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,
})
Procesa lotes grandes de documentos
Para procesar eficientemente un lote con muchos documentos, conviene limitar la concurrencia:
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]))
}
Por qué los equipos eligen Transloadit para la IA documental
- Una sola API abarca la ingesta, conversión, OCR, extracción con IA y entrega.
- Integraciones de importación y exportación para almacenamiento en la nube (S3, Azure, Google Cloud Storage, Dropbox y más).
- Las Assembly Instructions te permiten versionar, reutilizar y bifurcar pipelines sin código de integración.
- Un solo proveedor para documentos y cargas de trabajo de archivos más amplias (vistas previas, miniaturas, análisis antivirus y procesamiento de imágenes, audio y video).
Transloadit frente a plataformas especializadas en IA documental
Piensa en Reducto como un producto especializado y en Transloadit como una plataforma componible. Puedes replicar el flujo principal de extracción y luego ampliarlo con todo lo que lo rodea.
| Funcionalidad | Transloadit | Reducto.ai |
|---|---|---|
| OCR y extracción de texto | ✅ 🤖 /document/ocr (English) (PDF) | ✅ API Parse |
| División de documentos | ✅ 🤖 /document/split (English) | ✅ API Split |
| Extracción basada en esquemas | ✅ 🤖 /ai/chat (English) con esquema JSON | ✅ API Extract |
| Integraciones de almacenamiento | ✅ Importación/exportación a almacenamiento en la nube | Herramientas externas |
| Orquestación de flujos de trabajo | ✅ Assembly Instructions + Templates | Herramientas externas |
| Proveedores de IA | ✅ OpenAI, Anthropic, Google (con credenciales) | — |
| Cargas de trabajo de archivos amplias | ✅ Imágenes/video/audio + vistas previas + seguridad | Plataforma centrada en documentos |
Cuándo usar este enfoque
Este enfoque basado en Transloadit es una excelente opción cuando:
- quieres crear tu propio producto de IA documental o plataforma interna,
- quieres un solo proveedor para la ingesta, conversión, extracción y entrega,
- necesitas combinar la inteligencia documental con flujos de trabajo multimedia más amplios y
- quieres flexibilidad para elegir proveedores de IA y precios predecibles.
¿Todo listo para comenzar?
La inteligencia documental no tiene por qué implicar agregar otro proveedor especializado. Con los 🤖 /document/ocr (English), 🤖 /document/split (English) y 🤖 /ai/chat (English) Robots, puedes crear sofisticados pipelines de extracción que compitan con plataformas especializadas.
Comienza por explorar nuestra documentación de Robots de IA y descubre hasta dónde puedes llevar tus flujos de trabajo de documentos dentro de una sola plataforma.