DEV Community: Akshay Kolhapure

How I “Vibe-Coded” a Self-Healing Vector Engine for MongoDB in One Weekend

Akshay Kolhapure — Fri, 06 Mar 2026 08:53:08 +0000

As a software engineer with nearly a decade of experience, I’ve spent thousands of hours manually typing every semicolon and crafting every database schema. But last weekend, I decided to try something radical. I wanted to see if I could build a production-ready, enterprise-grade SDK by focusing purely on vision, architecture, and testing, while letting AI handle the heavy lifting of syntax.

The result? @manasdb/core is now live on NPM.

The Problem: RAG is Brittle and Expensive

If you’ve built Retrieval-Augmented Generation (RAG) applications with MongoDB, you’ve likely hit these three walls:

The Context Gap: Traditional vector search returns isolated sentences. When you feed these fragments to an LLM, it loses the “big picture,” leading to hallucinations.
The “Dimension Crash”: Switch your embedding model from OpenAI to Gemini, and your entire Vector Index crashes because of a dimension mismatch.
The PII Leak: Sensitive data (emails, credit cards) accidentally hitting external LLM APIs because implementing robust scrubbing is a tedious manual task.

I had the architectural blueprints to fix this, but I didn’t want to spend three weeks writing the boilerplate.

The Workflow: Architecture First, Syntax Second

Using Google’s Antigravity IDE, I adopted a “Vibe Coding” workflow. This isn’t “lazy coding” – it is high-speed orchestration. As an experienced engineer, I guided the AI through 8 distinct development plans:

The Intent: I defined the “Context-Healer” protocol (Parent-Child linking).
The Generation: I let the AI implement the complex MongoDB aggregation pipelines and the cryptographic hashing for deduplication.
The Rigorous Test: This is where the “Engineer” in me took over. I didn’t trust the AI’s code; I tested the output. I ran stress tests on 50-page PDFs to ensure that a search for a tiny detail would “heal” into a full, relevant paragraph for the LLM.

What is ManasDB?

ManasDB isn’t just another database wrapper. It’s an intelligence layer that sits on top of your MongoDB (Atlas or Self-Hosted 8.2+).

Subscribe to the Medium newsletter
| Feature | The Developer “Vibe” |

| – -| – -|

| Self-Healing | Automatically falls back to keyword search if vectors fail. |

| PII Shield | Native redaction of emails/secrets before they hit the cloud. |

| ROI Tracking | A CLI (npx manas stats) that proves your cost savings. |

| Context Healer | Parent-Child logic that ensures your LLM never loses the plot. |

The Lesson: The Architect is the New Coder

The biggest takeaway from this project? In 2026, being a software engineer is becoming less about being a “syntax expert” and more about being a Systems Architect.

Because I knew how a Vector DB should behave and what pain points developers face regarding costs and privacy, I could guide the AI to build a tool that solves real-world problems. I spent 10% of my time prompting and 90% of my time testing edge cases – like ensuring a 768-D query doesn’t crash a 1536-D index.

Try it out

If you’re tired of brittle vector setups and want a memory layer that just works, give ManasDB a spin. It’s open-source, lightweight, and takes just 5 lines to integrate.

npm install @manasdb/core

Github link: https://github.com/manasdb/manasdb

NPM link: https://www.npmjs.com/package/@manasdb/core

I’m curious – are you still writing every line by hand, or have you started “vibe coding” your infrastructure yet? Let’s discuss in the comments.

Stop reading stack traces — this tool explains them

Akshay Kolhapure — Thu, 19 Feb 2026 08:02:25 +0000

Hi devs 👋

I built a small open-source library called whylog.

It’s not another logger — it’s a runtime diagnostic engine that explains WHY your app crashed.

Instead of this:

Error: Cannot find module...

You get:

✔ Clear explanation
✔ Source snippet
✔ Fix suggestions
✔ Clean stack trace
✔ JSON output for production

Works in Node, serverless functions, and browser environments.

Install:
npm install whylog

Usage:
import "whylog/register"

I’d love feedback, ideas, or real-world error cases to improve heuristics.

GitHub: https://github.com/kolhapureakshay/whylog
npm: https://www.npmjs.com/package/whylog

Demo:
Before:

After using "whylog" library:

I Built an Open-Source Authentication Engine for Node.js (with the Help of AI)

Akshay Kolhapure — Mon, 09 Feb 2026 22:05:59 +0000

Authentication is one of those things that looks simple until you try to run it in production.

JWT-based authentication is everywhere in the Node.js ecosystem, but after working on multiple real-world backend systems, I kept facing the same recurring issue:

JWT libraries are excellent at creating and verifying tokens —
but they stop short when it comes to session management.

Production systems need much more than stateless tokens.

They need:

Session awareness
Refresh token rotation
Token revocation (“logout all devices”)
Device & IP tracking
Rate limiting against brute-force attacks
Extensibility for future security needs

That gap is what led me to build Smart Auth Engine.

🔐 What Is Smart Auth Engine?

Smart Auth Engine is an open-source authentication engine for Node.js and TypeScript, built on top of JWT but designed with stateful session intelligence.

📦 npm: https://www.npmjs.com/package/smart-auth-engine
💻 GitHub: https://github.com/kolhapureakshay/smart-auth-engine

Instead of treating authentication as “just token generation”, it treats auth as backend infrastructure.

🧠 The Core Idea: JWT + Session Intelligence

JWTs are powerful, but on their own they are:

Stateless
Hard to revoke
Blind to device and session context

Smart Auth Engine layers session tracking on top of JWT, enabling:

Multiple sessions per user
Secure refresh token rotation
Immediate session revocation
Device & IP visibility
Safer long-lived authentication

This approach gives you the scalability of JWT with the control of session-based auth.

✨ Key Features

Smart Auth Engine currently provides:

✅ Stateful session management on top of JWT
🔁 Refresh token rotation with replay-attack detection
🧠 Session intelligence (device + IP tracking)
🔐 Role-Based Access Control (RBAC) middleware
🚦 Rate limiting utilities for login protection
🔌 Pluggable storage adapters (In-memory, Redis)
🧩 Modular architecture with event bus & plugins
💙 TypeScript-first API with strong typings

All features are fully open-source and self-hostable.

🏗️ Why I Built This Instead of Using Existing Libraries

Most existing Node.js authentication libraries focus on:

Token creation
Token verification

But real backend systems need:

Session lifecycle control
Safer refresh token handling
Clean extensibility
Framework-agnostic design

I wanted:

Something I’d trust in production
A clean foundation for future security features (MFA, OAuth)
A modular system that grows with the application

Smart Auth Engine is the result of that mindset.

🤖 How AI Helped During Development

While building Smart Auth Engine, I used AI tools to:

Explore and validate architectural approaches
Review security patterns and edge cases
Improve documentation clarity
Speed up repetitive development tasks

AI didn’t replace engineering judgment —
it amplified productivity and design thinking.

The final decisions around security, architecture, and API design were always deliberate and manual.

🧠 Open-Source First Philosophy

Smart Auth Engine follows an open-core, developer-first philosophy:

✔ All core authentication features are open-source
✔ No artificial feature locking
✔ Fully transparent and self-hostable
✔ Designed for extensibility and long-term growth

If commercial offerings ever exist, they would focus on hosted services and tooling, not core authentication logic.

Developer trust matters.

⚠️ Project Status

Smart Auth Engine is currently at v0.1.0.

That means:

APIs may evolve
Feedback is highly encouraged
Real-world usage will shape future releases

The goal right now is learning and validation, not hype.

🛣️ What’s Coming Next

Some planned directions:

Fastify and NestJS adapters
OAuth / social login support
Multi-factor authentication (MFA)
Additional storage adapters
More real-world examples

🙌 Feedback Welcome

If you:

Build Node.js backends
Work with JWT, authentication, or session management
Care about secure and scalable auth design

I’d love your feedback:

Does this solve a real problem for you?
What would you expect from an auth engine?
What should come next?

🔗 Links

📦 npm: https://www.npmjs.com/package/smart-auth-engine
💻 GitHub: https://github.com/kolhapureakshay/smart-auth-engine

If you find it useful, a ⭐ on GitHub helps a lot.

Thanks for reading — and happy building 👋