Structify: Von Chaos zu Struktur in Sekunden

Beginnen Sie mit einem einfachen flachen Schema für unkomplizierte Extraktion

{
  "name": "string",
  "email": "string",
  "phone": "string",
  "company": "string",
  "role": "string"
}

Eingabe: Input-Text: ''Hallo, ich bin Sarah Johnson von TechCorp (sarah.j@techcorp.com, +1-555-0123). Ich bin VP of Engineering.''

Ausgabe: Output: '{'name: ''Sarah Johnson'', email: ''sarah.j@techcorp.com'', phone: ''+1-555-0123'', company: ''TechCorp'', role: ''VP of Engineering'''}'

Spezifizieren Sie exakte Typen für bessere Validierung und Type Safety

{
  "invoice_number": "string",
  "date": "date",
  "total_amount": "number",
  "currency": "string",
  "is_paid": "boolean",
  "line_items": "array",
  "vendor": {
    "name": "string",
    "address": "string",
    "tax_id": "string"
  }
}

Extrahieren Sie hierarchische Daten mit verschachtelten Objekten

{
  "product": {
    "name": "string",
    "sku": "string",
    "price": {
      "amount": "number",
      "currency": "string",
      "tax_included": "boolean"
    },
    "availability": {
      "in_stock": "boolean",
      "quantity": "number",
      "warehouse": "string"
    },
    "specifications": {
      "dimensions": "string",
      "weight": "number",
      "color": "string"
    }
  }
}

Verschachtelte Schemas halten zusammengehörige Daten organisiert und erleichtern die nachgelagerte Verarbeitung.

Extrahieren Sie Listen und Collections aus Text

{ "tags": ["string"], "prices": ["number"] }

{
  "line_items": [
    {
      "description": "string",
      "quantity": "number",
      "unit_price": "number",
      "total": "number"
    }
  ]
}

Perfekt für Rechnungen, Warenkörbe, Multi-Item-Formulare und Produktlisten.

Markieren Sie Felder als optional, wenn sie möglicherweise nicht in allen Dokumenten erscheinen

{
  "name": "string",          // Pflicht
  "email": "string",         // Pflicht
  "phone?": "string",        // Optional
  "company?": "string",      // Optional
  "role?": "string"          // Optional
}

Verwenden Sie das `?`-Suffix oder spezifizieren Sie `required: false` im JSON-Schema-Format.

Implementieren Sie Business-Logic-Validierung nach der Extraktion

const result = await structifyAPI.extract(text, schema);

// Custom Validation
if (result.total_amount < 0) {
  throw new ValidationError('Gesamtbetrag kann nicht negativ sein');
}

if (result.line_items.length === 0) {
  throw new ValidationError('Rechnung muss mindestens eine Position enthalten');
}

const calculatedTotal = result.line_items
  .reduce((sum, item) => sum + item.total, 0);

if (Math.abs(calculatedTotal - result.total_amount) > 0.01) {
  throw new ValidationError('Positionen stimmen nicht mit Gesamtbetrag überein');
}

Verarbeiten Sie mehrere Dokumente effizient

async function batchStructify(documents, schema) {
  const results = [];
  const errors = [];
  
  // Parallel verarbeiten (Batch-Größe: 10)
  for (let i = 0; i < documents.length; i += 10) {
    const batch = documents.slice(i, i + 10);
    
    const promises = batch.map(async (doc) => {
      try {
        const result = await structifyAPI.extract(doc.text, schema);
        return { id: doc.id, data: result, status: 'success' };
      } catch (error) {
        return { id: doc.id, error: error.message, status: 'failed' };
      }
    });
    
    const batchResults = await Promise.allSettled(promises);
    
    batchResults.forEach(result => {
      if (result.status === 'fulfilled') {
        if (result.value.status === 'success') {
          results.push(result.value);
        } else {
          errors.push(result.value);
        }
      }
    });
  }
  
  return { results, errors };
}

Verarbeiten Sie 1000 Dokumente in 15 Minuten statt 3+ Stunden sequenziell

Behandeln Sie temporäre Fehler graceful

async function extractWithRetry(text, schema, maxRetries = 3) {
  let lastError;
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await structifyAPI.extract(text, schema);
    } catch (error) {
      lastError = error;
      
      // Nur bei temporären Fehlern wiederholen
      if (error.code === 'RATE_LIMIT' || error.code === 'TIMEOUT') {
        const delay = Math.pow(2, attempt) * 1000; // Exponential Backoff
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      
      // Validierungsfehler nicht wiederholen
      throw error;
    }
  }
  
  throw lastError;
}

Implementieren Sie Exponential Backoff: 2s, 4s, 8s Verzögerungen zwischen Wiederholungen

Validieren Sie Extraktionsqualität vor nachgelagerter Verwendung

function validateExtraction(result, rules) {
  const issues = [];
  
  // Vollständigkeits-Check
  if (!result.email || !result.name) {
    issues.push('Pflichtfelder fehlen');
  }
  
  // Format-Validierung
  if (result.email && !isValidEmail(result.email)) {
    issues.push('Ungültiges E-Mail-Format');
  }
  
  // Bereichs-Validierung
  if (result.price && result.price < 0) {
    issues.push('Preis kann nicht negativ sein');
  }
  
  return { valid: issues.length === 0, issues };
}

Markieren Sie Extraktionen niedriger Qualität für manuelle Prüfung, statt schlechte Daten zu verwenden

Cachen Sie Extraktionsergebnisse, um Punkte zu sparen und Performance zu verbessern

Hash Input-Text + Schema → Cache-Key

const crypto = require('crypto');

function getCacheKey(text, schema) {
  const hash = crypto.createHash('sha256');
  hash.update(text + JSON.stringify(schema));
  return hash.digest('hex');
}

async function extractWithCache(text, schema) {
  const cacheKey = getCacheKey(text, schema);
  
  // Cache prüfen
  const cached = await cache.get(cacheKey);
  if (cached) return JSON.parse(cached);
  
  // Extrahieren
  const result = await structifyAPI.extract(text, schema);
  
  // Cache für 24 Stunden
  await cache.set(cacheKey, JSON.stringify(result), 86400);
  
  return result;
}

Sparen Sie 70% der Punkte bei wiederholten Extraktionen, 10x schnellere Antwortzeiten

Tracken Sie Extraktionsqualität und Performance

Alert bei: Erfolgsrate < 95%, Extraktionszeit > 10s, tägliche Punkte > Budget

Extrahieren: Name, E-Mail, Telefon, Erfahrung, Ausbildung, Skills

Validieren: E-Mail-Format, Telefon-Format, Pflichtfelder vorhanden

Verarbeiten: 500 Lebensläufe in unter 20 Minuten

Qualität: 95%+ Erfolgsrate, unvollständige Datensätze zur Prüfung markieren