DEV Community: Ayan pal

Architecture Breakdown: Building an Enterprise-Grade Legal RAG System (From Ingestion to RAGAS Evaluation)

Ayan pal — Sun, 07 Jun 2026 05:00:49 +0000

Hey Devs! 👋

Building a Retrieval-Augmented Generation (RAG) system for standard Q&A is relatively straightforward. But when you move into the legal domain, standard setups fall apart. Accuracy isn't a vanity metric here—hallucinations can have actual legal consequences, and citations are non-negotiable.

I recently mapped out and built an end-to-end architecture for a Legal RAG System designed to handle complex legal documents with high precision. Here is the architectural blueprint and stack breakdown.

🛠️ The Stack & Phase Breakdown
Phase 1–2: The Heavy-Lifting Data Pipeline
Document Ingestion: Handling raw PDFs, DOCX, and TXT files. Legal documents are notoriously long and structurally dense.

Preprocessing: Simple character splitting won't cut it. We implement smart chunking strategies alongside a deduplication layer to keep the index clean.

Metadata Extraction: Extracting deterministic fields (Date, Court, Jurisdiction) during ingestion. This is crucial for hybrid filtering later.

Phase 3: The Multi-Tier Vector Store & Embedding Core
Raw Storage: AWS S3 handles the absolute source of truth for raw files.

Local Prototyping & Hybrid Cloud Vector Indexing: We run ChromaDB locally for rapid development and testing, while routing to Pinecone in production for scalable, cloud-native vector search.

The Retrieval Engine: Moving past simple dense embeddings. We utilize a hybrid approach combining OpenAI's text-embedding-ada-002 (or open-source sentence-transformers) with BM25 keyword search for precise lexical matching on legal jargon.

Phase 4: RAG Chain & Continuous Evaluation
LangChain Integration: Orchestrates the retrieval, prompt injection, context window management, and crucially, enforcing source citations in the final LLM output.

Evaluation via RAGAS: You can't improve what you don't measure. We use the RAGAS framework to programmatically calculate scores for Faithfulness (groundedness), Answer Relevancy, and Context Precision@k.

Phase 5–6: API, UI, and Deployment
Backend: FastAPI exposes clean asynchronous endpoints like /upload for ingestion, /query for RAG interaction, and /health for monitoring.

Frontend: A minimal, responsive Streamlit dashboard tailored for legal professionals, featuring a clean Chat UI, inline citations, and confidence scoring.

DevOps: The entire system is containerized via Docker, deployed on AWS EC2 (and mirrored on Hugging Face Spaces for staging), documented thoroughly with an automated Loom walkthrough.

🧠 Key Takeaways from the Build
Hybrid Search is Mandatory: Dense vectors catch semantic meaning, but BM25 catches exact statute numbers and specific legal terms. You need both.

Evaluate Early: Setting up RAGAS pipelines on Day 1 prevents you from guessing whether a prompt tweak actually improved the model or just made it sound better.

What does your production RAG stack look like? Are you favoring local vector stores like Chroma/Qdrant or going straight to cloud-native solutions like Pinecone/Milvus? Let's discuss in the comments!

ai #rag #llm #python #architecture #fastapi

🚀 Beyond the Buzzwords: Is "Vibe Coding" the Future of Mastering Data Science?

Ayan pal — Sat, 30 May 2026 15:40:20 +0000

As developers and tech enthusiasts, we’ve all seen the explosion of AI-accelerated development tools. From GitHub Copilot to Cursor, the way we write code is shifting from manual syntax-wrangling to high-level architecture and intent. Some call it AI engineering—others are calling it Vibe Coding.

If you've been wondering how to actually leverage this shift to break into Data Science and AI/ML engineering without drowning in traditional bootcamp models, I recently came across a modern learning ecosystem that completely embraces this methodology: Data Science & AI Bootcamps via Vercel.

Here is a breakdown of what this approach looks like, why it works, and how it’s reshaping how modern tech stacks are taught.

🤔 What Exactly is "Vibe Coding" in Data Science?
Traditional bootcamps often spend the first 6 weeks forcing you to memorize Python syntax errors or struggle with the boilerplate setup of a local environment.

Vibe Coding flips the script. It focuses on high-level intuition, structural logic, and using modern AI tooling to handle the mundane syntax. This allows learners to instantly dive into what actually matters: architecting intelligent systems, reading data signals, and deploying production-ready ML pipelines.

Instead of passive lecture videos, the focus shifts to real-time interactive development

🛠️ The Tech Stack You Actually Need
A modern data science roadmap shouldn't just stop at a Jupyter notebook running locally on your laptop. To stand out to recruiters, you need to know how models exist in the wild.

The core curriculum of this modern approach bridges the gap between raw data and scalable production:

- Data Wrangling & Analytics: Python, SQL, NumPy, Pandas, Seaborn
Business Intelligence: Power BI & Tableau (turning raw telemetry into stakeholder-ready dashboards)
Core ML & Computer Vision: Scikit-Learn, OpenCV The AI
Frontier: Deep Learning, NLP, LangChain, RAG (Retrieval-Augmented Generation), and Hugging Face
MLOps & Cloud Deployment: AWS SageMaker, Google Cloud AI, Azure ML Studio, Docker, and Kubernetes

🏗️ Portfolio-Driven Learning: Move Past the "Titanic Dataset"
If I see one more resume with the Titanic Survival Dataset or the Iris Flower Classification, I might lose my mind—and modern recruiters feel the exact same way.

To bridge this gap, this ecosystem focuses on building 25+ next-generation projects that mirror real-world industry demands. Think less "academic math homework" and more "scalable AI infrastructure":

1. Multimodal AI Chatbots: Integrating voice, text, and contextual RAG workflows.
Autonomous Vehicle Sensor Processing: Using Computer Vision to interpret spatial data.
Agentic Cyber Defense Honeypots: Simulating realistic target behavior using intelligent AI models to track and flag malicious activity.
Climate & Financial Forecasting Platforms: Deep-diving into predictive analytics and time-series pipelines

⚡ Production-First Architecture
One of the biggest pitfalls for data science beginners is the "it works on my machine" syndrome. Moving a model from a local environment to a live endpoint is where most fail.

The methodology highlighted here leans heavily on deploying ML models directly to cloud infrastructure (AWS, GCP, Azure) alongside modern application platforms like Vercel and Heroku. By containerizing models with Docker, you graduate from being a statistical analyst to a true Full-Stack AI Engineer

📈 The Outcomes
The shift toward AI-assisted, high-intuition learning isn't just about making coding "easier"—it’s about speed-to-market for your career.

Accelerated Placement: Skipping the syntax hurdles means getting to complex system designs faster.

AI-Optimized Profiles: Focusing heavily on building out a GitHub portfolio, open-source contributions, and AI-optimized resumes that actually bypass ATS systems.

💬 Let's Discuss!
Have you experimented with AI-assisted development or "Vibe Coding" in your data pipelines? Do you think abstracting the boilerplate code helps beginners grasp data engineering concepts faster, or do you still swear by the traditional "learn the hard way" approach?

Drop your thoughts in the comments below! 👇

[https://datascience-projects.vercel.app/]

How We Built an AI Candidate Screening System That Actually Explains Itself

Ayan pal — Thu, 28 May 2026 04:51:18 +0000

I'm building ATSFy — an AI-powered hiring platform from Northeast India. This post is about the design decisions behind our candidate screening feature, specifically around explainability and scoring transparency.

The problem with most ATS scoring

Most applicant tracking systems rank by keyword density. Feed a JD into the system, get a match percentage back. No reasoning. No breakdown. No way to audit why Candidate A scored 87% and Candidate B scored 63%.

That's not explainable AI. That's a black box with a confidence score painted on it.

We wanted to do better.

What we built

ATSFy's screening system takes a job description and a set of resumes (PDF, DOCX, TXT — bulk supported), runs them through a Claude-powered evaluation pipeline, and returns a ranked candidate list scored across four SHRM-aligned dimensions:

Technical Fit      →  Does the skills profile match the role?
Experience Depth   →  How relevant is their career history?
Education Match    →  Does the background meet requirements?
Cultural Alignment →  Values and working style signals

Each dimension is scored independently, then combined into a weighted composite out of 100.

The transparency layer

Here's the part I'm most proud of.

Every skill tag on a candidate profile is marked:

✅ Checkmark = explicitly found in the resume
ℹ️ Info icon = inferred from context

So if the JD requires Kubernetes experience and the resume mentions "led containerised infrastructure migrations at scale," the system might infer K8s familiarity — but it marks it as inferred, not verified. The recruiter sees the distinction.

Same with the reasoning summary. Every candidate gets one line:

"Led K8s migration cutting cloud spend 38% — direct fit for platform mandate."

This isn't generated fluff. It's the system's most defensible evidence for the score, pulled from the resume.

Why this matters for AI in hiring

There's real regulatory pressure coming around AI in recruitment — particularly around transparency and explainability. The EU AI Act classifies automated hiring decisions as high-risk. Explainability isn't just a nice-to-have; it's going to be a legal requirement.

Building transparency into the core scoring logic now means we're compliant-by-design, not compliant-by-retrofit.

Stack

We're built on TypeScript + React + Vite on the frontend, Node.js + Express on the backend, Claude API for the evaluation pipeline, and Neon (PostgreSQL) for persistence. Deployed on Vercel.

What's next

We're iterating fast. Currently working on:

Bias audit flags per candidate evaluation
Weighted scoring customisation by role type
Explainability report PDF export for regulated industries

If you're building in HR Tech or AI evaluation systems, I'd love to compare notes. Drop a comment below.

— Ayan, Founder @ ATSFy Technologies, Agartala

I Built a Free Interactive GitHub Learning Platform — Web Guide + Terminal Guide + Git Reference + CLI Sandbox

Ayan pal — Wed, 27 May 2026 03:39:48 +0000

TL;DR
I built and deployed a free browser-based GitHub learning app with three modes — Web Guide, Terminal Guide, and Git Reference — plus an interactive CLI Sandbox that simulates real Git file state transitions.
🔗 Live: github-onboarding-tutorial.vercel.app

Why I Built This
Git has a reputation for being confusing. Not because the commands are hard to type, but because the mental model is hard to visualize.

What's the difference between staging and committing?
What does "origin" actually mean?
Why does git pull sometimes create a merge commit?

Most resources answer these with text. I wanted to answer them with interaction.

What's Inside
Web Guide — 11 Steps
A visual walkthrough for beginners. Starting from visiting GitHub.com and creating an account, all the way through setting up your profile and understanding the GitHub interface. No terminal required.
Terminal Guide — 16 Steps
A CLI-first learning path. Covers:

Installing GitHub CLI (gh)
Running the login command
Selecting GitHub.com as host
Choosing authentication protocol
Authenticating via browser
Copying the one-time code
Authorizing in browser
Configuring Git identity
Verifying the connection
Cloning a repository
Creating a new branch
Staging and committing
...and more through step 16

Each step has the exact terminal command, a PRO TIP, and Next/Back navigation.
Git Reference — 25 Commands
A searchable Git command encyclopedia. Categories:
CategoryCommandsSetup & Config4Daily Work5Branches & Merging6Team Collaboration4Fix Mistakes3Advanced Tools3
Each command page has:

Functional description
Standard syntax with terminal block
Area Operations Visualizer (which zones does this command touch?)
File State Transition explanation

CLI Sandbox
The crown jewel. An embedded terminal where you type real Git commands and watch simulated file state changes happen live across four zones:
┌─────────────┐ ┌──────────────┐ ┌────────────────┐ ┌─────────────┐
│ WORKSPACE │ → │ STAGING AREA │ → │ LOCAL REPOSITORY│ → │ REMOTE REPO │
│ (Unsaved) │ │ (Index) │ │(Commits History)│ │(GitHub Cloud│
└─────────────┘ └──────────────┘ └────────────────┘ └─────────────┘
Quick Execution Recipes let you run one-click command trials like git init, git add, git commit.

Tech Stack
Framework: React + TypeScript
Styling: Tailwind CSS
Deployment: Vercel

What's Next
Planning to add:

Progress saving via localStorage
Quiz checkpoints every 5 steps
.gitignore setup guide
Pull Request workflow steps
SSH key setup alternative path

Try It / Contribute
🔗 Live app: github-onboarding-tutorial.vercel.app
Drop feedback in the comments. If there's interest, I'll open-source the repo.

I built a hyperlocal telehealth coordination platform — full clinician dashboard, patient gateway & geospatial routing

Ayan pal — Mon, 25 May 2026 14:27:00 +0000

TeleHealth Connect is a near-production-ready Next.js telehealth infrastructure platform built for real-time doctor-patient coordination. Here's what I shipped, how it works, and what's left before production.

The problem I was solving:

Healthcare in Tier 2 and Tier 3 India — especially the Northeast — has a coordination gap, not just a resource gap. Doctors exist. Patients exist. What's missing is structured real-time infrastructure to route the right clinician to the right patient at the right time, especially in hyperlocal geographies.

Most telehealth products are built for metros. I wanted to build something proximity-aware, operationally structured, and deployable in lower-connectivity regions — a platform any healthcare provider or district health team could white-label and deploy.

What's inside the platform
Patient gateway
Symptom submission, consultation requests, multimedia upload support
Clinician dashboard
Patient queue management, consultation workflows, routing interface
Hyperlocal routing
Proximity-based doctor routing with geospatial case allocation
Workflow system
Structured consultation lifecycle with queue and patient workflow handling
Privacy-first arch
Local-first persistence, compartmentalized workflows, minimal central dependency
Responsive UI
Fully mobile-responsive across patient and clinician surfaces
Tech stack
Next.js
React
TypeScript
Tailwind CSS
Vercel
Firebase (ready)

The architecture is Firebase-ready — the persistence and auth layers are scaffolded but not yet connected to a production backend. This was intentional: the MVP is UI-complete and deployment-ready so any health org can wire in their own Firebase project with minimal configuration.

Geospatial routing — the interesting bit
The hyperlocal routing engine is what differentiates this from a generic telehealth template. Rather than global queuing, the system uses proximity-aware case allocation — incoming patient cases are routed dynamically to clinicians based on geographic proximity and current queue load. This matters significantly in district-level healthcare deployments where a "nearest available doctor" model is the operational norm.

The routing architecture is modular, so it can be extended with additional signals — specialisation matching, language preference, historical outcomes — without restructuring the core workflow engine.

Building ATSfy: My Journey Creating an AI-Powered Career Intelligence Platform

Ayan pal — Tue, 19 May 2026 10:39:03 +0000

Building ATSfy taught me something important:

Most people don’t fail because they lack talent.
They fail because opportunity is fragmented.

Resumes. ATS systems. Skill gaps. Job platforms. AI tools.
Everything exists separately.

So I started building ATSfy — an AI-powered Career Intelligence Platform designed to make hiring, career growth, and opportunity navigation smarter.

What started as an idea in Tripura is now growing into something much bigger.

Currently working across:
• AI-powered resume intelligence
• Career recommendation systems
• Hiring optimization
• AI automation workflows
• Product ecosystems for employability

As a founder, the hardest part hasn’t been coding.

It’s:

building consistency
learning distribution
handling uncertainty
shipping despite imperfection

But that’s also where the growth happens.

I’m documenting the journey publicly while building in AI, MedTech, EdTech, and GreenTech ecosystems.

Would love to connect with:

developers
startup founders
AI builders
open-source contributors
people building meaningful tech from underrated regions

The future of innovation won’t come from only Silicon Valley.

It’ll come from everywhere. 🚀