Forem: Shushant Rishav

Building an AI Assistant That Actually Understands Company Policy

Shushant Rishav — Wed, 24 Dec 2025 12:00:36 +0000

Managing customer complaints in footwear retail is deceptively complex. Orders, warranty windows, product defects, inventory constraints, and outlet-specific rules intersect, creating a decision space where speed, accuracy, and consistency are all hard requirements.

STRIDE Assistant is an AI-driven complaint resolution system designed to automate this process while ensuring strict policy compliance, accountability, and human oversight.

This document explains why STRIDE Assistant exists, how it works, and how AI can be combined with deterministic policy logic to deliver reliable and auditable decisions in production systems.

Why STRIDE Assistant Exists

A customer messages support:

“My shoe tore 4 days after purchase.”

Without automation, a staff member must manually:

Verify the order and purchase date
Check warranty eligibility
Interpret company policy
Confirm inventory availability
Decide between return, replacement, repair, or rejection

Multiply this by hundreds of tickets per day, and the process becomes slow, inconsistent, and error-prone.

STRIDE Assistant addresses this by combining:

AI-driven semantic analysis to understand customer complaints
Deterministic policy enforcement grounded in business rules
Human-in-the-loop escalation for ambiguous or high-risk cases
Immutable audit logging for compliance and traceability

The result is fast, accurate, and accountable complaint handling—without over-reliance on generative AI.

Architecture Overview

Customer Message
        |
Session Verification (Order + Phone + JWT)
        |
Semantic Analysis (Intent Detection)
        |
Clarification Step (if required)
        |
Policy Retrieval
        |
Decision Engine (Policy + Order + Inventory)
        |
+-----------------------------+
| FINAL DECISION / TICKET     |
+-----------------------------+
        |
     OR Manual Review → Ticket Created

Tools and Models Used

Component	Tool / Model	Purpose
Semantic Analysis & RAG	LLaMA 3 (8B) via Ollama	Intent detection and generation of professional, policy-safe customer responses
Embeddings	SentenceTransformer (all-MiniLM-L6-v2)	Converts complaints and policy chunks into vectors for semantic retrieval
API Layer	FastAPI	Secure endpoints for customers, staff, and admins (JWT-based)
Database	PostgreSQL	Stores orders, tickets, staff actions, and audit logs
Cache	Redis	Low-latency access to prefetched order data
Logging	Structured Python logging	Captures system events, AI decisions, and staff actions

Why this setup?

LLaMA 3 (8B) hosted via Ollama enables fully local, private inference with strong instruction-following capability.
Embeddings enable deterministic policy retrieval without relying on probabilistic generation.
The system explicitly separates language understanding from decision authority.

Dual-Logic Workflow

STRIDE Assistant deliberately separates reasoning from enforcement using two complementary logic layers:

1. Policy Retriever (RAG Layer)

Interprets the complaint semantically
Retrieves relevant policy rules
Produces an initial suggested action

2. Decision Engine (Deterministic Layer)

Validates the suggestion against:
- Order history
- Warranty duration
- Product category
- Inventory availability
- Past customer interactions
Produces an authoritative outcome that may:
- Approve
- Suggest repair
- Require inspection
- Reject the complaint

Complaints are rejected when:

Warranty is expired
Damage indicates misuse
Repeated requests violate policy limits
Required order data is missing

RAG Orchestration

The RAG pipeline coordinates both logic layers:

Aggregates signals across multiple turns
Requests clarification when signals conflict
Escalates ambiguous cases to inspection
Produces a final ticket with explicit reasoning notes

This prevents hallucinated decisions and ensures traceability.

Code Snippet: Combining Logic Outputs

policy_signal = retriever.get_policy_signal(user_text, order)
decision_signal = engine.make_decision(
    user_text,
    order,
    inventory_available
)

signals = [policy_signal, decision_signal]
final_ticket = resolve_final_ticket(signals)

Every ticket is generated only after policy compliance, historical context, and system constraints are validated.

Authentication & Access Control

STRIDE Assistant uses JWT-based authentication across all actors:

User	Credentials	Access
Customer	order_id + phone	Submit complaints, track status
Staff	user_id + password	Act on tickets, add remarks
Admin	role-based credentials	Audit logs, system oversight

Benefits

Stateless and scalable
Role-based enforcement
Every action is attributable and logged

Staff & Admin Logging

Staff actions (approve, reject, escalate, close, note delays) are recorded securely
Logs are immutable and stored in staff_action_log
Admins have read-only visibility

log_staff_action(staff.id, ticket_id, action, remarks)

This ensures full accountability for both AI and human decisions.

Example End-to-End Workflow

Customer: “My shoe tore after 4 days.” → Policy retriever suggests REPLACEMENT
Decision engine validates eligibility
Clarification requested if needed
Signals are aggregated
Final ticket is resolved as one of: RETURN, REPLACEMENT, REPAIR, PAID_REPAIR, INSPECTION, or REJECT
Inventory constraints are checked
Ambiguous cases escalate to inspection
Every ticket includes a system-generated reasoning note
Staff actions are logged immutably

Production Considerations

Thread-safe LLM access via Ollama
Transaction-safe ticket creation
Redis-based order prefetching
Role-based access control
Structured logging for observability

Future Improvements

Multi-model ensembles for higher signal accuracy
Analytics dashboards for staff performance
Versioned policy ingestion
Predictive ticket prioritization
GPU-backed inference for scale

Conclusion

STRIDE Assistant demonstrates how AI can augment human decision-making without replacing it.

By combining:

Semantic understanding via LLaMA 3
Deterministic policy enforcement
Structured escalation
Immutable audit logs

STRIDE delivers explainable, compliant, and production-safe complaint resolution, a blueprint for enterprise AI systems built to operate under real-world constraints.

Author: Shushant Rishav
Repository: STRIDE_Assistant_DEMO

Drowning in News? Meet NewsSelect: Your AI-Powered Summarizer

Shushant Rishav — Sun, 27 Jul 2025 16:29:21 +0000

In our hyper-connected digital age, keeping up with the news feels less like staying informed and more like trying to drink from a firehose. The sheer volume of articles across countless sources leads to an overwhelming sense of information overload. Manually sifting through lengthy pieces to grasp the core message is not just inefficient; it's practically impossible for most people.

This challenge inspired NewsSelect – an end-to-end, AI-powered web application designed to cut through the noise. NewsSelect aims to automatically fetch live news articles, distill them into concise, abstractive summaries using a sophisticated deep learning model, and present them through a clean, responsive web interface. It’s about getting to the essence of the news, faster.

The Brains Behind the Summaries: Our Technology Stack

Building an intelligent summarization system that works in real-time requires a thoughtful selection of technologies. Here’s what powers NewsSelect and why each component was chosen:

Python 3.x: For both machine learning and backend development due to its mature ecosystem.
TensorFlow 2.x / Keras: Enables building Sequence-to-Sequence (Seq2Seq) models with attention mechanisms.
Pandas / NumPy: For preprocessing and numerical operations.
Matplotlib: For visualizing training metrics.
Contractions: Helps normalize text data by expanding contractions.
Django: Backend framework used for serving the ML model and scraping news articles.
BeautifulSoup / Requests: Handles web scraping of live news.
HTML/CSS/JS with Bootstrap: For building a responsive and clean user interface.
TPU Runtime (Colab/Kaggle): Dramatically speeds up training time for the deep learning model.

NewsSelect's Blueprint: High-Level Design

+-----------------+         +----------------+        +-------------------+
|    Preprocess    |  --->   |    Encoder      |  --->  |   Attention Layer  |
|   Clean + Token  |         |   (Bi-LSTM)     |        | (Context Vector)   |
+-----------------+         +----------------+        +-------------------+
                                                                |
                                                                V
                                                       +----------------+
                                                       |    Decoder      |
                                                       |   (LSTM + FC)   |
                                                       +----------------+
                                                                |
                                                                V
                                                       +----------------+
                                                       |    Summary       |
                                                       +----------------+
                                                                |
                                                                V
                                                       +----------------+
                                                       |  Django Backend  |
                                                       | (Model Serving & |
                                                       |   Web Scraping)  |
                                                       +----------------+
                                                                |
                                                                V
                                                       +----------------+
                                                       |   Frontend UI    |
                                                       | (Responsive App) |
                                                       +----------------+

The Workflow

Data Preparation: Preprocess 42,000+ news articles from Kaggle (news_summary.csv).
Text Normalization: Clean, normalize, and tokenize input text.
Model Training:

Encoder: Bi-LSTM to capture input context.
Attention Layer: Guides decoder by focusing on relevant parts.
Decoder: LSTM + Fully Connected layer to generate summaries.
1. Training Performance:
100 epochs in 180 minutes on Kaggle TPU.
Final Training Accuracy: 89.62%
Validation Accuracy: 74.08%
AUC Score: 0.79
F1 Score: 0.73
1. Deployment: Model served via Django REST APIs.
2. Live News Integration: Scrapes and summarizes latest news dynamically.
3. Frontend UI: Clean, mobile-responsive interface using Bootstrap.

Key Features of NewsSelect

Real-Time AI Summarization: Fetches and summarizes live news articles.
Abstractive Summarization: Generates new sentences rather than extracting existing ones.
Custom Preprocessing: Includes text cleaning and contraction handling.
RESTful Django Backend: Secure API access to the summarization engine.
Live Scraping Integration: Dynamically updates news feed.
Responsive UI: Optimized for both desktop and mobile.
Accelerated Model Training: Uses TPUs for efficient training.

Performance Metrics

Final Training Accuracy: 89.62%
Final Validation Accuracy: 74.08%
Final Training Loss: 0.7421
Final Validation Loss: 2.0726
AUC Score: 0.79
F1 Score: 0.73

Training was efficient and stable across epochs, validated by plots of Accuracy vs Epoch and Loss vs Epoch.

Getting Started Locally

Prerequisites:

Python 3.8+
Django
TensorFlow 2.x
BeautifulSoup4
Requests

Steps:

git clone https://github.com/shushantrishav/NewsSelect.git
cd NewsSelect
pip install -r requirements.txt
python manage.py runserver
# Then open frontend/index.html in browser

What's Next? Future Enhancements

Multilingual Summarization: Support summaries in multiple languages.
Cloud Deployment: Serve model via GCP/AWS for scalability.
Mobile PWA: Build a Progressive Web App version.
Real-Time Analytics: Track article popularity, summary usage.
More Categories: Expand beyond general news (e.g., finance, health).

Experience NewsSelect Today

NewsSelect stands as a powerful example of using deep learning and clean UI design to fight information overload. With real-time AI-generated summaries, users can now stay informed efficiently.

🔍 Explore the Project

🧪 Live Demo: NewsSelect
💻 GitHub Repo: NewsSelect

Thanks for reading!

👉 Like this project? Drop a star on GitHub
💬 Have questions or feedback? Let’s connect in the comments!

Feel free to contribute or ask questions!

Revolutionizing Retail: A Blockchain-Powered Loyalty and Transaction System with FastAPI + Ethereum

Shushant Rishav — Sun, 27 Jul 2025 16:08:20 +0000

Traditional retail systems, despite decades of evolution, continue to struggle with fundamental structural inefficiencies. Loyalty programs remain siloed, transaction histories are opaque, and centralized databases introduce single points of failure that are vulnerable to fraud, data corruption, and administrative manipulation. At scale, these systems also suffer from high operational costs and limited interoperability across brands.

To address these challenges, I built a Hybrid Retail Blockchain System an architecture that combines the speed and reliability of traditional databases with the immutability and auditability of blockchain, without sacrificing real-time user experience.

Rather than forcing retail transactions directly on-chain (which is impractical due to latency and gas costs), this system adopts a database-first, blockchain-anchored design suitable for real-world commerce.

Why Blockchain and Why Hybrid?

Blockchains are powerful, but they are not designed for sub-second transactional workloads. Public networks like Ethereum introduce unavoidable latency due to block times and probabilistic finality.

Retail systems, on the other hand, require:

Low-latency DB-first confirmation
Deterministic correctness
High throughput during peak hours

This creates the finality–latency tradeoff.

The Solution: Dual-State Architecture

PostgreSQL serves as the hot state for real-time transactions
Ethereum acts as an immutable audit ledger
The system is DB-first, the API returns only after PostgreSQL commit, and can optionally write to Ethereum during the same request.

This preserves the UX guarantees of traditional systems while gaining the trust and transparency benefits of Web3.

What Blockchain Brings to Retail (When Used Correctly)

Immutability: Transaction records are cryptographically anchored and tamper-proof
Transparency: Transaction proofs are verifiable on-chain when enabled, loyalty balances are stored off-chain in PostgreSQL with deterministic rules.
Security: No single point of failure for historical data
Interoperability: Enables future cross-brand loyalty ecosystems

Blockchain becomes a trust layer, not a performance bottleneck.

Technology Stack

The system is designed for correctness, scalability, and operational resilience:

FastAPI – Async Python backend with high-throughput request handling
PostgreSQL – ACID-compliant transactional datastore
Redis – Idempotency middleware cache
Solidity – Smart contracts for immutable transaction anchoring
Ethereum / Ganache / Sepolia – Development and test networks
Web3.py – Blockchain interaction and transaction signing
solcx – Dynamic Solidity compilation
Docker – Environment-consistent deployment

High-Level System Architecture

[POS / Frontend]
        |
        |  POST /transactions (Idempotency-Key)
        v
[FastAPI Backend]
        |
        +-- Redis (Idempotency Lock)
        |
        +-- PostgreSQL (ACID Transaction)
        |       - Create Sale Record
        |       - Update Loyalty Balance
        |
        +-- Blockchain Anchor (Async)
                - Convert INR → Wei (cached + emergency fallback)
                - Sign & Broadcast TX
                - Wait for receipt (current implementation)
                - Persist txId + txHash back into PostgreSQL

The customer receives an immediate response after the PostgreSQL write. When blockchain is enabled, the endpoint currently waits for the on-chain receipt before responding.

Core Backend Services

Transaction Manager
Ensures atomic DB writes and maps internal transaction IDs to blockchain hashes.
Idempotency Guard (Redis-based)
Prevents duplicate charges during retries, crashes, or network failures.
Loyalty Engine
Deterministic, precision-safe loyalty calculation using Decimal + ROUND_CEILING, implemented in PostgreSQL-backed logic.
Blockchain Anchor Service
Posts transaction metadata to Ethereum when enabled, the current implementation waits for the receipt before returning.
Currency Conversion Module
Multi-tier fallback (cached ≤ 60s → live CoinGecko refresh → emergency fixed rate) to ensure uptime under API failures.

Key Features

⚡ Low-latency DB-first confirmation
🔒 Retry-safe execution via Redis-backed idempotency middleware
📜 Immutable blockchain audit trail
🎯 Deterministic loyalty rewards
🔁 Retry-safe APIs
📊 Swagger & ReDoc auto-generated documentation
🐳 Dockerized, reproducible setup

Example API Usage

Record a Transaction

POST /transactions/record (Idempotency-Key)
{
  "orderid": "ORD-ABC123",
  "customeraddress": "0x...",
  "amountINR": 1500.75
}

The response is immediate after the PostgreSQL write, when blockchain is enabled, the API currently waits for the on-chain receipt before responding.

Local Development Setup

Prerequisites

Python 3.8+
Docker & Docker Compose
Ganache CLI

Run Locally

git clone https://github.com/shushantrishav/Blockchain_In_Retail.git
cd Blockchain_In_Retail

cp .env.example .env
pip install -r requirements.txt

npx ganache-cli -d
uvicorn app.main:app --reload

Deployment Notes

Switch to Sepolia / Mainnet via Infura or Alchemy
Persist deployed contract addresses
Secure private keys via environment variables or secret managers
Never hardcode credentials

Lessons Learned

Blockchain should anchor, not block, retail workflows
Idempotency is non-negotiable for financial systems
Floating-point math has no place in money or rewards
Async design is the difference between demos and production systems

Business Impact

📈 Increased customer trust via transparent loyalty systems
🔁 Higher retention due to predictable rewards
🤝 Foundation for cross-brand loyalty partnerships
🛡️ Auditability without operational slowdown

Roadmap

Zero-Knowledge Proofs for private loyalty validation
L2 batching with Merkle roots (99% gas reduction)
WalletConnect & MetaMask integration
Admin analytics dashboard
Multi-chain support (Polygon, Avalanche)

Final Thoughts

This project demonstrates how Web2 reliability and Web3 trust can coexist in real-world systems. By respecting the constraints of both domains, we can build retail infrastructure that is fast, transparent, and future-proof.

🔍 Project: https://github.com/shushantrishav/Blockchain_In_Retail
🧪 Live Demo: https://block-cart.vercel.app

⭐ If you found this useful, consider starring the repo or contributing!

From Long URLs to Lightning Fast Links: A Go-Powered Shortener Explained

Shushant Rishav — Sun, 27 Jul 2025 15:56:49 +0000

In today's fast-paced digital world, long and complicated URLs can be a real headache. They're difficult to share, hard to remember, and often look messy in print or on social media. This common problem led me to build the Go Distributed & Scalable Link Shortener API – a service designed to transform those unwieldy links into short, memorable, and trackable ones, all while ensuring speed, security, and scalability.

This project isn't just about shortening links; it's about providing a reliable, high-performance API with essential features like automatic expiration, robust validation, and intelligent rate limiting to prevent misuse.

Let's dive into how it's built and why these choices were made.

The Powerhouse Behind the Links: Our Technology Stack

Choosing the right tools is crucial for any scalable application. Here's what powers our link shortener and the rationale behind each choice:

Go (Golang): Go's strengths in concurrency management, rapid compilation, static typing, and performance make it ideal for high-concurrency services. Its built-in HTTP server is fast and reliable.
Redis: Used as the primary datastore. Its in-memory design ensures fast read/write, and TTL (Time-To-Live) simplifies auto-expiration. Atomic operations make it great for rate limiting.
Docker: Provides containerized environments that ensure consistent development and production deployments.
Gorilla Mux: A versatile router that handles routing, path variables, and method matching effectively in Go.
Upstash Redis: A managed, serverless Redis solution that simplifies deployment and maintenance with built-in TLS and scalability.

Architectural Blueprint: How It All Connects

The service operates as a stateless microservice:

+------------------+     HTTPS     +---------------------+     HTTP/S     +-------------------+
|   Client Device  | <------------>|   Render (Proxy)    | <------------->|   Go API Service  |
| (Browser/cURL)   |               | (HTTPS Termination) |                | (Docker Container)|
+------------------+               +---------------------+                +--------+----------+
                                                                                   |
                                                                                   | TLS
                                                                                   |
                                                                           +-------+--------+
                                                                           | Upstash Redis  |
                                                                           | (Data Storage, |
                                                                           | Rate Limiting) |
                                                                           +----------------+

Workflow at a Glance:

Request Ingress: Client sends HTTP/HTTPS requests.
Render Proxy: Handles HTTPS and forwards to Go service.
Go API Service:

Rate Limiting: Redis checks IP-based usage.
URL Validation: Ensures HTTPS and no malicious input.
Duplicate Check: Returns existing short URL if already stored.
Short Code Generation: Creates or verifies custom short code.
Redis Storage: Stores mappings with 7-day TTL.
Response: Returns short URL and remaining rate limit.
1. Redirection: Resolves short URL to long URL using Redis and sends a 301 redirect.
2. Redis Connectivity: All interactions are TLS-encrypted.

Key Features That Make a Difference

Link Shortening: Converts long URLs to concise versions.
Optional Custom Shorts: User-defined short paths are supported.
Automatic Expiration (TTL): Links expire in 7 days.
Duplicate Handling: Existing links return the same short URL and renew the TTL.
Strict HTTPS Validation: Validates incoming URLs to ensure security.
Rate Limiting: Max 15 requests per 2 minutes per IP.
Enhanced API Response: /shorten endpoint includes remaining rate limit.
Dockerized Deployment: Simplifies setup and scaling.
Environment Config: All settings handled via .env variables.
TLS-Secured Redis Connection: Fully encrypted communication with Redis.
CORS Support: Manages cross-origin requests with secure defaults.

API Usage: Getting Started

Base URLs:

Local HTTP: http://localhost:8080
Local HTTPS: https://localhost:8443
Render Deployment: https://your-render-service-name.onrender.com

1. Shorten a URL

POST /shorten

Request Body (JSON)

{
  "long_url": "https://example.com/very/long/path",
  "custom_short": "optional-custom-code"
}

Example curl

curl -k -X POST \
     -H "Content-Type: application/json" \
     -d '{"long_url": "https://github.com/golang/go"}' \
     https://localhost:8443/shorten

Success Response

{
  "short_url": "/s/AbC12X",
  "long_url": "https://github.com/golang/go",
  "limit_remaining": 14,
  "message": "URL shortened successfully"
}

2. Redirect from Short URL

GET /s/{short}

Example curl

curl -k -L https://localhost:8443/s/AbC12X

Returns an HTTP 301 redirect to the long URL.

3. Health Check

GET /health

curl http://localhost:8080/health

Returns 200 OK with message OK

Local Setup

Prerequisites:

Go 1.22+
Docker + Docker Compose
OpenSSL

Steps:

git clone https://github.com/shushantrishav/Go_URL_Shortner.git
cd Go_URL_Shortner

Create .env file:

REDIS_ADDR=localhost:6379
REDIS_PASSWORD=your_redis_password
REDIS_DB=0
HTTP_PORT=8080
HTTPS_PORT=8443
TLS_CERT_PATH=/app/localhost.crt
TLS_KEY_PATH=/app/localhost.key

Generate Self-Signed Certificates:

openssl req -x509 -newkey rsa:4096 -nodes -keyout localhost.key -out localhost.crt -days 365 -subj "/CN=localhost"

go mod tidy
docker-compose up --build

Seamless Deployment on Render

Push to GitHub
Create a new Web Service in Render
Choose Docker as runtime
Set env variables:
- PORT=8080
- REDIS_ADDR, REDIS_PASSWORD, REDIS_DB

Render handles HTTPS automatically. No TLS certs required in code.

Important Notes

Never hardcode secrets like REDIS_PASSWORD
Local HTTPS uses self-signed certs. Use curl -k to bypass warnings.
CORS config must be production-aware
Rate limit by IP; can be adjusted for users behind proxies

Future Improvements

User Auth for managing personal links
Custom Domain Support
Analytics: Clicks, referrers, geolocation
QR Code generation
Admin dashboard
Advanced rate limiting strategies
Database abstraction for metadata
Monitoring & graceful shutdowns

🔍 Explore the Project
🧪 Live Demo: Cutlink
💻 GitHub Repo: Go_URL_Shortner

Thanks for reading!

👉 Like this project? Drop a star on GitHub
💬 Have questions or feedback? Let’s connect in the comments!

Feel free to contribute or ask questions!