Code Examples¶

const { ArchivusClient } = require('@archivus/sdk');

const client = new ArchivusClient({
  apiKey: process.env.ARCHIVUS_API_KEY,
  tenant: process.env.ARCHIVUS_TENANT
});

async function uploadAndProcess() {
  const fs = require('fs');
  const file = fs.createReadStream('contract.pdf');

  // Upload with AI processing
  const document = await client.documents.upload({
    file,
    enableAI: true,
    folderId: 'folder_legal'
  });

  console.log('Document uploaded:', document.id);

  // Poll for AI completion
  let processed = false;
  while (!processed) {
    const doc = await client.documents.get(document.id);
    if (doc.ai_status === 'completed') {
      console.log('AI Summary:', doc.ai_summary);
      console.log('AI Tags:', doc.ai_tags);
      console.log('Entities:', doc.entities);
      processed = true;
    } else if (doc.ai_status === 'failed') {
      console.error('AI processing failed');
      break;
    }
    await new Promise(resolve => setTimeout(resolve, 2000));
  }
}

uploadAndProcess();

async function searchDocuments() {
  const results = await client.search.query('contract renewal terms', {
    mode: 'semantic',
    limit: 10,
    minScore: 0.7,
    folderId: 'folder_legal'
  });

  console.log(`Found ${results.total} documents`);

  results.results.forEach(result => {
    console.log(`\n${result.document.filename} (score: ${result.score})`);
    console.log(`Summary: ${result.document.ai_summary}`);
    console.log(`Highlight: ${result.highlight}`);
  });
}

async function chatWithDocument(documentId) {
  // Create session
  const session = await client.chat.createSession({
    documentId,
    name: 'Contract Analysis'
  });

  // Ask multiple questions
  const questions = [
    'What are the key terms?',
    'What is the contract duration?',
    'What are the payment terms?',
    'What are the termination conditions?'
  ];

  for (const question of questions) {
    const answer = await client.chat.ask(session.id, question);

    console.log(`\nQ: ${question}`);
    console.log(`A: ${answer.content}`);
    console.log(`Confidence: ${(answer.confidence * 100).toFixed(0)}%`);

    if (answer.sources.length > 0) {
      console.log('Sources:');
      answer.sources.forEach(source => {
        console.log(`  - Page ${source.page}: "${source.excerpt}"`);
      });
    }
  }
}

const fs = require('fs');
const path = require('path');

async function batchUpload(directory) {
  const files = fs.readdirSync(directory)
    .filter(f => f.endsWith('.pdf'));

  console.log(`Uploading ${files.length} files...`);

  const uploadPromises = files.map(filename => {
    const filepath = path.join(directory, filename);
    const file = fs.createReadStream(filepath);

    return client.documents.upload({
      file,
      enableAI: true
    }).then(doc => {
      console.log(`✓ Uploaded: ${filename} → ${doc.id}`);
      return doc;
    }).catch(err => {
      console.error(`✗ Failed: ${filename} → ${err.message}`);
      return null;
    });
  });

  const documents = await Promise.all(uploadPromises);
  const successful = documents.filter(d => d !== null);

  console.log(`\nCompleted: ${successful.length}/${files.length} files uploaded`);
  return successful;
}

const express = require('express');
const { verifyWebhookSignature } = require('@archivus/sdk');

const app = express();
const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET;

app.post('/webhooks/archivus',
  express.raw({ type: 'application/json' }),
  async (req, res) => {
    const signature = req.headers['x-archivus-signature'];
    const payload = req.body.toString();

    // Verify signature
    if (!verifyWebhookSignature(payload, signature, WEBHOOK_SECRET)) {
      return res.status(401).send('Invalid signature');
    }

    const event = JSON.parse(payload);

    // Handle event asynchronously
    handleEvent(event).catch(console.error);

    // Respond immediately
    res.json({ status: 'ok' });
  }
);

async function handleEvent(event) {
  switch (event.type) {
    case 'document.processed':
      await onDocumentProcessed(event.data);
      break;
    case 'document.failed':
      await onDocumentFailed(event.data);
      break;
    case 'dag.execution.completed':
      await onWorkflowCompleted(event.data);
      break;
  }
}

async function onDocumentProcessed(data) {
  console.log(`Document ${data.document_id} processed`);
  console.log(`Summary: ${data.ai_summary}`);

  // Trigger downstream processing
  await processDocument(data.document_id);
}

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000');
});