TypeScript Basic Operations

import fs from 'fs';
import Morphik from 'morphik';

const client = new Morphik({
  apiKey: process.env.MORPHIK_API_KEY!,
  baseURL: 'https://api.morphik.ai',
});

const filePath = 'path/to/document.pdf';
const QUESTION = 'What are the key takeaways from the uploaded document?';

function getDocumentId(document: any): string {
  if (document.external_id) return document.external_id;

  const systemMetadata = document.system_metadata as { document_id?: unknown } | undefined;
  if (systemMetadata?.document_id && typeof systemMetadata.document_id === 'string') {
    return systemMetadata.document_id;
  }

  throw new Error('Document response did not include an external_id or document_id.');
}

async function waitForProcessing(documentId: string) {
  const timeoutMs = 120_000;
  const intervalMs = 2_000;
  const started = Date.now();

  while (true) {
    const status = await client.documents.getStatus(documentId);
    const state = (status as any).status ?? (status as any).document_status;

    if (state === 'completed') return;
    if (state === 'failed') throw new Error(`Document ${documentId} failed to process.`);
    if (Date.now() - started > timeoutMs) throw new Error('Processing timed out.');

    await new Promise((resolve) => setTimeout(resolve, intervalMs));
  }
}

async function logSources(sources: any[] | undefined, label: string) {
  if (!sources?.length) {
    console.log(`${label}: no sources returned.`);
    return;
  }

  const chunkDetails = await client.batch.retrieveChunks({
    body: {
      sources: sources.map((source) => ({
        document_id: source.document_id,
        chunk_number: source.chunk_number,
      })),
    },
  });

  chunkDetails.forEach((chunk: any, index: number) => {
    const preview = chunk.content.slice(0, 120).replace(/\s+/g, ' ');
    console.log(`${label} #${index + 1} doc ${chunk.document_id} chunk ${chunk.chunk_number}: ${preview}`);
  });
}

const multimodalDocument = await client.ingest.ingestFile({
  file: fs.createReadStream(filePath),
  metadata: JSON.stringify({ demo_variant: 'multimodal' }),
  use_colpali: true,
});

await waitForProcessing(getDocumentId(multimodalDocument));

const multimodalChunks = await client.retrieve.chunks.create({
  query: QUESTION,
  use_colpali: true,
  k: 4,
  padding: 1,
  filters: { demo_variant: 'multimodal' },
});

const multimodalAnswer = await client.query.generateCompletion({
  query: QUESTION,
  use_colpali: true,
  k: 4,
  filters: { demo_variant: 'multimodal' },
});

console.log('Multimodal answer:', multimodalAnswer.completion);
await logSources(multimodalAnswer.sources, 'Multimodal source');

const standardDocument = await client.ingest.ingestFile({
  file: fs.createReadStream(filePath),
  metadata: JSON.stringify({ demo_variant: 'standard' }),
});

const textChunks = await client.retrieve.chunks.create({
  query: QUESTION,
  use_colpali: false,
  k: 4,
  padding: 1,
  filters: { demo_variant: 'standard' },
});

const textAnswer = await client.query.generateCompletion({
  query: QUESTION,
  use_colpali: false,
  k: 4,
  filters: { demo_variant: 'standard' },
});

console.log('Text answer:', textAnswer.completion);
await logSources(textAnswer.sources, 'Text source');

import OpenAI from 'openai';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Text-only prompt
const textContext = textChunks
  .map((chunk: any, idx: number) => `Source #${idx + 1}:\n${chunk.content}`)
  .join('\n\n');

const textResponse = await openai.responses.create({
  model: process.env.OPENAI_MODEL ?? 'gpt-4o-mini',
  input: [{
    role: 'user',
    content: [{ type: 'text', text: `Use the context below to answer.\n\n${textContext}\n\nQuestion: ${QUESTION}` }],
  }],
});

// Multimodal prompt (only includes chunks with image URLs)
const imageChunks = multimodalChunks.filter(
  (chunk: any) => chunk.download_url && chunk.content_type?.startsWith('image/'),
);

const multimodalResponse = await openai.responses.create({
  model: process.env.OPENAI_MODEL ?? 'gpt-4o-mini',
  input: [{
    role: 'user',
    content: [
      { type: 'text', text: `Answer using only these images.\nQuestion: ${QUESTION}` },
      ...imageChunks.map((chunk: any) => ({
        type: 'image_url',
        image_url: { url: chunk.download_url },
      })),
    ],
  }],
});