Autonomous, AI-driven Returns and RMA SaaS platform with real-time fraud detection and intelligent claim processing.

ClaimNova transforms the massive headache of e-commerce returns into a seamless, fully automated, zero-touch process. Built with Amazon Nova's High-Thinking models for multimodal reasoning and orchestrated by Airia's Active Agents, wrapped in a premium glassmorphic UI.

• 🤖 Autonomous AI Agent: A conversational interface that handles the entire return process via chat, reducing manual support tickets and overhead.
• 🛡️ Intelligent Fraud Detection: Utilizes Amazon Nova's phenomenal multimodal understanding to cross-reference conversational text with user-uploaded images of defects, assigning a highly accurate fraud probability score before processing refunds.
• ⚡ Multi-Agent Orchestration: Deployed as an Active Agent using Airia, seamlessly executing SQL database queries and managing decision-making workflows between the frontend and backend.
• 📊 Real-Time Admin Dashboard: Live, synchronized interface for administrators to monitor incoming orders, claims, and AI resolutions using Supabase Realtime, enforcing a Human-In-The-Loop (HITL) capability.
• 🔔 Smart Slack Automation: Configurable real-time webhook alerts pushed directly to Slack when high fraud is detected or high-value claims require human review.
• 🎨 Premium UI/UX: A stunning, modern, glassmorphic white theme built with TailwindCSS, shadcn/ui, and Framer Motion animations.

graph TD
    A[Customer initiates chat] -->|Types issue or records voice| B(Airia Active Agent Orchestrator)
    B -->|Requests evidence| C{User provides evidence}
    C -->|Uploads Image/Receipt| D[Amazon Nova: Multimodal Analysis]
    C -->|Text Description| E[Amazon Nova: High-Thinking Reasoning]

    D --> F[AI Fraud Engine]
    E --> F

    F -->|Calculates Confidence Score| G{Decision Matrix}

    G -->|Low Fraud & Valid| H[✅ Approve Refund]
    G -->|Medium Fraud| I[⚠️ Flag for Human-in-the-Loop]
    G -->|High Fraud / Invalid| J[❌ Reject Claim]

    H --> K[(Supabase Database)]
    I --> K
    J --> K

    K -->|Realtime Subscription| L[Admin Dashboard]
    K -->|Webhook Trigger| M[Slack Notification]

The system operates through a multi-stage AI pipeline:

1. Customer Chat — The customer interacts with Nova, the AI assistant, via a chat interface. They describe their issue in text or use voice input (transcribed via Groq Whisper).

2. Order Lookup — When the customer provides an Order ID (format: ORD-XXXX-XXX), the system fetches order details from Supabase and injects them into the AI context for fraud cross-referencing.

3. Evidence Collection — The AI requests photographic evidence for physical damage claims. Uploaded images are converted to base64 and attached to the Airia pipeline payload.

4. AI Analysis — The request is sent to the Airia Pipeline which routes to Amazon Nova's multimodal models. Nova analyzes text + images together for:

   • Product verification (does the photo match the ordered item?)
   • Damage assessment
   • Fraud probability scoring (Low / Medium / High)
   • Confidence scoring (0–100)

5. Fallback — If Airia is unavailable, the system falls back to Groq (Llama 3.3 70B) for text-only reasoning.

6. Decision & Persistence — The AI emits a structured JSON verdict. The backend creates/updates a claim record in Supabase with the verdict, fraud score, and resolution.

7. Real-Time Dashboard — Admins see claims appear instantly via Supabase Realtime subscriptions. They can override AI decisions (Human-In-The-Loop).

8. Slack Alerts — High-fraud or high-value claims trigger configurable Slack webhook notifications.

ClaimNova/
├── src/
│   ├── app/
│   │   ├── api/
│   │   │   ├── chat/route.ts          # AI chat endpoint (Airia + Groq fallback)
│   │   │   └── notify/route.ts        # Slack webhook notification endpoint
│   │   ├── page.tsx                    # Main split-screen view (Chat + Admin)
│   │   ├── layout.tsx                  # Root layout with Poppins font
│   │   └── globals.css                # Global styles, design tokens, animations
│   ├── components/
│   │   ├── chat/
│   │   │   ├── ChatPanel.tsx           # Chat container with header
│   │   │   ├── ChatInput.tsx           # Message input with file/voice attachments
│   │   │   ├── MessageBubble.tsx       # Chat message rendering
│   │   │   ├── FileUpload.tsx          # Drag-and-drop file attachment
│   │   │   └── VoiceRecorder.tsx       # Voice recording with Whisper transcription
│   │   ├── admin/
│   │   │   ├── AdminDashboard.tsx      # Live admin panel with claims/orders tables
│   │   │   ├── AddOrderModal.tsx       # Create new orders
│   │   │   ├── AddClaimModal.tsx       # Manually file claims
│   │   │   └── NotificationSettings.tsx # Configure Slack webhook
│   │   └── ui/                         # shadcn/ui primitives
│   └── lib/
│       ├── supabase.ts                 # Supabase client, TypeScript interfaces
│       ├── chat-store.ts               # Zustand store with localStorage persistence
│       └── utils.ts                    # Utility functions (cn helper)
├── supabase/
│   └── database_schema.md             # SQL DDL for orders & claims tables
├── public/                             # Static assets
├── Dockerfile                          # Multi-stage production build
├── docker-compose.yml                  # Container orchestration wrapper
├── .dockerignore                       # Docker context exclusions
├── next.config.ts                      # Next.js configuration (standalone output)
├── package.json                        # Dependencies and scripts
├── tsconfig.json                       # TypeScript configuration
└── .env.local                          # Environment variables (not committed)

• Node.js ≥ 18 (recommended: 20 LTS)
• npm ≥ 9
• A Supabase project (create one free)
• An Airia account with an active pipeline (airia.ai)
• (Optional) A Groq API key for voice transcription and LLM fallback
• (Optional) A Slack Incoming Webhook URL for alerts

git clone https://github.com/trueashik/ClaimNova.git
cd ClaimNova

npm install

Create a .env.local file in the project root:

# ── Supabase (Required) ──
NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
NEXT_PUBLIC_SUPABASE_ANON_KEY=your-anon-key

# ── AI Orchestrator (Required for AI features) ──
ORCHESTRATOR_WEBHOOK_URL=https://api.airia.ai/v2/PipelineExecution/your-pipeline-id
AIRIA_API_KEY=your-airia-api-key

# ── Groq (Optional — voice transcription + LLM fallback) ──
GROQ_API_KEY=your-groq-api-key

Tip: Get your Supabase URL and anon key from your project's Settings → API page.

Run the SQL from supabase/database_schema.md in your Supabase SQL Editor to create the required orders and claims tables with their custom enum types.

npm run dev

Open http://localhost:3000 — you'll see the split-screen interface with the Customer Chat on the left and the Admin Dashboard on the right.

ClaimNova includes Docker support for containerized production deployments.

# Make sure .env.local exists with your keys (see step 3 above)
docker compose up --build

The app will be available at http://localhost:3000.

To run in the background:

docker compose up --build -d

To stop:

docker compose down

# Build the image
docker build -t claimnova .

# Run the container
docker run -p 3000:3000 --env-file .env.local claimnova

The Dockerfile uses a multi-stage build optimized for production:

* Without Airia keys, the AI chat will fall back to Groq if configured, or return a service-unavailable message.

ClaimNova uses Supabase (PostgreSQL) with two core tables and Realtime subscriptions enabled for live dashboard updates.

Full SQL definitions: supabase/database_schema.md

erDiagram
    ORDERS ||--o{ CLAIMS : "has"
    ORDERS {
        varchar order_id PK
        varchar customer_name
        varchar customer_email
        varchar product_name
        text product_description
        varchar product_category
        varchar vendor_name
        timestamptz order_date
        timestamptz delivery_date
        varchar delivery_status
        numeric order_amount
        int return_window_days
        timestamptz created_at
    }
    CLAIMS {
        varchar claim_id PK
        varchar order_id FK
        text customer_issue
        varchar issue_category
        jsonb multimodal_evidence
        enum ai_status
        enum ai_fraud_probability
        numeric ai_confidence_score
        text ai_assessment_notes
        enum authority_status
        varchar authority_reviewer_id
        text authority_notes
        enum resolution
        numeric approved_refund_amount
        timestamptz filed_at
        timestamptz resolved_at
        timestamptz updated_at
    }

The core AI chat endpoint. Accepts multipart/form-data with:

Returns a structured JSON response with reply, verification_status, fraud_probability, confidence_score, assessment_notes, resolution, and refund_amount.

Sends Slack webhook notifications. Accepts JSON:

{
  "type": "fraud" | "refund" | "verification",
  "orderId": "ORD-XXXX-XXX",
  "claimId": "CLM-XXXXXXXX",
  "details": "Formatted message string",
  "slackWebhookUrl": "https://hooks.slack.com/services/..."
}

1. Fork the repository
2. Create a feature branch: git checkout -b feature/your-feature
3. Commit your changes: git commit -m 'Add your feature'
4. Push to your branch: git push origin feature/your-feature
5. Open a Pull Request

This project is private. All rights reserved.

Built with ❤️ by Ashik Ahmed
Powered by Amazon Nova • Airia • Supabase