# ACME Corp Q3 2025 Earnings Report
## Financial Performance
Revenue grew 32% year-over-year to $847M...
Operating margin expanded 4 percentage points to 24%...

Revenue grew 32% year-over-year to $847M.
Operating margin expanded 4 percentage points to 24%.
Net income increased 41% to $203M...

// ✅ Contextual Retrieval — generate per-chunk context with prefix caching
// file: packages/db/src/ingestion/ContextualRetrieval.ts

import Anthropic from '@anthropic-ai/sdk'

const anthropic = new Anthropic()

export async function contextualiseChunk(
  documentContent: string,  // Full document — cached as prefix
  chunk: string,
): Promise<string> {
  // Anthropic caches the large document prefix across all chunk calls
  // via prompt caching — dramatically reducing contextualisation cost
  const response = await anthropic.messages.create({
    model: 'claude-3-haiku-20240307',  // Haiku: fast + cheap for contextualisation
    max_tokens: 200,
    system: [
      {
        type: 'text',
        text: documentContent,
        cache_control: { type: 'ephemeral' },  // Cache the full document
      },
      {
        type: 'text',
        text: 'You are a document context generator. Given a document and a specific chunk from that document, generate a brief 1-2 sentence context that situates the chunk within the document. Focus on what document this is from, what section it belongs to, and what its role is within the broader document structure.',
      },
    ],
    messages: [{
      role: 'user',
      content: `<chunk>\n${chunk}\n</chunk>\n\nProvide context for this chunk in 1-2 sentences.`,
    }],
  })

  return response.content[0].type === 'text' ? response.content[0].text : ''
}

export async function buildContextualisedChunk(
  context: string,
  originalContent: string,
): Promise<string> {
  return `${context}\n\n${originalContent}`
}

// ✅ Rate-limited batch contextualisation pipeline
// file: packages/db/src/ingestion/ContextualisationPipeline.ts

import pLimit from 'p-limit'
import { contextualiseChunk, buildContextualisedChunk } from './ContextualRetrieval'
import { embedAndNormalise } from '../embeddings'

const CONTEXTUALISATION_CONCURRENCY = 5  // Haiku API: 5 concurrent calls

export async function contextualiseAndEmbed(
  documentContent: string,
  chunks: DocumentChunk[],
): Promise<ContextualisedChunk[]> {
  const limit = pLimit(CONTEXTUALISATION_CONCURRENCY)

  const results = await Promise.all(
    chunks.map(chunk =>
      limit(async () => {
        // Generate context — document content is prompt-cached by Anthropic
        const context = await contextualiseChunk(documentContent, chunk.content)
        const contextualisedContent = await buildContextualisedChunk(context, chunk.content)

        // Embed the contextualised version (not the raw chunk)
        const embedding = await embedAndNormalise(contextualisedContent)

        return {
          ...chunk,
          contextualisedContent,
          embedding,
          // Store original content for display — context is for retrieval only
          displayContent: chunk.content,
        }
      })
    )
  )

  return results
}

// ✅ Parent-Document schema — two chunk granularities
// file: packages/db/src/schema/parentChunks.ts

import { pgTable, uuid, text, integer, vector, index } from 'drizzle-orm/pg-core'

// Parent chunks — larger, for LLM synthesis context
export const parentChunks = pgTable('parent_chunks', {
  id:         uuid('id').primaryKey().defaultRandom(),
  documentId: uuid('document_id').notNull(),
  orgId:      uuid('org_id').notNull(),
  content:    text('content').notNull(),  // 500–1000 tokens
  chunkIndex: integer('chunk_index').notNull(),
})

// Child chunks — smaller, for precision search
export const childChunks = pgTable('child_chunks', {
  id:            uuid('id').primaryKey().defaultRandom(),
  parentChunkId: uuid('parent_chunk_id').notNull()
    .references(() => parentChunks.id, { onDelete: 'cascade' }),
  documentId:    uuid('document_id').notNull(),
  orgId:         uuid('org_id').notNull(),
  content:       text('content').notNull(),    // 100–200 tokens (for embedding)
  contextualisedContent: text('contextualised_content').notNull(),  // For embedding
  embedding:     vector('embedding', { dimensions: 1536 }).notNull(),
  sha256:        text('sha256').notNull(),
  tokenCount:    integer('token_count').notNull(),
}, (table) => ({
  embeddingIdx: index('child_chunks_hnsw_idx')
    .using('hnsw', table.embedding.op('vector_ip_ops')),
}))

// ✅ Parent-Document retrieval — search small, synthesise large
// file: packages/db/src/retrieval/ParentDocumentRetriever.ts

import { db } from '../drizzle'
import { sql } from 'drizzle-orm'
import { embedAndNormalise } from '../embeddings'

export interface ParentDocumentResult {
  parentChunkId: string
  parentContent: string   // Full section for LLM synthesis
  childContent: string    // Matched sub-section for reference
  similarity: number
  tokenCount: number
}

export async function parentDocumentSearch(
  orgId: string,
  query: string,
  limit = 5,
): Promise<ParentDocumentResult[]> {
  const queryEmbedding = await embedAndNormalise(query)
  const vectorLiteral = `[${queryEmbedding.join(',')}]`

  // Search child chunks for precision, then JOIN to parent for context
  const results = await db.execute(sql`
    SELECT
      p.id          AS parent_chunk_id,
      p.content     AS parent_content,
      c.content     AS child_content,
      c.token_count,
      1 - (c.embedding <#> ${vectorLiteral}::vector) AS similarity
    FROM child_chunks c
    JOIN parent_chunks p ON c.parent_chunk_id = p.id
    WHERE c.org_id = ${orgId}::uuid
    ORDER BY c.embedding <#> ${vectorLiteral}::vector
    LIMIT ${limit}
  `)

  return results.rows as ParentDocumentResult[]
}