Push submodules dir

ingestion_js/app/api/health/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from 'next/server'
+import { getMongo } from '@/lib/mongo'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const mongo = await getMongo()
+  let mongodb_connected = false
+  try {
+    await mongo.db.command({ ping: 1 })
+    mongodb_connected = true
+  } catch {
+    mongodb_connected = false
+  }
+  return NextResponse.json({ ok: true, mongodb_connected, service: 'ingestion_pipeline' })
+}

ingestion_js/lib/captioner.ts

@@ -0,0 +1,73 @@
+type ImageLike = { data: Buffer } | Blob | ArrayBuffer | string
+
+async function imageToJpegBase64(input: any): Promise<string> {
+  // input will be a Buffer or ArrayBuffer from parser; expect Buffer for server-side
+  if (typeof input === 'string') return input
+  const b64 = Buffer.isBuffer(input) ? input.toString('base64') : Buffer.from(input).toString('base64')
+  return b64
+}
+
+function getNvidiaKey(): string | null {
+  const direct = process.env.NVIDIA_API || null
+  if (direct) return direct
+  for (let i = 1; i <= 5; i++) {
+    const k = process.env[`NVIDIA_API_${i}`]
+    if (k) return k
+  }
+  return null
+}
+
+export async function captionImage(imageBuffer: Buffer): Promise<string> {
+  const key = getNvidiaKey()
+  if (!key) return ''
+  const imgB64 = await imageToJpegBase64(imageBuffer)
+  const system_prompt =
+    'You are an expert vision captioner. Produce a precise, information-dense caption of the image. Do not include conversational phrases or meta commentary.'
+  const user_prompt = 'Caption this image at the finest level of detail. Return only the caption text.'
+  const payload = {
+    model: process.env.NVIDIA_MAVERICK_MODEL || 'meta/llama-4-maverick-17b-128e-instruct',
+    messages: [
+      { role: 'system', content: system_prompt },
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: user_prompt },
+          { type: 'image_url', image_url: { url: `data:image/jpeg;base64,${imgB64}` } }
+        ]
+      }
+    ],
+    max_tokens: 512,
+    temperature: 0.2,
+    stream: false
+  }
+  const res = await fetch('https://integrate.api.nvidia.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${key}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(payload)
+  })
+  if (!res.ok) return ''
+  const data = await res.json() as any
+  const text = data?.choices?.[0]?.message?.content || ''
+  return normalizeCaption(text)
+}
+
+export function normalizeCaption(text: string): string {
+  if (!text) return ''
+  let t = text.trim()
+  const banned = [
+    'sure,', 'sure.', 'sure', 'here is', 'here are', 'this image', 'the image', 'image shows',
+    'the picture', 'the photo', 'the text describes', 'the text describe', 'it shows', 'it depicts',
+    'caption:', 'description:', 'output:', 'result:', 'answer:', 'analysis:', 'observation:'
+  ]
+  const lower = t.toLowerCase()
+  for (const p of banned) {
+    if (lower.startsWith(p)) {
+      t = t.slice(p.length).trimStart()
+      break
+    }
+  }
+  return t.replace(/^['\"]|['\"]$/g, '').trim()
+}

ingestion_js/lib/embedder.ts

@@ -0,0 +1,22 @@
+export async function embedRemote(texts: string[]): Promise<number[][]> {
+  if (!texts || texts.length === 0) return []
+  const base = (process.env.EMBED_BASE_URL || '').replace(/\/$/, '')
+  if (!base) throw new Error('EMBED_BASE_URL is required')
+  const res = await fetch(`${base}/embed`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ texts }),
+    // 60s like Python client
+    next: { revalidate: 0 }
+  })
+  if (!res.ok) {
+    // Fail closed with zeros to avoid crashes (parity with Python fallback)
+    return Array.from({ length: texts.length }, () => Array(384).fill(0))
+  }
+  const data = await res.json() as any
+  const vectors = Array.isArray(data?.vectors) ? data.vectors : []
+  if (!Array.isArray(vectors)) {
+    return Array.from({ length: texts.length }, () => Array(384).fill(0))
+  }
+  return vectors
+}

ingestion_js/lib/mongo.ts

@@ -0,0 +1,72 @@
+import { MongoClient, Db } from 'mongodb'
+
+let client: MongoClient | null = null
+let db: Db | null = null
+
+export async function getMongo() {
+  if (client && db) return { client, db }
+  const uri = process.env.MONGO_URI
+  const dbName = process.env.MONGO_DB || 'studybuddy'
+  if (!uri) throw new Error('MONGO_URI is required')
+  client = new MongoClient(uri)
+  await client.connect()
+  db = client.db(dbName)
+  return { client, db }
+}
+
+export const VECTOR_DIM = 384
+
+export async function storeCards(cards: any[]) {
+  const { db } = await getMongo()
+  if (!cards || !cards.length) return
+  for (const c of cards) {
+    if (!c.embedding || c.embedding.length !== VECTOR_DIM) {
+      throw new Error(`Invalid embedding length; expected ${VECTOR_DIM}`)
+    }
+  }
+  await db.collection('chunks').insertMany(cards, { ordered: false })
+}
+
+export async function upsertFileSummary(user_id: string, project_id: string, filename: string, summary: string) {
+  const { db } = await getMongo()
+  await db.collection('files').updateOne(
+    { user_id, project_id, filename },
+    { $set: { summary } },
+    { upsert: true }
+  )
+}
+
+export async function listFiles(user_id: string, project_id: string) {
+  const { db } = await getMongo()
+  const cursor = db.collection('files').find({ user_id, project_id }, { projection: { _id: 0, filename: 1, summary: 1 } }).sort({ filename: 1 })
+  return cursor.toArray()
+}
+
+export async function getFileChunks(user_id: string, project_id: string, filename: string, limit = 20) {
+  const { db } = await getMongo()
+  const cursor = db.collection('chunks').find({ user_id, project_id, filename }).limit(limit)
+  const out: any[] = []
+  for await (const doc of cursor) {
+    const d: any = {}
+    for (const [k, v] of Object.entries(doc as any)) {
+      if (k === '_id') d[k] = String(v)
+      // @ts-ignore
+      else if (v && typeof v === 'object' && typeof (v as any).toISOString === 'function') d[k] = (v as any).toISOString()
+      else d[k] = v as any
+    }
+    out.push(d)
+  }
+  return out
+}
+
+export async function deleteFileData(user_id: string, project_id: string, filename: string) {
+  const { db } = await getMongo()
+  await db.collection('chunks').deleteMany({ user_id, project_id, filename })
+  await db.collection('files').deleteMany({ user_id, project_id, filename })
+}
+
+export async function ensureIndexes() {
+  const { db } = await getMongo()
+  await db.collection('chunks').createIndex({ user_id: 1, project_id: 1, filename: 1 })
+  await db.collection('files').createIndex({ user_id: 1, project_id: 1, filename: 1 })
+}

ingestion_js/lib/parser.ts

@@ -0,0 +1,38 @@
+import pdfParse from 'pdf-parse'
+import mammoth from 'mammoth'
+
+export type Page = { page_num: number; text: string; images: Buffer[] }
+
+export async function parsePdfBytes(buf: Buffer): Promise<Page[]> {
+  // pdf-parse: text only; image extraction is non-trivial in Node serverless
+  const data = await pdfParse(buf)
+  const text = data.text || ''
+  const pages = text.split('\f') // pdf-parse uses form-feed between pages when available
+  const out: Page[] = []
+  for (let i = 0; i < pages.length; i++) {
+    out.push({ page_num: i + 1, text: pages[i] || '', images: [] })
+  }
+  if (out.length === 0) out.push({ page_num: 1, text, images: [] })
+  return out
+}
+
+export async function parseDocxBytes(buf: Buffer): Promise<Page[]> {
+  const { value } = await mammoth.extractRawText({ buffer: buf })
+  const text = value || ''
+  return [{ page_num: 1, text, images: [] }]
+}
+
+export function inferMime(filename: string): string {
+  const lower = filename.toLowerCase()
+  if (lower.endsWith('.pdf')) return 'application/pdf'
+  if (lower.endsWith('.docx'))
+    return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+  return 'application/octet-stream'
+}
+
+export async function extractPages(filename: string, file: Buffer): Promise<Page[]> {
+  const mime = inferMime(filename)
+  if (mime === 'application/pdf') return parsePdfBytes(file)
+  if (mime === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document') return parseDocxBytes(file)
+  throw new Error(`Unsupported file type: ${filename}`)
+}

ingestion_js/next.config.js

@@ -0,0 +1,10 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    serverActions: {
+      bodySizeLimit: '50mb'
+    }
+  }
+};
+
+module.exports = nextConfig;

ingestion_js/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "ingestion-js",
+  "private": true,
+  "version": "0.1.0",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start"
+  },
+  "dependencies": {
+    "mongodb": "^6.8.0",
+    "next": "^14.2.5",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "pdf-parse": "^1.1.1",
+    "mammoth": "^1.6.0",
+    "slugify": "^1.6.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "@types/react": "^18.2.66",
+    "typescript": "^5.4.5"
+  }
+}

ingestion_js/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "es2022"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "types": ["node"]
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules"]
+}