DEV Community: Gargi Joshi

MSME-360: How I Kept Every Tenant's Hindsight Memory Strictly Separate

Gargi Joshi — Sat, 07 Nov 2026 13:54:06 +0000

If an assistant remembers everything about a business, you had better be sure it never mixes that memory with another business.

What the system does

MSME-360 is a single dashboard for small and medium businesses. It has a chat assistant, a unified inbox for WhatsApp, Instagram, Facebook and Gmail, GST invoice generation, receipt scanning, and a live link to Google Sheets. The assistant uses Hindsight agent memory (https://github.com/vectorize-io/hindsight) so it can remember past decisions and instructions across sessions.

Hindsight documentation: https://hindsight.vectorize.io/
Agent memory explainer: https://vectorize.io/what-is-agent-memory

I built the backend: Node.js, Express, MongoDB with Mongoose, JWT authentication, encryption for stored credentials, PDF invoices and billing.

The through-line: one rule for every record

The rule is simple. Every record belongs to a userId, and every query is filtered by it. That covers vendors, customers, inventory, inbox threads, vector records and Google Sheet IDs.

A business owner who asks "who is my most reliable vendor?" must only ever get an answer built from their own data and their own memory. A mix up here would not be a small bug. It would end the product.

So I put the check in one place. Every protected route reads the JWT bearer token, finds the user, and passes userId down into the controllers and services. Nothing below that layer is allowed to query without it. When we later added memory and search, the same rule carried over without any new thinking.

Keeping secrets safe

Connecting WhatsApp, Instagram, Facebook and Gmail means storing access tokens for other people's accounts. We never store those as plain text. I wrapped them in AES-256-GCM encryption using Node's built in crypto module, so a leaked database row is useless without the server key. The secret box decrypts only when a message actually needs to be sent.

Architecture Diagram

Invoices from a sentence

The chat can create invoices from messages such as "Create an invoice for Acme Corp for ₹25,000". I used PDFKit to generate the file on the fly, with the company name, GSTIN, PAN and tax rate coming from the user's settings.

This is where memory shows its value. After the owner tells the assistant once to always add 18 percent GST and use 15 day payment terms, Hindsight recalls that instruction and the invoice route receives the right values without asking again.

Billing and uploads

New accounts start on a trial subscription, and the billing controller tracks the plan. For uploads I used Multer to handle receipts and PDFs, then passed the files to the OCR service my teammate built. Keeping uploads, billing and auth in clear separate controllers kept the codebase easy for five people to work in at the same time.

What went wrong

My first version of the user filter lived inside each controller. Two controllers drifted apart and one forgot a check during testing. I caught it, but it scared me enough to move the logic into shared middleware. If a rule has to be true everywhere, put it in one place and make it impossible to skip.

Lessons I would reuse

1.⁠ ⁠Make tenant isolation a rule of the framework, not a habit of the developers.

2.⁠ ⁠Return fast, sync later. Slow third party calls should never sit in the user's click path.

3.⁠ ⁠Encrypt third party tokens at rest from day one. It is much harder to add later.

4.⁠ ⁠Treat memory as user data. Anything an agent remembers deserves the same access rules as a database row.

5.⁠ ⁠Split controllers early. Auth, billing, uploads and search are easier to debug apart.

We used Hindsight Cloud for memory, redeeming the promo code MEMHACK99 in the billing section after we registered to get the free credits. We worked with the Band AI desktop app, and the Hindsight community Slack was where we asked our questions. Language model calls go through Groq.

Memory is only a feature when it is safe. Once it is safe, it becomes the reason people trust the product.

GITHUB
LIVE LINK
YOUTUBE

🦥 SlothMode — Less Overwhelm, Smaller Steps

Gargi Joshi — Sat, 24 Oct 2026 07:47:09 +0000

🦥 SlothMode: Less Overwhelm, Smaller Steps — AI-Powered Planning at a Human Pace

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Ever spend so much time planning your tasks that you have no energy left to actually do them?

I built SlothMode, a gentle, AI-assisted task planner designed to make productivity feel less overwhelming. It is especially useful for students and people who struggle with executive dysfunction or planning anxiety.

Instead of dumping a huge to-do list into a rigid calendar, SlothMode helps turn tasks into manageable steps and creates a schedule that leaves room for breaks and everyday routines.

🦥 What makes it different?

Personalized onboarding: Set up sleep, meals, college or work hours, and other routine preferences.
Local AI assistance: Gemma 3 1B helps classify tasks, estimate durations, assess urgency, and suggest smaller subtasks.
Gentle scheduling: A deterministic scheduler organizes tasks into focus sessions and breaks while respecting deadlines and protected routine blocks.
Flexible planning: Switch between day, week, and month views, edit tasks, track subtasks, and reschedule overdue work.
Graceful fallback: If Ollama or the model is unavailable, rule-based estimation helps the app remain usable.

The goal isn't to squeeze more work into every minute. It's to make starting feel easier.

Demo

Click here for video and screenshots

Screenshots and a walkthrough are also available in the repository.

Code

GitHub repository: https://github.com/gargijoshi9/SlothMode

Built with React, TypeScript, Vite, Express, Ollama, and Gemma 3 1B.

Check out the repository for the source code, setup instructions, and implementation details.

How I Built It

SlothMode combines local AI assistance with predictable scheduling logic.

The frontend is built with React and TypeScript, with Vite for development and building. An Express backend exposes endpoints for task estimation, classification, and planning.

For AI-assisted task understanding, I integrated Gemma 3 1B through Ollama. The model can help estimate how long a task might take, identify its category and urgency, and suggest smaller steps.

But I deliberately kept the actual scheduling deterministic.

The model helps interpret the task; the scheduler decides how to fit work into the day. It organizes focus sessions and breaks around deadlines and protected routine blocks rather than asking a language model to invent calendar timestamps.

I also added validation and rule-based fallbacks for unavailable models or invalid responses. This matters because a productivity app should not become unusable just because its AI dependency is temporarily unavailable.

One of the most important parts was connecting personalized onboarding to actual scheduling behavior. Routine preferences should influence the plan, not merely make the onboarding screen look personalized.

Why Does Open Innovation Matter?

Open innovation made it possible to experiment with AI-assisted planning without building the entire experience around a closed, hosted model API.

Using an open-weight model locally through Ollama gave me more control over the integration and let me develop around a model I could run on my own machine.

It also encouraged a useful architectural separation: AI handles flexible language understanding, while deterministic code handles scheduling decisions.

That combination makes the application easier to reason about and gives it a fallback path when the model isn't available.

Open tools also make the project easier for other developers to inspect, learn from, and extend. Contributors can examine the integration, experiment with different models, or improve the scheduler without needing to treat the AI service as a black box.

The Lazy Payoff 🦥

SlothMode is meant to reduce the mental effort between “I have so much to do” and “Here's one small thing I can start.”

I haven't measured time saved yet, so I won't make up a number. For now, the goal is a calmer starting point, more realistic plans, and permission to take things one step at a time.

Prize Categories

Best Use of Gemma — SlothMode uses Gemma 3 1B locally through Ollama for task classification, time estimates, urgency, and suggested subtasks.

Less overwhelm. Smaller steps. A gentler way to get things done.

Thanks for checking out SlothMode! 🦥

Always open to suggesstion and improvements ! ❤️