Bible Verse RAG · Hybrid Inference · Real-Time

Scripture content is embedded into Weaviate's vector database. At query time, semantically relevant passages are retrieved and injected into the prompt before inference — grounding AI responses in actual scripture text rather than relying on model memory.

Llama 3.2 8B handles primary inference for cost efficiency. A custom orchestration layer classifies query complexity and routes complex or low-confidence cases to the OpenAI API as a fallback — keeping routine queries cheap while preserving quality at the edge.

Three dedicated queues handle work outside the request path: audio transcoding, notification dispatch, and AI inference batching. No heavy operation blocks API response time — all long-running work is enqueued and processed by dedicated workers.

Community features use WebSockets for message sync and reaction broadcasting. Livestream sessions use WebRTC for peer-to-peer video. Redis pub/sub routes events across server instances so state stays consistent regardless of which node a client connects to.

Audio and video uploads are accepted immediately and enqueued as BullMQ jobs. A dedicated worker runs FFmpeg transformations, writes processed output to MinIO, and notifies the client via WebSocket on completion. Raw uploads never touch the public delivery path.

Bible and Quran content share a single Weaviate embedding collection. A vector similarity query with metadata filters can surface semantically related passages from either corpus in one call — no separate indices, no post-hoc merging.

Vue 3 Composition API throughout — no Options API. SSR on public scripture and devotional pages for SEO; SPA mode for authenticated dashboard routes. Pinia stores scoped per domain. Nuxt auto-imports remove component boilerplate. Strict TypeScript shared between client and server layer.

H3 event handlers with Zod schema validation at every public endpoint. Service layer pattern — controllers are thin, logic lives in typed service modules. Middleware chain: auth → rate limit → logging → handler. Async work dispatched to BullMQ queues rather than awaited in the response path.

Five bounded contexts: Scripture, AI Reasoning, Community, Media, and Infrastructure. Each owns its schema, service logic, and repository layer. Cross-domain calls go through typed service interfaces — no direct DB table access across boundaries. Enables future service extraction without a rewrite.

PostgreSQL + Prisma for relational content and user data with typed migrations. Weaviate vectors indexed by book, chapter, and verse with metadata filters for scoped retrieval. Redis for session store, rate-limit counters, and pub/sub. MinIO for S3-compatible object storage with signed URL delivery.

JWT-based auth with short-lived access tokens and Redis-backed refresh token rotation. Redis tracks active sessions enabling server-side revocation without waiting on token expiry. Rate limiting applied per-IP and per-user at the Nitro middleware layer before any handler executes. Role-based access enforced at the service layer, not just route guards.

Strict TypeScript across frontend, Nitro server, and shared utilities. Zod schemas at API boundaries generate both runtime validation and inferred TypeScript types — one source of truth. Prisma client types flow from the schema; no hand-written model interfaces. ESLint and Prettier enforced via pre-commit hooks.

Every request generates a structured log entry with a correlation ID threaded through all downstream calls — PostgreSQL queries, Weaviate retrievals, BullMQ dispatches, and AI inference. Errors include stack traces, request context, and the authenticated user ID. Log level controlled per environment via runtime config.

Each external dependency (PostgreSQL, Redis, Weaviate, MinIO) has a dedicated health check endpoint polled by the load balancer. The AI inference path wraps Llama and OpenAI calls in a circuit breaker — if error rate exceeds threshold, new requests route to the fallback immediately rather than queuing behind timeouts.

Prometheus metrics track request latency, BullMQ queue depth, worker throughput, and AI inference time per model. Grafana dashboards surface queue backlog and Redis memory pressure. Alertmanager notifies on sustained queue stalls, high error rates, and inference latency spikes.

Docker Compose for local development with full service parity — same PostgreSQL, Redis, Weaviate, and MinIO versions as production. Environment config managed via Nuxt runtime config. CI pipeline runs lint, type check, and integration tests before any deploy step executes.

Scripture modelled at verse granularity — Books → Chapters → Verses with translation variants in a separate table to support multi-translation queries without denormalization. B-tree indexes on verse reference columns; GIN indexes on full-text search fields. User data isolated in separate schemas with FK constraints enforced at the DB layer.

A single ScriptureVerse collection stores embeddings for both Bible and Quran. Properties include text, translation, corpus (bible|quran), book, chapter, and verse. The corpus and translation fields act as metadata filters, enabling single-query cross-corpus retrieval without managing separate collections. Vectorizer: text2vec-transformers with a multilingual model.

Four namespaces: session:{userId} for refresh tokens (7-day TTL), ratelimit:{ip}:{route} for sliding window counters, presence:{roomId} for WebSocket connection state (30s TTL with heartbeat renewal), and events:{instanceId} pub/sub channels for cross-instance broadcast. No business data lives in Redis.

All schema changes go through Prisma migrate — no hand-written SQL in production. Migrations run in CI before the deploy step; the pipeline blocks if pending migrations are detected. A shadow database catches destructive migration issues in development before they reach staging. Seeder scripts populate translations and scripture content for local dev.