AI Document Processing Examples

An end-to-end pipeline that ingests invoices in PDF, image, or email format, extracts key fields (vendor, amount, line items, dates), validates against purchase orders, and pushes structured data to the accounting system.

// Invoice extraction pipeline
async function processInvoice(document) {
  // Step 1: Convert to text (OCR if needed)
  const text = document.type === "pdf"
    ? await extractPdfText(document)
    : await runOCR(document);

  // Step 2: Extract structured fields with LLM
  const extracted = await llm.chat({
    messages: [{
      role: "system",
      content: "Extract invoice fields as JSON: vendor, invoiceNumber, date, lineItems[], subtotal, tax, total, paymentTerms"
    }, { role: "user", content: text }],
    responseFormat: { type: "json_object" }
  });

  // Step 3: Validate against PO
  const po = await findMatchingPO(extracted.vendor, extracted.total);
  return { ...extracted, poMatch: po?.id, confidence: po ? "high" : "review" };
}

A system that analyses legal contracts to identify key clauses (indemnity, liability caps, termination, IP assignment), flags risky language, and generates a risk summary for legal review. Trained on company-specific risk criteria.

// Contract risk analysis
const riskCriteria = {
  unlimitedLiability: { severity: "high", pattern: "unlimited liability" },
  autoRenewal: { severity: "medium", pattern: "automatic renewal" },
  ipAssignment: { severity: "high", pattern: "assign.*intellectual property" },
  nonCompete: { severity: "medium", pattern: "non-compete|restrictive covenant" },
};

async function analyseContract(contractText) {
  const clauses = await llm.chat({
    messages: [{
      role: "system",
      content: `Identify and classify all clauses in this contract. For each clause, provide: type, text, riskLevel (low/medium/high), and explanation.`
    }, { role: "user", content: contractText }],
    responseFormat: { type: "json_object" }
  });

  const riskScore = clauses.reduce((sum, c) => sum + riskWeights[c.riskLevel], 0);
  return { clauses, riskScore, requiresReview: riskScore > threshold };
}

Processes patient medical records to extract diagnoses, medications, lab results, and care history into a structured timeline. Handles handwritten notes via OCR and reconciles information across multiple document sources.

// Medical record summarisation
async function summarisePatientRecord(documents) {
  const timeline = [];

  for (const doc of documents) {
    const text = doc.handwritten ? await medicalOCR(doc) : await extractText(doc);

    const extracted = await llm.chat({
      messages: [{
        role: "system",
        content: "Extract: date, provider, diagnoses[], medications[], labResults[], procedures[], notes. Use SNOMED codes where possible."
      }, { role: "user", content: text }]
    });

    timeline.push({ ...extracted, sourceDoc: doc.id });
  }

  // Reconcile and deduplicate across sources
  return reconcileTimeline(timeline);
}

Processes expense receipts submitted via email or mobile app, categorises spending, checks against company policy limits, and routes for approval. Handles multiple currencies and receipt formats.

// Expense receipt processing
async function processExpenseReceipt(receipt) {
  const extracted = await llm.extractStructured(receipt.image, {
    fields: ["merchant", "date", "amount", "currency", "category", "items"]
  });

  // Check against policy
  const policy = await getPolicyLimits(receipt.submitterId);
  const violations = [];
  if (extracted.amount > policy.maxSingleExpense) {
    violations.push("Exceeds single expense limit");
  }
  if (!policy.allowedCategories.includes(extracted.category)) {
    violations.push("Category not in approved list");
  }

  return {
    ...extracted,
    policyCompliant: violations.length === 0,
    violations,
    approvalRoute: violations.length > 0 ? "manager" : "auto"
  };
}

Automates the assembly of regulatory filings by pulling data from multiple internal systems, populating templates, cross-referencing prior submissions for consistency, and flagging discrepancies for human review.

// Regulatory filing assembly
async function assembleRegFiling(filingType, period) {
  // Gather data from multiple sources
  const [financials, riskData, complianceNotes] = await Promise.all([
    fetchFinancialData(period),
    fetchRiskAssessments(period),
    fetchComplianceNotes(period),
  ]);

  // Check consistency with prior filings
  const priorFiling = await getPriorFiling(filingType, previousPeriod);
  const inconsistencies = await llm.chat({
    messages: [{
      role: "system",
      content: "Compare current data with prior filing. Flag any material changes or inconsistencies that need explanation."
    }, { role: "user", content: JSON.stringify({ current: financials, prior: priorFiling }) }]
  });

  // Populate template
  const filing = await populateTemplate(filingType, { financials, riskData, complianceNotes });
  return { filing, inconsistencies, requiresReview: inconsistencies.length > 0 };
}