-
-
Ignite Chat Icon
-
Ignite API Results
-
Microphone feature
-
Ignite Chat - Intertactive Messages
-
Generation of Images on demand
-
Google Cloud Run
-
Ignite API - Architecture
-
Ignite Chat Architecture
Inspiration
📜 Disclosure of Pre-existing Work:
The foundational Ignite Ecosystem codebase was originally initiated in May 2026 and the core repository was pushed in July 2026. However, the specific features submitted for this hackathon—including the Google Cloud Run deployment, Gemini 3.5 integration, Google GenAI SDK implementation, multi-cloud orchestration, enterprise-grade MLOps pipelines, and the autonomous agentic workflow orchestration for the Fortified Enterprise Fleet track—were developed, refactored, and fully deployed during the official Hackathon Submission Period (August 2026).
This submission represents a significant enhancement and enterprise-grade adaptation built on top of the existing foundation. All pre-existing code is open-source and fully documented in the repository. This integration-level solution did not exist in this cloud-deployed, agentic form prior to August 2026, fully complying with the 'newly created during the period' spirit.
Enterprises and developers routinely drown in unstructured data—invoices, technical sheets, contracts, emails, and internal documentation—locked in static PDFs and complex layouts. Traditional OCR/TTS solutions extract raw text without semantic context, while standard conversational bots struggle with hallucination and lack real-time integration with business backends. The result is operational friction, missed insights, and slow decision‑making.
We set out to bridge this divide by designing the Ignite Ecosystem: a modular, end‑to‑end AI platform that unifies high‑throughput file extraction with contextual conversational intelligence—and ultimately, autonomous execution.
Our architecture is built on three progressive layers, each adding a new dimension of value:
- Ignite API lays the foundation with reliable, event‑driven data extraction.
- Ignite Chat turns those insights into tangible, human value through natural conversation.
- Ignite Autopilot (in planning) takes that intelligence into autonomous execution, without losing flexibility.
Value is not created in a single layer—it is built from the ground up. Each layer depends on the quality of the one below it to deliver real agility to the end user.
Enterprises routinely drown in piles of unstructured paper, PDFs, and invoices.
What it does
Diagram depicting the 3-tier modular architecture: Foundation Data Extraction (Ignite API), Conversational Interface (Ignite Chat), and Autonomous Execution (Ignite Autopilot).
The Ignite Ecosystem operates through three decoupled, complementary engines that scale from data ingestion to autonomous decision‑making:
Ignite API – The Foundation
A high‑throughput, event‑driven extraction engine built on FastAPI. It ingests complex, unstructured documents (PDFs, scans, spreadsheets), audio files, and meeting videos, extracts nested tabular and semantic structures, validates the output against deterministic schemas with unified metadata blocks, and dispatches normalized JSON payloads to downstream enterprise systems (ERPs, databases, webhooks). Without correctly processed data, the interface has no real value to deliver.
Ignite Chat – The Interface
An enterprise multi-agent conversational platform packaged as a native desktop assistant (PyWebView + WinForms container) and headless multi-cloud server. Powered by Retrieval-Augmented Generation (RAG) and an active multi-provider LLM picker (Google Gemini 3.5 Flash/Pro, DeepSeek R1/V4, OpenAI, Anthropic Claude 3.7, Perplexity Sonar, xAI Grok, Alibaba Qwen), it provides voice cloning, full-duplex hands-free voice calls, isolated code execution, and real-time USD token cost auditing. This is where technology becomes human and accessible: the visible proof point where Ignite API insights translate into agility and tangible value for the end user.
Ignite Autopilot – The Autonomy (in planning)
The most advanced tier: an agentic solution that executes automated processes end‑to‑end while preserving conversational flexibility. It reasons over extracted context to make autonomous decisions and trigger workflows with minimal human manual intervention. The flow is simple: the user expresses an intent in natural language → Ignite Autopilot reasons over context and defines the right action → the process runs end to end, with no manual intervention required.
When to use each layer:
- Ignite Chat – For day‑to‑day questions, multi-agent debates, real-time web search grounding, interactive Plotly dashboards, automated Office document generation, and KPI tracking on the go.
- Ignite API – For high-throughput synchronous/asynchronous document, image OCR, audio, and video extraction with strict Pydantic schemas, multi-LLM routing, and direct disk streaming.
- Both together – For end‑to‑end enterprise workflows: Ignite API extracts, normalizes, and indexes multimedia payloads into persistent SQLite vector stores (
local_rag.db), while Ignite Chat consumes them via RAG and MCP tools to let users query and act on source data immediately.
How we built it
Cloud-native architecture blueprint showcasing Python FastAPI async services, multi-stage Docker containers, and automated CI/CD deployment pipelines.
We designed Ignite with a cloud‑native, decoupled architecture prioritizing scalability, low latency, and deterministic output:
Backend & Ingestion (Ignite API):
Built with Python and FastAPI, utilizing asynchronous task queues, media-type semaphores, and persistent job managers (/api/v1/jobs/{id}) to ensure horizontal autoscaling. The architecture implements smart dynamic routing based on file size thresholds (< MB sync vs. ≥ MB async) and direct disk streaming to eliminate RAM saturation under heavy payloads.
Specialized Multimodal Extraction Pipeline:
Layout-aware parsers and OpenCV frame extractors combined with local OCR (Tesseract), audio processing (Gemini File API with faster-whisper fallback), and a two-stage video pipeline (Stage A Gemini Vision description + Stage B target LLM structuring). Output payloads enforce strict Pydantic V2 schemas and ship ready-made business JSON templates (Invoices, Medical Prescriptions, Meeting Minutes, Lecture Summaries, Video Ad Analysis).
Conversational & Multi-Agent Engine (Ignite Chat):
Hybrid architecture supporting local execution (PyWebView, faster-whisper, local SQLite vector store local_rag.db, Cartesia TTS with ~150ms zero-latency streaming) and remote multi-cloud container execution (IGNITE_RUNTIME_MODE=remote with sticky X-Ignite-Session-Id headers). Features a Model Context Protocol (MCP) JSON-RPC 2.0 gateway, live Python/Matplotlib code sandbox, Plotly.js chart renderer, and automated .docx, .xlsx, and .pptx document builders.
DevOps & Multi-Cloud Infrastructure:
Containerized via multi-stage Dockerfiles and automated with GitHub Actions and Google Cloud Build. Deployable across Google Cloud Run (scale-to-zero on port 8080), Azure Container Apps (ACA), and Kubernetes (GKE/AKS) with Azure Key Vault (kvignitechat) secrets management and automated test suites (255 tests in Chat across 34 modules, 47 tests in API).
Challenges we ran into
Technical workflow illustrating complex document layout parsing, recursive table detection, and schema validation with fallback recovery.
Layout & Table Complexity:
Handling non‑standard document formatting (multi‑column layouts, nested tables, rotated pages) and complex spreadsheets without losing semantic structure during extraction and chunking.
LLM Non‑Determinism & Schema Compliance:
Enforcing strict JSON schemas across diverse model providers under heavy token load, solved via Pydantic V2 programmatic guardrails, fallback recovery parsers, and exponential backoff retry mechanisms.
Latency vs. Accuracy in RAG & Search:
Balancing high-context retrieval quality against real-time streaming latency. Solved by truncating search grounding context history (cutting token usage by over 95%), integrating hybrid dense/sparse retrieval, and prefetching audio chunks in Cartesia TTS.
Cost & Token Economics:
Preventing runaway API costs during large batch ingestions through dynamic prompt optimization, intelligent routing, vector caching, and real-time USD token cost calculators without hardcoded rates.
Accomplishments that we're proud of
Enterprise production dashboard displaying live conversational multi-model interactions alongside schema-verified JSON extraction results and system health metrics.
Decoupled & Multi-Cloud Architecture:
Engineered a modular ecosystem deployable seamlessly across Google Cloud Run, Azure Container Apps, and Kubernetes, complete with offline export sinks (SQL Server via pyodbc and Azure Data Explorer Kusto SDK).
100% Deterministic Extraction & Unified Schemas:
Delivered strict, schema-compliant JSON extraction across documents, images, audio, and video with a homogeneous metadata block tracking model duration and token consumption.
Comprehensive Enterprise Feature Set:
Integrated hands-free 3-tier voice transcription, Cartesia voice cloning, PII Shield redaction, Prompt Injection guards, live Python execution sandbox, and automated Office file generation directly within the desktop UI.
Production-Grade Testing & MLOps:
Built robust automated CI/CD pipelines backed by 302 automated tests in total (255 in Ignite Chat and 47 in Ignite API), guaranteeing zero regression across multi-cloud environments.
What we learned
Engineering architecture breakdown highlighting modular decoupling, programmatic Pydantic guardrails, and hybrid retrieval efficiency.
Modularity is Crucial in AI Engineering:
Decoupling ingestion from conversational interfaces allows each engine to scale, fail, and upgrade independently without cascading outages. A strong data foundation sustains the entire ecosystem.
Validation Trumps Pure Prompting:
LLMs require deterministic programmatic guardrails (Pydantic, strict typing, fallback parsers) to be viable for enterprise data pipelines. Quality inputs at the source keep every answer in Chat accurate.
Context Efficiency:
Advanced chunking and hybrid retrieval strategies yield far better factual accuracy than simply feeding larger context windows to models. Context efficiency matters more than raw context size.
What's next for Ignite
Strategic roadmap focusing on multi-agent task orchestration, on-premise quantized models, self-healing schemas, and autonomous Autopilot execution.
Multi‑Agent Task Orchestration:
Enabling Ignite Chat to autonomously execute multi‑step enterprise workflows based on extracted document triggers, moving from conversation to action seamlessly.
On‑Premise & Local Model Support:
Adding support for quantized local models (e.g., LLaMA, Mistral, ONNX runtime) for air‑gapped or privacy‑restricted deployments, giving enterprises full control over their data.
Self‑Healing Extraction Schemas:
Implementing automated schema adaptation that dynamically flags and learns new document formats over time, reducing maintenance overhead and future‑proofing the extraction pipeline.
Enhanced Autopilot Capabilities:
Expanding the agentic layer to handle more complex, multi‑step business processes while preserving the conversational naturalness that makes Ignite Chat accessible to all users.
Log in or sign up for Devpost to join the conversation.