planning.txt

# RIDA – AntiGravity Project Context & Hackathon Requirements

> This document is for the AI assistant inside **AntiGravity** (Gemini) to understand exactly what we are building, why, and under which hackathon constraints.

---

## 1. Hackathon Overview

We are participating in a hackathon where we must:

### 1.1 What to Build

* Build and deploy a **working AI application** that leverages modern AI infrastructure.
* The app **must be built on LiquidMetal AI’s Raindrop Platform**, using the **Raindrop MCP Server**.
* We **must use an AI coding assistant** (Claude Code, Gemini CLI, etc.) to build on Raindrop.
* We **must integrate at least one Vultr service** for AI workloads.
* Projects must be **new or significantly updated** during the hackathon period.
* If we choose a special category (Voice Agent / Ultra-Low Latency), there are extra requirements (ElevenLabs, Cerebras), but RIDA is primarily positioned for:

  * **Best Small Startup Agents** and/or
  * **Best AI App by a Solopreneur**.

### 1.2 Core Technical Requirements

* Utilize **Raindrop Smart Components**:

  * **SmartBuckets** (document ingestion & classification)
  * **SmartInference** (OCR, extraction, layout, summary)
  * **SmartMemory** (semantic memory / vector search)
  * **SmartSQL** (natural-language SQL, validations, analytics)
* Deploy backend services on **Raindrop**.
* Enhance the Raindrop application with **at least one Vultr service** (for example: Vultr compute instance, managed database, object storage, or GPUs for workloads).
* The application must function consistently as demonstrated in the video.
* Aim for **launch-ready quality**: auth encouraged, payment optional.

### 1.3 Submission Requirements

We must provide:

1. **Live Deployed App**

   * Public URL where judges can test RIDA.

2. **Source Code**

   * Public GitHub repo (with MIT/Apache license) **or**
   * `.zip` of complete source code.

3. **Demo Video (≤ 3 minutes)**

   * Show the app functioning as intended.
   * Explicitly show where and how we use **Raindrop Smart Components**.
   * Show where and how we use **Vultr services**.

4. **Project Description**

   * Problem being solved.
   * Features and functionality.
   * How required technologies are used (Raindrop + Vultr, plus any others).
   * Any additional integrations.

5. **List of Raindrop services used**

   * Which Smart Components and how they are used in the app.

Optional but encouraged:

* Product Requirements Document (PRD) generated by Raindrop.
* Feedback on Raindrop + Vultr.
* Social media posts showing the project.

Judging criteria (equally weighted):

* Use of Raindrop Smart Components (20%)
* Use of Vultr services (20%)
* Launch quality & functionality (20%)
* Idea quality & impact (20%)
* Submission quality (20%)

---

## 2. Problem RIDA Solves

Companies are flooded with operational documents:

* Invoices, receipts, **GRNs** (Goods Received Notes), **IRs** (Inspection Reports)
* Contracts, legal agreements
* Forms (HR, education, healthcare, etc.)

Current tools (Google DocAI, AWS Textract, Azure Form Recognizer, ABBYY, Rossum, Nanonets, etc.) mostly:

* Do **OCR + field extraction** for individual documents
* Provide limited or no **cross-document reasoning**
* Do not maintain a **semantic memory** across all documents
* Rarely support **natural-language SQL** or business logic
* Do not allow **“chat with my entire document collection”**

RIDA fills six key gaps:

1. **Multi-agent reasoning** over documents
2. **Cross-document semantic memory**
3. **Unified extraction + reasoning engine**
4. **Natural-language SQL intelligence**
5. **Chat with your entire document collection**
6. **Zero-setup onboarding** for SMBs (no manual templates)

---

## 3. RIDA – Product Overview

**Name:** RIDA – Raindrop Intelligent Document Agent

**Concept:**
A **Document Intelligence Console** where users can:

1. Upload operational documents (invoices, GRNs, IRs, receipts, contracts, etc.)
2. Automatically extract structure and meaning (fields + tables + summary)
3. Store them in **SmartMemory** for cross-document semantic search
4. Chat across all documents using natural language
5. Trigger SQL-backed analytics and workflows via **SmartSQL**

RIDA is built on **Raindrop** and enhanced by **Vultr services**.

---

## 4. Multi-Agent Architecture (Conceptual)

RIDA uses a multi-agent design on top of Raindrop Smart Components:

1. **Ingestion Agent**

   * Input: uploaded documents.
   * Uses **SmartBuckets** to classify document type (invoice, GRN, IR, contract, etc.).
   * Writes document metadata to our database.
   * Routes to the correct extraction workflow.

2. **Extraction Agent**

   * Uses **SmartInference**:

     * OCR and raw text.
     * Key–value field extraction (total, vendor, date, etc.).
     * Table extraction (line items).
     * Document summary.
   * Stores extraction results in a `documents` / `extractions` table.

3. **Memory Agent**

   * Takes raw text and important sections.
   * Chunks and embeds via **SmartMemory**.
   * Stores chunk references linked to documents, vendors, dates.

4. **Query Agent**

   * Handles user questions like:

     * "Summarize this contract."
     * "Compare these two invoices."
     * "What did Vendor X charge last month?"
   * Retrieves relevant context from **SmartMemory**.
   * Produces a grounded answer with references.

5. **Action Agent**

   * Turns high-level instructions into **SmartSQL** tasks:

     * Validate invoice vs GRN vs IR quantities and totals.
     * Compute vendor spend over a period.
     * Flag discrepancies and generate reports.
   * Executes SQL via SmartSQL and returns structured results to frontend.

All of this is meant to run on **Raindrop** backend infrastructure, with Vultr providing underlying compute/database/storage for performance and scalability.

---

## 5. Frontend Application Structure

We want a **clean, responsive, modern web console** for RIDA. This will exist as a Next.js / React app (either from Lovable or AntiGravity-generated), with:

1. **Landing Page (`/`)**

   * Aurora-style hero background (using a custom `AuroraBackground` component).
   * RIDA branding and tagline.
   * Clear explanation of features.
   * Calls to action: **Get Started (Sign Up)**, **View Console Demo**.

2. **Auth Pages**

   * Login & Signup (email/password or social provider).
   * For hackathon, can be Supabase / Firebase / or any secure provider.

3. **Dashboard (`/dashboard`)**

   * Stat cards: Total Documents, Processed Documents, Vendors, Last Upload.
   * Recent documents list.

4. **Documents (`/documents`)**

   * Upload area (drag-and-drop + file picker for PDFs/images).
   * Documents table: name, type, status, uploaded at.
   * Link to **Document Detail**.

5. **Document Detail (`/documents/[id]`)**

   * Document metadata.
   * Key fields panel.
   * Summary panel.
   * Line items table.

6. **Chat (`/chat`)**

   * Left panel: "Documents in context" with checkboxes.
   * Right panel: chat view between user and RIDA.
   * Uses our backend `/chat` endpoint powered by QueryAgent + SmartMemory/SmartSQL.

7. **Workflows (`/workflows`)**

   * List or cards showing example workflows (Invoice vs GRN validation, Vendor spend analytics, etc.).
   * For now, mostly descriptive, with potential to trigger ActionAgent tasks.

We want this frontend to be **simple, elegant, and mobile-friendly**, using:

* **Tailwind CSS**
* **shadcn/ui** for high-quality components
* **TypeScript** for type safety

---

## 6. Backend & Infrastructure Plan

To satisfy hackathon requirements:

* **Backend on Raindrop**

  * Implement MCP server and Raindrop functions that:

    * Handle document upload & metadata.
    * Call SmartBuckets / SmartInference / SmartMemory / SmartSQL.
    * Expose REST / RPC endpoints for the frontend.

* **Vultr Integration** (at least one service)

  * Options include:

    * Vultr compute instance for hosting part of the stack.
    * Vultr-managed database for document metadata & logs.
    * Vultr object storage for document files.
  * AntiGravity / AI assistant should help design this integration in a **clear and minimal** way.

* **AI Coding Assistant Usage**

  * We explicitly use **Gemini CLI / AntiGravity** and/or Claude Code to:

    * Scaffold project structure.
    * Implement agents and endpoints on Raindrop.
    * Wire Vultr services.

---

## 7. Goals for AntiGravity Workspace

When working inside this AntiGravity project, the AI assistant should:

1. **Respect the Hackathon Constraints**

   * Always keep Raindrop + Vultr + AI assistant usage in mind.
   * Prefer solutions that clearly showcase SmartBuckets, SmartInference, SmartMemory, SmartSQL.

2. **Keep Architecture Clean & Understandable**

   * Well-organized backend code for Raindrop MCP server.
   * Clear modules for each Agent (Ingestion, Extraction, Memory, Query, Action).
   * REST/JSON-style interfaces that are easy for the frontend to call.

3. **Prioritize Demo Flow**

   * Smooth flow for judges:

     1. Landing → Sign up / Login
     2. Upload docs on Documents page
     3. Open Document Detail (see extracted data)
     4. Go to Chat and ask questions
     5. Optionally run a workflow (e.g., validate invoice vs GRN)

4. **Minimize Complexity, Maximize Clarity**

   * Use mock data where necessary but keep clear extension points for real Raindrop calls.
   * Ensure the app can be deployed and run consistently.

---

## 8. Summary for the AI Assistant

* We are building **RIDA**, a Raindrop-powered Intelligent Document Agent, for a hackathon.
* Frontend: modern Next.js console (landing + Dashboard + Documents + Chat + Workflows).
* Backend: Raindrop MCP server with multi-agent architecture using SmartBuckets, SmartInference, SmartMemory, SmartSQL.
* Infra: integrate at least one Vultr service.
* Tools: we must use AI coding assistants (like Gemini CLI inside AntiGravity) to build it.
* Focus: keep the implementation **simple, robust, and demo-ready**, aligned with the judging criteria and submission requirements above.

When you generate code or make changes in this project, always align with this context and these goals.