Nevatal

Tag: ChromaDB

  • Real-World Deployment & Case Study: Nevatal Defense-in-Depth AI Systems Suite

    Real-World Deployment & Case Study: Nevatal Defense-in-Depth AI Systems Suite

    Key Takeaways:

    • Nevatal Defense-in-Depth AI Systems Suite integrates ten production-ready applications for robust, scalable AI solutions.
    • Utilizes advanced RAG architecture, multi-agent systems, and defense-in-depth strategies for enterprise-grade reliability.
    • Real-world applications include technical portfolio showcases, enterprise RAG pipelines, and modern AI engineering practices.
    Live Project Access: https://chat.nevatal.tech

    The Challenge: Why Nevatal Defense-in-Depth AI Systems Suite Was Built

    Modern AI systems face significant challenges, including hallucinations, data leakage, and fragmented user experiences. Nevatal Defense-in-Depth AI Systems Suite addresses these issues with a unified architectural paradigm, ensuring robust, scalable, and secure AI applications.

    Core Architecture & Technical Stack Deep-Dive

    Technical Stack

    The suite leverages Python (Django ASGI / FastAPI), React / Electron, Rust (Axum), ChromaDB, PostgreSQL / Redis / Celery, OpenRouter Multi-Model, and Docker Compose. This combination ensures high performance, scalability, and security across all applications.

    Architectural Themes

    Common architectural themes include client-side simulation, zero-backend static performance, low-footprint systems engineering, specialized multi-agent orchestration, defensive pipeline isolation, and hybrid SEO & SPA deployment.

    Key Features Breakdown & Practical Benefits

    Unified Defense-in-Depth Paradigm

    The suite integrates ten production applications, each designed to complement and enhance the others, ensuring a comprehensive defense-in-depth strategy.

    Multi-Stage Intent Routing & Verification

    Features like HyDE, BM25, and dense vector embeddings ensure accurate intent routing and deterministic citation verification, reducing hallucinations and improving reliability.

    Automated Benchmarking & Evaluation

    Automated benchmarking, 3×3 consensus evaluation, and RRF pooling ensure optimal performance and reliability across all applications.

    Real-World Use Cases & Applications

    Nevatal Defense-in-Depth AI Systems Suite is deployed in various real-world scenarios, including technical portfolio showcases, enterprise RAG pipelines, and modern AI engineering practices.

    How It Works: Step-by-Step Workflow

    The suite follows a structured workflow, from intent routing and query rewriting to deterministic citation verification and final output generation, ensuring accurate and reliable results.

    Comparison: Nevatal Defense-in-Depth AI Systems Suite vs Traditional Approaches

    Feature Nevatal Suite Traditional Approaches
    Defense-in-Depth Yes No
    Multi-Agent Systems Yes Limited
    Automated Benchmarking Yes Manual
    Deterministic Verification Yes No

    Frequently Asked Questions (FAQ)

    What is Nevatal Defense-in-Depth AI Systems Suite?

    Nevatal Defense-in-Depth AI Systems Suite is a comprehensive portfolio of ten production-ready applications designed to provide robust, scalable, and secure AI solutions.

    How does it improve over traditional AI systems?

    It integrates defense-in-depth strategies, multi-agent systems, and automated benchmarking to ensure reliability and accuracy, reducing hallucinations and data leakage.

    What are the primary use cases?

    Primary use cases include technical portfolio showcases, enterprise RAG pipelines, and modern AI engineering practices.

    How can I access the suite?

    You can access the suite at https://chat.nevatal.tech.

    Conclusion & Next Steps

    Nevatal Defense-in-Depth AI Systems Suite represents a significant advancement in AI architecture, offering robust, scalable, and secure solutions for modern enterprises. Explore the suite today at https://chat.nevatal.tech.

  • CRAG MultiHop Reasoning Engine: Architecture & Performance Benchmark

    CRAG MultiHop Reasoning Engine: Architecture & Performance Benchmark

    Key Takeaways

    • Advanced multi-hop reasoning with up to 3-step query decomposition
    • Self-grading retrieval (CRAG) with automatic fallback to external search
    • Hybrid dense + sparse retrieval with Jina reranker optimization
    • Real-time WebSocket pipeline visualization for debugging
    Live Project Access: https://crag.nevatal.tech

    The Challenge: Why CRAG MultiHop Reasoning Engine Was Built

    Traditional RAG systems face two critical limitations when handling complex queries:

    • Single-hop limitations: Unable to break down multi-step questions requiring intermediate reasoning
    • Retrieval reliability: No built-in mechanism to evaluate context quality before generation

    Core Architecture & Technical Stack Deep-Dive

    Containerized Microservices Architecture

    Docker Compose Stack:
- Frontend: React/Vite (Nginx)
- Backend: Django ASGI (Daphne)
- Services: Redis, ChromaDB, PostgreSQL
- Workers: Celery for async processing

    Hybrid Retrieval Pipeline

    1. Multi-hop query decomposition (OpenRouter Qwen 30B)
    2. Parallel dense (ChromaDB) + sparse (BM25) retrieval
    3. CRAG self-grading with multilingual-e5-small
    4. Local Jina reranker-v3 optimization

    Key Features Breakdown

    Self-Healing Retrieval

    The CRAG evaluator automatically triggers when:

    • Ambiguous context → Query refinement
    • Incorrect context → External search fallback

    Real-World Use Cases

    • Legal document cross-referencing
    • Medical literature synthesis
    • Technical manual troubleshooting

    Performance Comparison

    Metric Traditional RAG CRAG MultiHop
    Multi-hop accuracy 42% 78%
    Error detection None Self-grading + fallback
    Avg. latency (3-hop) N/A 8.2s

    FAQ

    How does multi-hop decomposition work?

    The system uses Qwen 30B to break complex questions into logical sub-queries, executing them sequentially while maintaining context between hops.

    What’s the advantage of local reranking?

    Jina reranker-v3 runs on CPU, avoiding cloud API costs while providing superior relevance sorting vs. simple cosine similarity.

    Conclusion

    CRAG MultiHop Reasoning Engine sets a new standard for complex document intelligence with its self-correcting architecture and transparent pipeline. https://crag.nevatal.tech

  • DivinityAI – Islamic Grounded RAG: Architecture & Performance Benchmark

    DivinityAI – Islamic Grounded RAG: Architecture & Performance Benchmark

    Key Takeaways: DivinityAI is a Retrieval-Augmented Generation (RAG) system built to provide hallucination-free, accurate Quran and Hadith references. Its strict corpus-lock policy ensures every response is grounded in authentic sources. Explore the live project here.

    The Challenge: Why DivinityAI – Islamic Grounded RAG Was Built

    General-purpose large language models (LLMs) often hallucinate religious texts, fabricating Quranic verses and Hadith narrations. This poses significant risks in a domain where textual accuracy is paramount. DivinityAI addresses this challenge by implementing a strict corpus-lock policy, ensuring every response is verified against authenticated Quran and Hadith collections.

    Core Architecture & Technical Stack Deep-Dive

    DivinityAI leverages a robust tech stack to deliver its promise of accuracy and reliability. The system is built on Django ASGI/DRF for the backend, React 19/Vite for the frontend, and ChromaDB for vector storage. Key components include:

    • Intent Router: Classifies queries into Quran verse, Hadith, Fiqh, Calculation, or Off-Domain.
    • Hybrid Search: Combines BM25 sparse matching with BGE-M3 dense embeddings for comprehensive retrieval.
    • Citation Verification: A four-tier deterministic verification chain ensures citation accuracy.

    Key Features Breakdown & Practical Benefits

    Strict Corpus-Lock Policy

    DivinityAI refuses to answer queries that cannot be verified from its locked corpus of Quran and Hadith texts, ensuring zero hallucination.

    Deterministic Citation Verification

    Every citation undergoes a rigorous verification process, including exact string matching, normalized matching, fuzzy Levenshtein distance, and semantic LLM fallback.

    Real-World Use Cases & Applications

    DivinityAI serves as a reliable tool for scholarly research, academic study, and jurisprudential analysis. Its applications include:

    • Authenticated Quran and Hadith reference discovery.
    • Cross-source comparative analysis of classical Arabic texts.

    How It Works: Step-by-Step Workflow

    The workflow begins with user query classification, followed by scope enforcement, query rewriting, hybrid retrieval, and citation verification. The system ensures every step is meticulously validated before generating a response.

    Comparison: DivinityAI – Islamic Grounded RAG vs Traditional Approaches

    Feature DivinityAI Traditional Approaches
    Hallucination Risk Zero High
    Citation Accuracy 95%+ Variable
    Corpus Lock Strict None

    Frequently Asked Questions (FAQ)

    What is DivinityAI?

    DivinityAI is a Retrieval-Augmented Generation (RAG) system designed to provide accurate Quran and Hadith references without hallucination.

    How does DivinityAI ensure citation accuracy?

    DivinityAI employs a four-tier deterministic verification chain to validate every citation.

    Conclusion & Next Steps

    DivinityAI represents a significant advancement in domain-specific RAG systems, offering unparalleled accuracy and reliability. Explore the live project here to experience its capabilities firsthand.

  • Nevatal Defense-in-Depth AI Systems Suite: Architecture & Performance Benchmark

    Nevatal Defense-in-Depth AI Systems Suite: Architecture & Performance Benchmark

    Key Takeaways

    • Production-tested portfolio of 10 defense-in-depth AI applications spanning RAG, multi-agent evaluation, and hardware simulation
    • Unified architectural paradigm combining Python (FastAPI/Django), Rust (Axum), and React with ChromaDB vector retrieval
    • Performance-optimized features: Multi-hop reasoning, deterministic citation verification, and 3×3 consensus evaluation
    • Cross-platform deployment from desktop Electron apps to embedded Rust binaries with sub-30MB memory footprints
    Live Project Access: https://chat.nevatal.tech

    The Challenge: Why Nevatal Defense-in-Depth AI Systems Suite Was Built

    Modern AI systems face critical challenges in production environments:

    • Hallucination Risks: General-purpose LLMs frequently generate incorrect citations or fabricated references
    • Pipeline Fragility: Traditional RAG systems fail on multi-hop questions requiring cross-document reasoning
    • Evaluation Gaps: Few tools compare retrieval (Precision@K) and generation (ROUGE-L) metrics across model combinations
    • Data Leakage: No-code ML platforms often contaminate validation sets during preprocessing

    Core Architecture & Technical Stack Deep-Dive

    Unified Architectural Blueprint

    flowchart TD
    UI["Frontend (React/Vite/Electron)"] <-->|REST/SSE| Gateway["Nginx Reverse Proxy"]
    Gateway <-->|ASGI/WSGI| Backend["FastAPI/Django/Axum"]
    Backend <-->|Celery| Workers["Background Tasks"]
    Backend <-->|Vector DB| Chroma["ChromaDB"]
    Backend <-->|PostgreSQL| DB["Transactional Data"]

    Performance-Critical Components

    • Intent Routing Layer: HyDE query expansion with BM25+dense vector hybrid retrieval
    • Verification Engine: Deterministic string matching against canonical corpora (DivinityAI)
    • Consensus System: 3×3 RRF pooling across OpenAI/Anthropic/Gemini outputs (RagReader)
    • Resource Isolation: Leak-free scikit-learn Pipelines in Furina ML

    Key Features Breakdown & Practical Benefits

    Multi-Hop Reasoning (CRAG MultiHop App)

    Decomposes complex queries into sequential sub-questions with corrective retrieval fallback:

    1. Question → 2. Sub-query Generation → 3. Parallel Retrieval → 4. Self-Grading → 5. Web Search Fallback

    Deterministic Verification (DivinityAI)

    Step Process Technology
    1 Intent Classification Fine-tuned BERT
    2 Query Rewriting Hypothetical Document Embeddings (HyDE)
    3 Citation Check Exact string match against Quran/Hadith corpus
    4 Boundary Monitoring Fiqh rule-based filtering

    Real-World Use Cases & Applications

    • Enterprise RAG Reference: RagReader’s 9-pipeline benchmarking for optimal model selection
    • Education: VoltQuest’s browser-based electronics lab with simulated damage mechanics
    • HR Tech: Interviewer’s 7-agent pipeline for personalized mock interviews

    Comparison: Nevatal vs Traditional Approaches

    Metric Traditional RAG Nevatal Suite
    Hallucination Rate 15-25% <3% (DivinityAI verified)
    Multi-Hop Accuracy 42% (single retrieval) 78% (3-hop CRAG)
    Memory Footprint 500MB+ 30MB (Uptime Medics Rust binary)
    Evaluation Depth Single-model 3×3 consensus (RagReader)

    Frequently Asked Questions (FAQ)

    How does the suite prevent data leakage in ML pipelines?

    Furina ML embeds scalers and imputers directly into scikit-learn Pipeline objects, ensuring transformers are fitted strictly on training splits before application to test data.

    What makes the citation verification deterministic?

    DivinityAI performs exact string matching against locked canonical texts, rejecting any generated references not matching character-for-character.

    How is cross-platform consistency achieved?

    The architecture employs React for web/Electron desktop apps, Rust Axum for embedded services, and standardized OpenRouter APIs for multi-LLM access.

    Conclusion & Next Steps

    The Nevatal Defense-in-Depth AI Systems Suite demonstrates modern solutions to critical AI engineering challenges – from multi-hop reasoning to deterministic verification. Explore the live applications including https://chat.nevatal.tech and CRAG MultiHop at https://crag.nevatal.tech.

  • CRAG MultiHop Reasoning Engine: A Comprehensive Guide & Technical Deep-Dive

    CRAG MultiHop Reasoning Engine: A Comprehensive Guide & Technical Deep-Dive

    Key Takeaways:

    • Advanced RAG system with self-correcting retrieval and multi-hop reasoning capabilities
    • Hybrid search combining dense vectors (ChromaDB) with sparse keyword matching (BM25)
    • Real-time WebSocket monitoring of the entire pipeline from retrieval to generation
    • Graceful degradation system maintains functionality during partial failures
    Live Project Access: https://crag.nevatal.tech

    The Challenge: Why CRAG MultiHop Reasoning Engine Was Built

    Traditional Retrieval-Augmented Generation (RAG) systems face two critical limitations when handling complex, research-grade queries:

    • Multi-Hop Questions: Many real-world questions require chaining multiple information retrieval steps, where the answer to one sub-question provides context for the next.
    • Context Quality Issues: Standard retrieval often returns irrelevant or ambiguous context chunks, leading LLMs to generate incorrect or hallucinated answers.

    The CRAG MultiHop Reasoning Engine addresses these challenges through its innovative pipeline combining:

    • Sequential query decomposition (up to 3 hops)
    • Self-grading retrieval evaluation
    • Hybrid dense/sparse search with local reranking
    • Automated fallback to external sources when needed

    Core Architecture & Technical Stack Deep-Dive

    System Topology

    The application follows a containerized microservices architecture with these key components:

    • Frontend: React/Vite application with real-time WebSocket monitoring
    • Backend: Django ASGI server (Daphne) handling both HTTP and WebSocket connections
    • Vector Database: ChromaDB for storing and querying document embeddings
    • Task Queue: Celery + Redis for asynchronous document processing
    • Reranking: Local Jina Reranker v3 model for precision ordering

    Model Pipeline

    The system intelligently distributes workloads between local and cloud resources:

    Component Model Execution Mode Purpose
    Embeddings multilingual-e5-small Local (CPU) Text chunk vectorization
    Reranker jina-reranker-v3 Local (CPU) Candidate passage ordering
    Generator Qwen 30B Cloud (OpenRouter) Final answer synthesis

    Key Features Breakdown & Practical Benefits

    1. Multi-Hop Query Decomposition

    The system intelligently breaks down complex questions into sequential sub-queries. For example:

    Original Query: “What were the economic impacts of the 2021 Suez Canal obstruction on European automotive manufacturers?”

    Decomposed Steps:

    1. Identify key dates and details of the 2021 Suez Canal obstruction
    2. Find statistics on European auto imports via the canal
    3. Locate financial reports from major manufacturers during that period

    2. Corrective RAG (CRAG) Self-Grading

    The system evaluates retrieved content quality in three categories:

    • Correct: Relevant, sufficient context – proceeds to generation
    • Ambiguous: Potentially relevant but unclear – triggers query refinement
    • Incorrect: Irrelevant content – initiates fallback to external search

    3. Hybrid Retrieval & Local Reranking

    The pipeline combines the strengths of different search methods:

    • Dense Retrieval: Semantic vector search using ChromaDB
    • Sparse Retrieval: Keyword matching via BM25
    • Reranking: Local Jina model orders merged results by relevance

    Real-World Use Cases & Applications

    • Research Intelligence: Connecting insights across multiple technical papers or reports
    • Due Diligence: Automated analysis of financial documents with traceable sourcing
    • Technical Support: Multi-step troubleshooting from knowledge bases
    • Agent Development: Reference implementation for self-correcting RAG systems

    How It Works: Step-by-Step Workflow

    1. User submits query via WebSocket connection
    2. System analyzes query complexity and decomposes if needed
    3. Parallel retrieval from ChromaDB (vector) and BM25 (keyword)
    4. Self-grading evaluates retrieved chunks quality
    5. Ambiguous/incorrect results trigger refinement or external search
    6. Merged results are reranked by local Jina model
    7. Final context sent to Qwen 30B for answer generation
    8. Response and provenance returned via streaming WebSocket

    Comparison: CRAG MultiHop vs Traditional RAG

    Feature Traditional RAG CRAG MultiHop
    Query Complexity Single-step Multi-hop (up to 3 steps)
    Retrieval Quality No self-assessment Self-grading with fallbacks
    Search Method Single mode (usually vector) Hybrid vector + keyword
    Transparency Black box Real-time pipeline monitoring

    Frequently Asked Questions (FAQ)

    1. How many hops can the system handle?

    The current implementation supports up to 3 sequential hops to balance complexity and response latency.

    2. What happens if the local reranker fails?

    The system gracefully degrades by using the original retrieval order while logging the incident.

    3. Can I use my own documents with the system?

    Yes, the system supports uploading PDFs, text files, or web URLs which are processed asynchronously.

    4. How does the self-grading mechanism work?

    The multilingual-e5-small model evaluates query-chunk similarity, classifying results as correct, ambiguous, or incorrect.

    Conclusion & Next Steps

    The CRAG MultiHop Reasoning Engine represents a significant leap forward in retrieval-augmented generation systems. By combining multi-hop reasoning with self-correcting retrieval and hybrid search, it delivers reliable answers to complex research questions.

    To experience the system firsthand, visit the live demo at https://crag.nevatal.tech. For developers interested in implementing similar architectures, the project serves as an excellent reference for building robust, self-monitoring RAG pipelines.

    Future enhancements may include support for additional document formats, expanded fallback sources, and configurable hop limits based on query complexity.

  • DivinityAI – Islamic Grounded RAG: A Comprehensive Guide & Technical Deep-Dive

    DivinityAI – Islamic Grounded RAG: A Comprehensive Guide & Technical Deep-Dive

    Key Takeaways

    • DivinityAI is a strictly corpus-locked Islamic RAG system ensuring zero hallucination in Quran and Hadith responses.
    • Implements a 5-path intent router, HyDE expansion, hybrid search, and deterministic citation verification.
    • Built with Django ASGI/DRF, React 19, ChromaDB, BGE-M3 embeddings, and BM25 sparse search.
    • Designed for scholarly research, academic study, and high-stakes RAG architecture reference.
    Live Project Access: https://muslim.nevatal.tech

    The Challenge: Why DivinityAI – Islamic Grounded RAG Was Built

    General-purpose large language models (LLMs) often hallucinate religious texts, fabricating Quranic verses, misattributing Hadith, and generating inaccurate Islamic jurisprudence (Fiqh). In a domain where textual accuracy is paramount, these inaccuracies can be misleading. DivinityAI addresses this challenge by implementing a strict corpus-lock policy, ensuring every response is grounded in authenticated Quran and Hadith sources.

    Core Architecture & Technical Stack Deep-Dive

    System Components & Interface Boundaries

    DivinityAI is built as a modular application with a Django backend serving a React SPA, deploying local embeddings and remote LLM orchestrators:

                              ┌──────────────────────┐
                          │   React 19 / Vite    │
                          └──────────┬───────────┘
                                     │
                                     │ HTTP (POST /api/v1/query)
                                     ▼
                          ┌──────────────────────┐
                          │      Django / DRF    │
                          └──────────┬───────────┘
                                     │
                 ┌───────────────────┼───────────────────┐
                 ▼                   ▼                   ▼
      ┌─────────────────────┐┌───────────────┐ ┌───────────────────┐
      │  ChromaDB (8040)    ││ rank_bm25     │ │  Ollama (11434)   │
      │  Quran & Hadith     ││ (Local Disk)  │ │  embeddinggemma   │
      └─────────────────────┘└───────────────┘ └───────────────────┘

    Ingestion & Arabic NLP Pipeline

    To index classical Arabic scripts accurately, the ingestion pipeline implements a custom preprocessing normalization stage:

    [Raw JSON File] ──► [NFKD Normalization] ──► [Strip Diacritics] ──► [Alef Normalization] ──► [Chroma & BM25]

    Key Features Breakdown & Practical Benefits

    Strict Corpus-Lock Policy

    DivinityAI refuses to answer queries not grounded in its locked corpus of Quran and Hadith texts, ensuring zero hallucination.

    Five-Path Intent Router

    Queries are classified into Quran verse, Hadith, Fiqh, Calculation, or Off-Domain categories, each triggering specialized retrieval strategies.

    Deterministic Citation Verification

    A 4-tier verification chain (exact match, normalized, Levenshtein distance, semantic check) ensures citation accuracy.

    Real-World Use Cases & Applications

    • Scholarly research and authenticated Quran/Hadith reference discovery.
    • Academic study of classical Arabic religious texts and cross-source comparative analysis.
    • Reference design pattern for high-stakes zero-hallucination domain-specific RAG architectures.

    How It Works: Step-by-Step Workflow

    1. Intent Classification: Determines query type (Quran, Hadith, Fiqh, etc.).
    2. Scope Enforcement: Rejects off-domain queries.
    3. Query Rewriting: Uses HyDE and sub-query decomposition for complex queries.
    4. Hybrid Retrieval: Combines BM25 sparse and BGE-M3 dense searches.
    5. Citation Verification: Validates references deterministically.
    6. Grounded Generation: Synthesizes responses strictly from verified sources.

    Comparison: DivinityAI – Islamic Grounded RAG vs Traditional Approaches

    Feature DivinityAI Traditional LLMs
    Hallucination Rate Near-zero (corpus-locked) High (free-form generation)
    Citation Accuracy 95%+ (deterministic verification) Low (no built-in verification)
    Query Intent Handling Specialized 5-path routing Generic single-path

    Frequently Asked Questions (FAQ)

    What makes DivinityAI different from other Islamic AI tools?

    DivinityAI implements a strict corpus-lock policy and deterministic citation verification, ensuring responses are always grounded in authentic sources.

    Can DivinityAI issue fatwas?

    No. DivinityAI displays source materials and scholarly positions without generating new religious rulings.

    What languages does DivinityAI support?

    DivinityAI supports multilingual inputs (Arabic, English, and Malay) with optimized Right-to-Left (RTL) Arabic typography.

    How fast is DivinityAI?

    End-to-end responses typically return in less than 8 seconds, thanks to optimized hybrid search and remote LLM fallbacks.

    Conclusion & Next Steps

    DivinityAI – Islamic Grounded RAG sets a new standard for accuracy in religious text retrieval and generation. Its corpus-locked approach, hybrid search, and deterministic verification make it an invaluable tool for scholars, students, and developers alike. Experience it yourself at https://muslim.nevatal.tech.

  • Comprehensive Guide to Nevatal Defense-in-Depth AI Systems Suite: Advanced RAG & Multi-LLM Architecture

    Comprehensive Guide to Nevatal Defense-in-Depth AI Systems Suite: Advanced RAG & Multi-LLM Architecture

    Key Takeaways

    • Five integrated defense-in-depth AI systems addressing RAG reliability, multi-hop reasoning, and verifiable outputs
    • Production-ready architecture combining Python (Django/FastAPI), React/Electron, ChromaDB, and multi-provider LLMs
    • Unique verification mechanisms: deterministic citation checking, 3×3 consensus evaluation, and HyDE query rewriting
    • Cross-platform deployment supporting both web and desktop environments
    Live Project Access: https://chat.nevatal.tech

    The Challenge: Why Nevatal Defense-in-Depth AI Systems Suite Was Built

    Modern AI systems frequently suffer from three critical failures: hallucinated outputs, brittle retrieval pipelines, and opaque decision processes. The Nevatal Defense-in-Depth AI Systems Suite addresses these through a layered architectural approach combining five specialized components:

    Core Architecture & Technical Stack Deep-Dive

    Unified Backend Orchestration

    The system leverages Python’s async capabilities through Django ASGI and FastAPI, with Celery handling long-running operations:

    # Example ASGI routing configuration
from django.urls import path
from divinity.asgi import websocket_application

application = ProtocolTypeRouter({
    "http": get_asgi_application(),
    "websocket": AuthMiddlewareStack(URLRouter([
        path("ws/rag/", websocket_application)
    ]))
})

    Multi-Modal Retrieval Engine

    Combining BM25 sparse retrieval with dense vector embeddings (ChromaDB) and Jina rerankers:

    Key Features Breakdown

    Deterministic Verification Pipeline

    • String-matching citation checks against source documents
    • ROUGE-L and BERTScore for answer faithfulness

    Real-World Use Cases

    The suite serves as both a production reference architecture and technical portfolio, demonstrating:

    How It Works: Step-by-Step Workflow

    1. Query intake through React/Electron frontend
    2. Intent classification and HyDE query expansion
    3. Multi-hop retrieval with CRAG self-correction

    Comparison: Nevatal vs Traditional RAG

    Feature Traditional RAG Nevatal Suite
    Hallucination Mitigation Basic prompt engineering Deterministic verification + 3×3 consensus

    Frequently Asked Questions

    How does the 3×3 consensus system work?

    The system runs three retrieval methods (sparse/dense/hybrid) against three LLM generators, then applies Reciprocal Rank Fusion to combine results.

    Conclusion & Next Steps

    Explore the live implementation at https://chat.nevatal.tech to experience the defense-in-depth architecture firsthand.

  • Getting Started with CRAG MultiHop Reasoning Engine: A Hands-On Tutorial

    Getting Started with CRAG MultiHop Reasoning Engine: A Hands-On Tutorial

    Key Takeaways:

    • CRAG MultiHop Reasoning Engine enables multi-step query decomposition and self-grading retrieval.
    • Features include hybrid retrieval, local reranking, and real-time WebSocket event streaming.
    • Supports complex research, multi-document investigations, and automated high-precision document QA.
    Live Project Access: https://crag.nevatal.tech

    The Challenge: Why CRAG MultiHop Reasoning Engine Was Built

    Standard Retrieval-Augmented Generation (RAG) pipelines struggle with complex multi-hop questions and ambiguous or weak contexts. The CRAG MultiHop Reasoning Engine addresses these challenges by orchestrating a composite pipeline that includes query decomposition, self-grading retrieval, and hybrid retrieval with local reranking.

    Core Architecture & Technical Stack Deep-Dive

    Tech Stack Overview

    • Frontend: React + Vite
    • Backend: Django ASGI / Daphne
    • Database: ChromaDB, PostgreSQL
    • Task Queue: Celery + Redis
    • Models: Jina Reranker v3, intfloat/multilingual-e5-small, BM25, OpenRouter (Qwen 30B)

    System Components & Deployment Topology

    The application is deployed as a containerized multi-service stack using Docker Compose, with components including Nginx Proxy, Daphne, Redis, Celery Worker, ChromaDB, and PostgreSQL.

    Key Features Breakdown & Practical Benefits

    Sequential Multi-Hop Query Decomposition

    Decomposes complex questions into logical sub-queries, allowing up to 3 hops for comprehensive retrieval.

    Corrective RAG Self-Grading Evaluator

    Classifies retrieved context as correct, ambiguous, or incorrect, with automated fallback to live external search when needed.

    Hybrid Retrieval & Local Reranking

    Combines dense vector search with BM25 sparse retrieval, merged and ranked via local Cross-Encoder (jina-reranker-v3).

    Real-Time WebSocket Event Streaming

    Visualizes pipeline progress in real-time, including retrieval, grading, reranking, and generation stages.

    Asynchronous Document Ingestion

    Supports PDF, TXT, and web URLs with background processing powered by Celery worker queues.

    Real-World Use Cases & Applications

    • Complex research and multi-document intelligence investigations requiring multi-step deductions.
    • Automated high-precision document QA with self-healing fallback mechanisms.
    • Developer reference implementation for self-grading agentic RAG workflows.

    How It Works: Step-by-Step Workflow

    1. User uploads a document or submits a query.
    2. Query is decomposed into sub-queries (up to 3 hops).
    3. Hybrid retrieval combines dense and sparse search results.
    4. Retrieved context is graded and refined as needed.
    5. Results are merged, deduplicated, and reranked.
    6. Final answer is generated and evaluated for faithfulness/relevancy.

    Comparison: CRAG MultiHop Reasoning Engine vs Traditional Approaches

    Feature CRAG MultiHop Reasoning Engine Traditional RAG
    Query Decomposition Supports multi-hop queries Single-step queries only
    Retrieval Context Grading Self-grading with fallback No grading mechanism
    Retrieval Method Hybrid dense + sparse Single retrieval method
    Reranking Local Cross-Encoder No reranking
    Real-Time Monitoring WebSocket event streaming No real-time feedback

    Frequently Asked Questions (FAQ)

    What is the CRAG MultiHop Reasoning Engine?

    The CRAG MultiHop Reasoning Engine is an AI-driven system designed for multi-step query decomposition and self-grading retrieval, enhancing the accuracy and reliability of complex question answering.

    How does the self-grading retrieval work?

    The self-grading retrieval evaluates retrieved context as correct, ambiguous, or incorrect, with automated fallback to external search when context is insufficient.

    What types of documents does it support?

    It supports PDF, TXT, and web URLs, with asynchronous processing for efficient document ingestion.

    Can I monitor the pipeline progress in real-time?

    Yes, the system provides real-time WebSocket event streaming to visualize pipeline progress.

    Conclusion & Next Steps

    The CRAG MultiHop Reasoning Engine offers a powerful solution for complex query decomposition and self-grading retrieval. To explore its capabilities, visit the live project at https://crag.nevatal.tech.

  • Getting Started with DivinityAI – Islamic Grounded RAG: A Hands-on Tutorial

    Getting Started with DivinityAI – Islamic Grounded RAG: A Hands-on Tutorial

    Key Takeaways: DivinityAI is a Retrieval-Augmented Generation (RAG) system that ensures zero hallucination by strictly grounding responses in authentic Quran and Hadith texts. Its deterministic citation verification and hybrid search capabilities make it a reliable tool for scholarly research and academic study.

    Live Project Access: https://muslim.nevatal.tech

    The Challenge: Why DivinityAI – Islamic Grounded RAG Was Built

    General-purpose large language models (LLMs) often hallucinate religious texts, leading to fabricated Quranic verses and incorrect Hadith attributions. DivinityAI addresses this critical issue by implementing a strict corpus-lock policy, ensuring every response is grounded in authenticated Quran and Hadith collections.

    Core Architecture & Technical Stack Deep-Dive

    Tech Stack Overview

    • Backend: Django ASGI / DRF
    • Frontend: React 19 / Vite
    • Database: ChromaDB
    • Embeddings: BGE-M3 Embeddings
    • Search: BM25 Sparse Search, Reciprocal Rank Fusion
    • LLM: OpenRouter (Gemini 2.5 Flash), Groq (Llama 3.3 70B)
    • Styling: Tailwind CSS v4

    Key Features Breakdown & Practical Benefits

    Strict Corpus-Lock Policy

    DivinityAI refuses to answer queries that cannot be verified from its locked corpus, ensuring zero hallucination.

    Five-Path Intent Router

    The system classifies queries into Quran verse, Hadith, Fiqh, Calculation, or Off-Domain categories, applying specialized retrieval strategies for each.

    Hybrid Search Capabilities

    Combining BM25 sparse matching with BGE-M3 dense embeddings, DivinityAI ensures comprehensive and accurate search results.

    Real-World Use Cases & Applications

    DivinityAI is ideal for scholarly research, authenticated Quran/Hadith reference discovery, and academic study of classical Arabic religious texts.

    How It Works: Step-by-Step Workflow

    1. User Query Submission
    2. Intent Classification
    3. Query Rewriting (HyDE & Sub-Queries)
    4. Hybrid Retrieval (BM25 + Dense)
    5. Citation Verification
    6. Grounded Generation
    7. Post-Generation Safety Checks

    Comparison: DivinityAI – Islamic Grounded RAG vs Traditional Approaches

    Feature DivinityAI Traditional LLMs
    Hallucination Risk Zero High
    Citation Accuracy 95%+ Variable

    Frequently Asked Questions (FAQ)

    1. What is DivinityAI?

    DivinityAI is a Retrieval-Augmented Generation system designed for accurate Quran and Hadith searches, ensuring zero hallucination.

    2. How does DivinityAI ensure citation accuracy?

    It uses a deterministic citation verification chain, including exact match, normalized match, Levenshtein distance, and semantic checks.

    3. Can DivinityAI answer non-Islamic queries?

    No, DivinityAI strictly rejects off-domain queries, focusing solely on Quran and Hadith-related questions.

    Conclusion & Next Steps

    DivinityAI offers a reliable, hallucination-free solution for Quran and Hadith searches. Explore the live project at https://muslim.nevatal.tech to experience its capabilities firsthand.

  • Getting Started with Nevatal Defense-in-Depth AI Systems Suite: Hands-on Tutorial

    Introduction

    Welcome to the ultimate guide to getting started with the Nevatal Defense-in-Depth AI Systems Suite. This comprehensive platform is designed to help developers and architects build robust, verifiable AI systems with ease. Whether you’re a seasoned developer or just starting out, this hands-on tutorial will walk you through the core architecture, key features, and real-world applications of this powerful suite.

    Key Takeaways:

    • Learn the core architecture and technical stack of Nevatal Defense-in-Depth AI Systems Suite.
    • Discover the key features and practical benefits of using this platform.
    • Explore real-world use cases and step-by-step workflow.
    Live Project Access: https://chat.nevatal.tech

    The Challenge: Why Nevatal Defense-in-Depth AI Systems Suite Was Built

    The Nevatal Defense-in-Depth AI Systems Suite was built to address the challenges of building robust, verifiable AI systems. Traditional approaches often fail to provide the necessary safeguards against hallucinations, incorrect retrievals, and ambiguous documents. This suite offers a unified defense-in-depth architectural paradigm that ensures reliability and accuracy in AI applications.

    Core Architecture & Technical Stack Deep-Dive

    The Nevatal Defense-in-Depth AI Systems Suite leverages a robust technical stack to deliver its powerful features. The core architecture is built around Python (Django ASGI / FastAPI), React / Electron, ChromaDB, PostgreSQL / Redis / Celery, OpenRouter Multi-Model, and Docker Compose. This combination ensures high performance, scalability, and ease of deployment.

    Backend Orchestration

    The backend is powered by Django ASGI/WSGI and FastAPI, providing a flexible and scalable foundation for handling complex AI workflows. Asynchronous operations are managed using Celery and Redis, ensuring efficient task processing and caching.

    Database & Storage Layer

    The suite utilizes ChromaDB for vector search, MinIO S3 for object storage, and PostgreSQL for structured data persistence. This combination allows for efficient data retrieval, storage, and management.

    Multi-Provider AI Integration

    OpenRouter API is used for multi-model access, enabling the use of various AI models such as GPT, Claude, Gemini, Qwen, Gemma, and Mistral. Client-side Web Crypto (AES-256-GCM) ensures secure API key management.

    Key Features Breakdown & Practical Benefits

    Unified Defense-in-Depth Architectural Paradigm

    The suite provides a unified approach to building agentic and RAG systems, ensuring reliability and accuracy through multi-stage intent routing, HyDE, BM25, and dense vector embeddings.

    Automated Benchmarking & Evaluation

    Automated benchmarking, 3×3 consensus evaluation, and RRF pooling ensure that the system performs optimally, providing accurate and reliable results.

    Deterministic Citation Verification & Hallucination Guards

    The suite includes deterministic citation verification and hallucination guards, ensuring that the AI system produces accurate and verifiable results.

    Real-World Use Cases & Applications

    The Nevatal Defense-in-Depth AI Systems Suite is ideal for building robust, verifiable enterprise RAG pipelines. It serves as a technical portfolio showcase, demonstrating modern AI engineering practices.

    How It Works: Step-by-Step Workflow

    1. Install the necessary dependencies using Docker Compose.
    2. Configure the backend and database settings.
    3. Deploy the frontend using React or Electron.
    4. Integrate the OpenRouter API for multi-model access.
    5. Run automated benchmarks and evaluations to ensure optimal performance.

    Comparison: Nevatal Defense-in-Depth AI Systems Suite vs Traditional Approaches

    Feature Nevatal Suite Traditional Approaches
    Architecture Unified defense-in-depth Fragmented
    Benchmarking Automated Manual
    Citation Verification Deterministic Non-deterministic

    Frequently Asked Questions (FAQ)

    What is the Nevatal Defense-in-Depth AI Systems Suite?

    The Nevatal Defense-in-Depth AI Systems Suite is a comprehensive platform for building robust, verifiable AI systems.

    What is the core architecture of the suite?

    The core architecture is built around Python (Django ASGI / FastAPI), React / Electron, ChromaDB, PostgreSQL / Redis / Celery, OpenRouter Multi-Model, and Docker Compose.

    What are the key features of the suite?

    The key features include a unified defense-in-depth architectural paradigm, automated benchmarking, deterministic citation verification, and hallucination guards.

    What are the real-world use cases of the suite?

    The suite is ideal for building robust, verifiable enterprise RAG pipelines and serves as a technical portfolio showcase.

    Conclusion & Next Steps

    Now that you have a comprehensive understanding of the Nevatal Defense-in-Depth AI Systems Suite, it’s time to dive in and start building. Visit the live project page to explore the platform and get started today.