🚀 NotiFlow — AI-Powered Business Operations Assistant

Turning informal business chaos into structured, automated intelligence — powered by Amazon Nova.

NotiFlow is an end-to-end AI operations assistant designed for small and micro businesses across India. It automatically processes informal business notifications (in Hinglish/English) from WhatsApp, GPay, Amazon Seller, and other sources — detecting intent, extracting entities, executing business logic, and syncing everything to a live Google Sheets ledger in real time.

🔴 The Problem

For a single small business owner, managing daily operations is incredibly messy and overwhelming. Throughout the day, they receive orders, payments, and credit requests continuously from multiple different apps at the same time:

WhatsApp: "bhaiya 3 kilo aata bhej dena"
GPay: "₹8000 received from Amit"
Amazon Seller: "Product: Silk Kurti. Qty: 2. Total: ₹1500"
Credit requests: "suresh ko 500 ka maal udhar dena"

Tracking all of this manually in physical notebooks or constantly switching between multiple apps is chaotic. Because there are so many notifications from different sources, it's extremely difficult for one person to maintain a unified record. As a result, owners frequently miss orders, lose track of payments, and struggle with inventory management.

The Language Barrier (Problem We Faced): Furthermore, these messages are almost always written in Hinglish (a complex mix of Hindi and English) or use highly informal, code-mixed formatting. Traditional software simply cannot understand this colloquial language, making it nearly impossible to parse and automate accurately.

There is a desperate need for a single, unified system. The owner should not have to manually scroll through every app and write things down. Instead, a central system should ingest notifications from all these apps, understand the informal Hinglish intents, and automatically construct a unified digital ledger.

💡 The Solution

NotiFlow uses Amazon Nova Lite (nova-lite-v1:0) via Amazon Bedrock to automatically convert raw, informal business notifications into structured, actionable operations.

One message in → complete business operation out.

"bhaiya 3 kilo aata bhej dena"
        ↓
Intent:    order
Item:      aata
Quantity:  3
        ↓
✅ Order recorded
✅ Inventory deducted
✅ Invoice generated
✅ Google Sheets updated
✅ Dashboard refreshed

🏗 Architecture

┌─────────────────────────────┐
│     React Dashboard         │
│  (Real-time Pipeline View)  │
└─────────────┬───────────────┘
              │ POST /api/notification
              ▼
┌─────────────────────────────┐
│     FastAPI Backend          │
│   (notification_routes.py)   │
└─────────────┬───────────────┘
              │ run_notiflow(message, source)
              ▼
┌─────────────────────────────┐
│     AI Agent Pipeline        │
│                              │
│  ┌─────────────────────┐     │
│  │  1. Intent Agent     │    │
│  │  (Amazon Nova Lite)  │    │
│  └──────────┬──────────┘     │
│             ▼                │
│  ┌─────────────────────┐     │
│  │  2. Extraction Agent │    │
│  │  (Amazon Nova Lite)  │    │
│  └──────────┬──────────┘     │
│             ▼                │
│  ┌─────────────────────┐     │
│  │  3. Data Validator  │     │
│  └──────────┬──────────┘     │
│             ▼                │
│  ┌─────────────────────┐     │
│  │  4. Skill Router    │     │
│  └──────────┬──────────┘     │
│             ▼                │
│  ┌─────────────────────┐     │
│  │  5. Google Sheets   │     │
│  │     Ledger Sync     │     │
│  └─────────────────────┘     │
└─────────────────────────────┘

✨ Features

Core AI

Hinglish NLU — Native understanding of Hindi-English code-mixed business language
Multi-intent classification — Order, Payment, Credit, Return, Preparation
Structured entity extraction — Customer, item, quantity, amount, payment type
Data validation — Hindi numeral parsing, payment alias normalization (GPay → UPI)
Agent memory — Remembers recent customers and items for contextual understanding

Automation

Zero-config pipeline — Every notification triggers: AI processing → skill execution → ledger update → dashboard refresh
Live Google Sheets ledger — Rows auto-appended, no manual export, no file downloads
Invoice generation — Automatic invoices for every order
Inventory tracking — Automatic stock deduction on orders

Multi-Source Ingestion

WhatsApp messages
GPay/UPI payment notifications
Amazon Seller orders
Custom webhooks via REST API
Real-time WebSocket streaming

Resilience

Dual model fallback — Amazon Nova → Gemini → Demo mode
Graceful Sheets failure — If Google Sheets API fails, pipeline continues normally
Error isolation — No single failure crashes the system

🛠 Tech Stack

Layer	Technology
AI Engine	Amazon Nova Lite (v1:0) via Amazon Bedrock
Backup AI	Google Gemini
Backend	Python 3.10+, FastAPI, Uvicorn
Frontend	React 18, TypeScript, Vite, Tailwind CSS
Live Ledger	Google Sheets API (gspread + google-auth)
Local Storage	Excel (pandas + openpyxl)
Real-time	WebSocket
Auth	Google Service Account (OAuth2)
Config	python-dotenv

📁 Project Structure

Notiflow/
├── agent/                    # AI Agent Pipeline
│   ├── intent_agent.py       # Stage 1: Intent classification (Nova)
│   ├── extraction_agent.py   # Stage 2: Entity extraction (Nova)
│   ├── orchestrator.py       # Pipeline orchestrator (all stages)
│   ├── router.py             # Skill router (intent → skill)
│   ├── model_router.py       # Model selection (Nova/Gemini)
│   └── skill_generator.py    # Dynamic skill generation
│
├── api/
│   └── notification_routes.py # FastAPI endpoints + WebSocket
│
├── app/
│   ├── config.py             # Central configuration
│   ├── main.py               # run_notiflow() — public API
│   └── bedrock_client.py     # Amazon Bedrock client
│
├── backend/
│   ├── main.py               # FastAPI app entry point
│   └── requirements.txt      # Python dependencies
│
├── dashboard/                # React frontend
│   └── src/
│       ├── App.tsx           # Main app component
│       ├── react.tsx         # VyaparFlow dashboard UI
│       ├── api.ts            # Backend API client
│       └── index.css         # Styles
│
├── services/
│   ├── google_sheets_service.py  # Google Sheets ledger sync
│   ├── inventory_service.py      # Stock management
│   ├── invoice_service.py        # Invoice generation
│   ├── excel_sync.py             # Excel persistence
│   └── notification_generator.py # Demo notification generator
│
├── skills/                   # Business skills
│   ├── order_skill.py        # Order processing
│   ├── payment_skill.py      # Payment recording
│   ├── credit_skill.py       # Credit tracking
│   ├── return_skill.py       # Return handling
│   └── preparation_skill.py  # Preparation queuing
│
├── validators/
│   └── data_validator.py     # Entity normalization
│
├── memory/
│   └── agent_memory.py       # Agent context memory
│
├── credentials/
│   └── sheets.json           # Google service account key
│
├── data/                     # Runtime data (Excel store)
├── .env                      # Environment variables
└── requirements.txt          # Python dependencies

🚀 Getting Started

Prerequisites

Python 3.10+
Node.js 18+
AWS account with Bedrock access (for live mode)
Google Cloud service account (for Sheets integration)

1. Clone and Install Backend

cd Notiflow
pip install -r requirements.txt

2. Set Up Environment Variables

Create a .env file in the project root:

# AWS Bedrock (for live AI mode)
AWS_ACCESS_KEY_ID=your_access_key
AWS_SECRET_ACCESS_KEY=your_secret_key
AWS_DEFAULT_REGION=us-east-1

# Google Sheets Integration
GOOGLE_SHEETS_CREDENTIALS=credentials/sheets.json
GOOGLE_SHEET_ID=your_google_sheet_id

# Optional
GEMINI_API_KEY=your_gemini_key
NOTIFLOW_DEMO_MODE=true

3. Set Up Google Sheets

Create a new Google Sheet at sheets.google.com
Add headers in Row 1:

intent	item	quantity	customer	amount	source	timestamp

Share the sheet with your service account email (found in credentials/sheets.json → client_email) as Editor
Copy the Sheet ID from the URL and update GOOGLE_SHEET_ID in .env

4. Start the Backend

cd Notiflow
uvicorn backend.main:app --reload

Backend runs at: http://localhost:8000 API docs at: http://localhost:8000/docs

5. Start the Dashboard

cd Notiflow/dashboard
npm install
npm run dev

Dashboard runs at: http://localhost:5173

📡 API Reference

`POST /api/notification`

Process a business notification through the full AI pipeline.

Request:

{
  "source": "whatsapp",
  "message": "bhaiya 3 kilo aata bhej dena"
}

Response:

{
  "message": "bhaiya 3 kilo aata bhej dena",
  "intent": "order",
  "data": {
    "customer": null,
    "item": "aata",
    "quantity": 3
  },
  "event": {
    "event": "order_received",
    "order": {
      "order_id": "ORD-20260316-0001",
      "customer": null,
      "item": "aata",
      "quantity": 3,
      "status": "pending"
    },
    "invoice": {
      "invoice_id": "INV-20260316-ABCD",
      "total_amount": 0.0
    }
  },
  "source": "whatsapp",
  "sheet_updated": true,
  "model": "live"
}

`GET /api/notifications/generate?n=5`

Generate demo notifications using Gemini.

`WebSocket /ws/notifications`

Real-time bidirectional notification streaming.

Send:

{"source": "whatsapp", "message": "rahul ne 15000 bheja"}

Receive: Same response format as POST endpoint, broadcast to all clients.

`GET /api/stream/start?n=5&delay=2.0`

Trigger automated Gemini notification streaming.

`GET /health`

Health check with configuration summary.

🧠 AI Agent Pipeline

The pipeline processes each message through 5 sequential stages:

Stage 1 — Intent Detection

Amazon Nova classifies the message into one of 6 intents:

Intent	Example
`order`	"bhaiya 3 kurti bhej dena"
`payment`	"rahul ne 15000 bheja"
`credit`	"udhar me de dijiye"
`return`	"size chota hai exchange karna hai"
`preparation`	"3 kurti ka set ready rakhna"
`other`	Unclassified messages

Stage 2 — Entity Extraction

Nova extracts structured fields based on the detected intent:

Field	Example Values
`customer`	"Rahul", "Amit Kumar"
`item`	"kurti", "aata", "silk saree"
`quantity`	3, 5 (parsed from Hindi numerals too)
`amount`	15000, 8000
`payment_type`	"upi" (normalized from gpay/paytm/phonepe)
`reason`	"size issue", "defective"

Stage 3 — Data Validation

Normalizes extracted data:

Number parsing (Hindi → integer)
Text cleanup
Payment alias mapping (GPay/PhonePe/Paytm → UPI)

Stage 4 — Skill Routing

Dispatches to the appropriate business skill based on intent.

Stage 5 — Google Sheets Sync

Appends a structured row to the configured Google Sheet.

⚡ Business Skills

Each skill handles persistence, side effects, and returns a structured event:

Skill	Trigger Intent	Actions
Order Skill	`order`	Record order → Deduct inventory → Generate invoice → Update memory
Payment Skill	`payment`	Record payment → Update ledger → Update memory
Credit Skill	`credit`	Record credit entry → Track outstanding balance
Return Skill	`return`	Log return request → Set status to `pending_review`
Preparation Skill	`preparation`	Queue preparation task → Track readiness

📊 Google Sheets Integration

NotiFlow uses Google Sheets as a live, cloud-accessible business ledger — no Excel downloads, no manual exports.

How It Works

Service account authenticates via credentials/sheets.json
After every AI pipeline execution, a row is auto-appended
The dashboard shows sync status (✅ Synced / ⚠️ Failed)

Row Structure

intent	item	quantity	customer	amount	source	timestamp
order	aata	3	Rahul		whatsapp	2026-03-16 19:30
payment			Amit	8000	gpay	2026-03-16 19:31
credit	goods		Suresh	500	whatsapp	2026-03-16 19:32

Error Handling

If credentials are missing → logs warning, returns sheet_updated: false
If Sheets API fails → logs error, pipeline continues normally
The system never crashes due to a Sheets failure

🖥 Dashboard

The React dashboard provides a premium, real-time operations console:

Reasoning Engine View

Step 1 — POST /Ingest: Shows the raw notification payload
Step 2 — AI Reasoning: Displays detected intent and extracted entities from the backend response
Step 3 — Skills Applied: Shows record finalization status and Google Sheets ledger sync badge

Business Ledger View

Orders tab: All processed orders with source, customer, item, quantity, status
Ledger tab: Payment and credit records
Inventory tab: Current stock levels with alerts

Mobile Simulation Panel

Displays a live "Signal Stream" of incoming notifications
Simulates a mobile device receiving business messages

⚙ Configuration

All settings are centralized in app/config.py:

Setting	Default	Description
`DEMO_MODE`	`true`	Use demo data instead of live Bedrock
`BEDROCK_MODEL_ID`	`amazon.nova-lite-v1:0`	Nova model ID
`BEDROCK_REGION`	`us-east-1`	AWS region
`DATA_FILE`	`data/notiflow_data.xlsx`	Local Excel store
`GOOGLE_SHEETS_CREDENTIALS`	`credentials/sheets.json`	Service account path
`GOOGLE_SHEET_ID`	(from .env)	Target Google Sheet key

🔐 Environment Variables

Variable	Required	Description
`AWS_ACCESS_KEY_ID`	For live mode	AWS access key
`AWS_SECRET_ACCESS_KEY`	For live mode	AWS secret key
`AWS_DEFAULT_REGION`	No	Default: `us-east-1`
`GOOGLE_SHEETS_CREDENTIALS`	For Sheets	Path to service account JSON
`GOOGLE_SHEET_ID`	For Sheets	Google Sheet key from URL
`GEMINI_API_KEY`	Optional	Gemini fallback API key
`NOTIFLOW_DEMO_MODE`	No	`true` / `false`

🎮 Demo Mode

When NOTIFLOW_DEMO_MODE=true (default), NotiFlow operates without AWS credentials:

Pre-configured responses for common Hinglish business messages
Keyword-based intent fallback for unknown messages
Google Sheets sync still works in demo mode
Full dashboard experience without cloud dependencies

Set NOTIFLOW_DEMO_MODE=false to use live Amazon Nova inference via Bedrock.

📄 License

This project was built for the Amazon Nova Hackathon.

Built with ❤️ using Amazon Nova Lite · FastAPI · React · Google Sheets

Name		Name	Last commit message	Last commit date
Latest commit History 8 Commits
agent		agent
api		api
app		app
backend		backend
credentials		credentials
dashboard		dashboard
data		data
database		database
memory		memory
models		models
parsers		parsers
prompts		prompts
services		services
skills		skills
utils		utils
validators		validators
.gitignore		.gitignore
README.md		README.md
package-lock.json		package-lock.json
requirements.txt		requirements.txt

Folders and files

Latest commit

History

Repository files navigation

🚀 NotiFlow — AI-Powered Business Operations Assistant

📋 Table of Contents

🔴 The Problem

💡 The Solution

🏗 Architecture

✨ Features

Core AI

Automation

Multi-Source Ingestion

Resilience

🛠 Tech Stack

📁 Project Structure

🚀 Getting Started

Prerequisites

1. Clone and Install Backend

2. Set Up Environment Variables

3. Set Up Google Sheets

4. Start the Backend

5. Start the Dashboard

📡 API Reference

POST /api/notification

GET /api/notifications/generate?n=5

WebSocket /ws/notifications

GET /api/stream/start?n=5&delay=2.0

GET /health

🧠 AI Agent Pipeline

Stage 1 — Intent Detection

Stage 2 — Entity Extraction

Stage 3 — Data Validation

Stage 4 — Skill Routing

Stage 5 — Google Sheets Sync

⚡ Business Skills

📊 Google Sheets Integration

How It Works

Row Structure

Error Handling

🖥 Dashboard

Reasoning Engine View

Business Ledger View

Mobile Simulation Panel

⚙ Configuration

🔐 Environment Variables

🎮 Demo Mode

📄 License

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

`POST /api/notification`

`GET /api/notifications/generate?n=5`

`WebSocket /ws/notifications`

`GET /api/stream/start?n=5&delay=2.0`

`GET /health`

Packages