DEV Community: Ansuj Kumar Meher

My Git History Called Me a Rage Coder (And Then Explained Why)

Ansuj Kumar Meher — Mon, 13 Jul 2026 10:37:57 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

I ran it on my own repo before anyone else's, and it did not go easy on me. StreamSync — 116 commits — got filed as a "Rage Coder," 35% of my commit messages apparently reading like the transcript of a bad night. The AI wasn't being generous about it, either.

Commit Confessions takes a public GitHub repo and reads its commit history back to you like a confession — not a dashboard, not a wrapped-style stat card, an actual short piece of writing that cites your real commit messages, your real busiest hour, your real longest streak, and tells you what it thinks that says about you.

Paste in a repo, and it:

Pulls up to 300 commits and works out when you actually code — hour by hour, weekends vs. weekdays, your longest streak, your longest disappearing act, and how often your commit messages sound like you were mid-crisis
Assigns you a developer persona and a D&D-style alignment based on that behavior, not a random quiz
Has Gemini write a genuinely specific narrative about it — one that has to cite real detail from your data or it doesn't count
Narrates that out loud with a documentary-grade ElevenLabs voice over a low atmospheric loop
Generates a shareable card with AI cover art that's actually read your README, plus a constellation pattern built from your real commit punchcard
If you want proof, mints the whole thing as a permanent, free memo transaction on Solana Devnet — a receipt that this repo, this obsession, existed

It's built to be run on your own repos first. It's more fun, and slightly more brutal, than you'd expect.

Demo

Live: commit-confession.vercel.app

ANSUJKMEHER / Commit-Confession

Commit Confessions

Your git history, read back to you like a confession.

Feed it a public GitHub repo. It pulls the commit history — timestamps, streaks, late-night patterns, message samples — and sends the data through Gemini to produce a short, honest narrative about the coding passion hiding in those commits. Optionally, ElevenLabs narrates it back like a movie trailer.

Built for DEV Weekend Challenge: Passion Edition (July 2026)

Live Demo

→ commit-confessions.vercel.app

How it works

GitHub REST API  →  pattern analysis  →  Gemini 2.0 Flash  →  narrative
                                                     ↘  ElevenLabs (optional voiceover)

GitHub API: fetches up to 300 commits (no auth needed for public repos, but adding a token raises the rate limit from 60 to 5,000 requests/hr)
api/analyze.js (Vercel serverless): computes stats — hourly distribution, late-night %, weekend %, streak/gap lengths, sample messages — then calls Gemini
Gemini 2.0 Flash: one well-crafted prompt → { title, narrative,…

View on GitHub

Good repos to try it on: your own (obviously), torvalds/linux if you want to see what 50,000+ commits of late-night density looks like, or antirez/redis for a solo project with genuinely vivid commit messages.

Code

ANSUJKMEHER / Commit-Confession

Commit Confessions

Your git history, read back to you like a confession.

Built for DEV Weekend Challenge: Passion Edition (July 2026)

Live Demo

→ commit-confessions.vercel.app

How it works

GitHub REST API  →  pattern analysis  →  Gemini 2.0 Flash  →  narrative
                                                     ↘  ElevenLabs (optional voiceover)

GitHub API: fetches up to 300 commits (no auth needed for public repos, but adding a token raises the rate limit from 60 to 5,000 requests/hr)
api/analyze.js (Vercel serverless): computes stats — hourly distribution, late-night %, weekend %, streak/gap lengths, sample messages — then calls Gemini
Gemini 2.0 Flash: one well-crafted prompt → { title, narrative,…

View on GitHub

How I Built It

The shape of it

React + Vite on the frontend, three serverless functions doing the actual work, GitHub's REST API as the only real data dependency. No database — there's nothing to persist, every confession is generated fresh.

Reading a repo like a diary

The stats engine pulls up to 300 commits and turns raw timestamps and messages into something with a shape: an hourly distribution, a full week × hour punchcard, late-night and weekend percentages, longest streak, longest gap, and a "rage score" — a regex pass over every commit message hunting for fix, revert, wtf, stupid, please, and their friends. Whichever persona (Night Owl, Rage Coder, Weekend Warrior, and four others) scores highest on the resulting weighted formula wins, and the same numbers feed a D&D-style alignment — Chaotic Evil, for the record, requires late nights over 25%, weekends over 20%, and a rage score over 15%. You know who you are.

The part I actually care about is what happens next: that data, plus the first 1,500 characters of the repo's README and a sample of real commit messages, gets handed to Gemini with a prompt that's less "write something nice" and more "write something true." It has to cite at least three specific details — an exact commit message, the exact busiest hour, the exact streak length — and it's explicitly told to avoid every hackathon-blurb cliché ("shows dedication," "journey of growth"). The output comes back as structured JSON — title, narrative, verdict, and an image prompt — with a three-model fallback chain (gemini-2.5-flash → gemini-2.0-flash → gemini-2.0-flash-lite) so a quota limit on one model doesn't take the whole thing down.

The README-awareness is what I'm most pleased with: because Gemini actually reads what the project is for, the generated cover-art prompt describes something specific to it — glowing cursors on a shared document for a collaborative editor, not generic circuit-board stock art.

Giving it a voice

The narrative gets narrated back through ElevenLabs' eleven_flash_v2_5 model with a deep documentary-narrator voice, an atmospheric urban loop fading in underneath at low volume and pausing itself when the narration ends. On mobile, the audio and the share card get bundled together as actual File objects through the Web Share API, so a confession can go straight to WhatsApp or LinkedIn with both attached — not just a link.

The part where I deleted a dependency

The most interesting engineering decision here wasn't a feature — it was a removal. I wanted an on-chain "proof of passion": mint a small, free, permanent record of your stats on Solana Devnet. The standard way to do that is @solana/web3.js, and @solana/web3.js does not want to run inside a Vercel serverless function — its WebSocket bindings and circular dependencies crashed the bundler with a 500 error four different ways before I stopped trying to fix the import and just took the SDK out entirely.

What's left is 279 lines that only use what Node already has. Ed25519 signing through the native crypto module, with a hand-wrapped PKCS#8 DER header around the raw key. A 50-line Base58 encoder I wrote because I didn't want to pull in a package for it. The Solana transaction format — header, account keys, blockhash, instructions, compact-u16 length prefixes — serialized byte by byte, by hand. Everything talks to Devnet through plain fetch calls to the JSON-RPC endpoint. Zero dependencies, instant cold starts, a transaction confirmed in under three seconds.

The user never sees any of this. They click one button and get back a Solscan link to a memo transaction that just says, permanently: this repo, these stats, this moment, happened.

Making it look like it means it

Dark, editorial, a little moody — Fraunces serif for anything the app is "saying" to you, JetBrains Mono for anything that's raw data, amber for the late-night hours everywhere they show up: the commit clock's ticks, the verdict text, the glow behind the persona. The commit clock itself is a D3 radial chart, one tick per hour, length proportional to commit count, animating in over about a second the first time you see your result. The share card layers persona, stats, verdict, AI cover art, and a constellation pattern generated from your actual punchcard data — real commit hours turned into stars, connected if they're close enough together. Four theme variants, if the default doesn't match your vibe.

Prize Categories

Best Use of Google AI — Gemini 2.5 Flash is the narrative engine, the persona/alignment writer, and the image-prompt generator, all off one README-aware, structured-JSON call with a three-model fallback for quota safety.

Best Use of ElevenLabs — eleven_flash_v2_5 turns the narrative into a genuinely cinematic narration, layered with ambient audio and bundled straight into native share sheets alongside the visual card.

Best Use of Solana — A real Devnet memo transaction, built and signed without @solana/web3.js after it broke the serverless bundler — native crypto, hand-written Base58, manual transaction serialization, confirmed in under three seconds, with zero wallet friction for the end user.

Built solo, over a weekend that — appropriately enough — involved several of the exact behaviors this tool now measures.

If you run it on your own repo, I want to know what it calls you. Drop your persona and your worst commit message in the comments — I'll go first: Rage Coder, 35%, no regrets.

I Built an AI Interview Coach That Turns Any Resume Into a Personalized Prep Package — No API Keys Needed

Ansuj Kumar Meher — Sun, 31 May 2026 06:10:19 +0000

This is a submission for the Hermes Agent Challenge

What I Built

Interview preparation is broken. You Google "top 50 interview questions," get a wall of generic prompts that have nothing to do with your background, and somehow you're supposed to feel prepared. If you've built real-time chat systems with Socket.io and trained CNNs with TensorFlow, why are you practicing questions about linked lists and nothing else?

I built AI Interview Coach — a full-stack web application that takes your resume PDF and produces a complete, personalized interview preparation package in under five seconds.

Here's what happens when you upload a resume:

Resume Score (out of 10) — Your resume is scored across five dimensions: Formatting & Readability, Content Completeness, Skills Relevance, Experience Impact, and Education & Certs. Each dimension gets a score, a color-coded progress bar, and specific notes explaining the rating.
Skills Summary — The engine auto-detects technologies from your resume and groups them into categories: Languages, Frameworks, ML & AI, Cloud & DevOps, Databases, and Tools & Practices. It scans against 90+ technology keywords.
20 Technical Interview Questions — These are generated based on what's actually on your resume. If you list TensorFlow, you'll get questions about batch normalization and vanishing gradients. If you list React, you'll get questions about useEffect dependency arrays and virtualization. Each question includes a "why" explanation connecting it to something specific on your resume.
10 HR & Behavioral Questions — Adapted based on whether you're a student, have internship experience, show leadership signals, or have multiple projects. Each comes with a STAR-method framing tip.
Improvement Suggestions — Prioritized into High, Medium, and Low buckets. Things like "Quantify your achievements" or "Add certifications" — not vague advice, but specific actions mapped to scoring gaps.

The entire thing runs locally. No OpenAI key. No GPT calls. No cost per request. No data leaves your machine.

Why does this matter? Because most interview prep tools either cost money, require API keys, or give you the same generic output regardless of your background. This one is free, private, and genuinely personalized.

Demo

📹 Video Walkthrough:

Upload Zone — Drag & drop your resume PDF:

Resume Score — Circular indicator + five-dimension breakdown:

Skills Summary — Auto-detected technologies grouped by category:

Technical Questions — Searchable, filterable, with difficulty badges:

HR Questions — Category-tagged with STAR-method tips:

Improvement Suggestions — Prioritized by impact:

Analysis engine output — scores, skills, and tailored questions in the terminal:

Code

ANSUJKMEHER / Interview-Coach-App

AI Interview Coach

A full-stack web application that analyzes resumes and generates personalized interview preparation packages. Built with React + Express for the Hermes Agent Challenge.

Overview

Upload a resume PDF and instantly receive:

Resume Score — rated across 5 dimensions (formatting, completeness, skills relevance, experience impact, education)
Skills Summary — auto-detected and grouped by category
20 Technical Interview Questions — tailored to your actual skills and projects
10 HR / Behavioral Questions — with STAR-method framing tips
Improvement Suggestions — prioritized by impact

No API keys or external services required. Everything runs locally.

Architecture

interview-coach-app/
├── backend/
│   ├── server.js              # Express server — upload handling, analysis engine
│   ├── package.json           # Dependencies: express, multer, cors
│   └── tmp/                   # Temp directory for PDF processing
├── frontend/
│   ├── src/
│   │   ├── App.jsx            # Main app — theme toggle, upload, results orchestration
│   │   ├── main.jsx           # React

…

View on GitHub

My Tech Stack

Frontend:

React 18 — Functional components with hooks (useState, useRef, useCallback). Five purpose-built components: FileUpload, ResumeScore, SkillsSummary, QuestionsList, and Suggestions.
Vite 5 — Dev server with API proxy to the backend, plus production builds served directly by Express.
CSS Custom Properties — A complete dark and light theme system with 25+ CSS variables. No Tailwind, no CSS framework — every style is hand-written with transitions for smooth theme switching.

Backend:

Node.js + Express 4 — Handles file uploads via Multer (disk storage, PDF-only filter, 10MB limit), spawns the Python extraction process, runs the analysis engine, and serves the built frontend in production.
Custom request logger — Every request gets a unique ID and timing for debugging.

PDF Extraction:

Python 3 + pymupdf — Extracts raw text from PDF resumes with proper Unicode handling. The script outputs structured JSON including page-level text, page count, and document metadata.

Analysis Engine:

A custom rule-based engine written entirely in JavaScript — no external API calls. It includes:
- A multi-dimensional scoring system with regex-based pattern matching
- Skill extraction across 90+ technology keywords organized into 6 categories
- Conditional question generation with 30+ templates spanning Deep Learning, NLP, Computer Vision, React, Node.js, Databases, Cloud, Security, and more
- HR question adaptation based on inferred career stage
- Priority-ranked improvement suggestions mapped to scoring gaps

Build & Dev Tooling:

Vite for frontend bundling
Express serves the production build from frontend/dist/
uv for Python virtual environment and dependency management

How I Used Hermes Agent

Hermes Agent was involved at every stage of building this project — not as a magic "generate my app" button, but as a collaborative development partner that I could iterate with in real time.

Architecture Decisions

The first thing I worked through with Hermes was the fundamental architecture question: should the analysis engine call an external LLM, or should it be rule-based?

Hermes helped me reason through the tradeoffs. An LLM-based approach would generate more varied questions, but it would require API keys (friction for users), add latency (seconds per request), introduce cost (real money per upload), and make the output non-deterministic. Hermes helped me design a rule-based engine that's fast, free, deterministic, and transparent. Every score has an explanation. Every question has a "why."

Hermes also helped me decide on the three-layer architecture — React frontend, Express backend, Python extraction subprocess. The alternative was doing PDF extraction in Node.js, but Hermes pointed out that pymupdf has significantly better handling of ligatures, embedded fonts, and Unicode edge cases compared to the Node.js PDF libraries available.

Here's Hermes planning the approach and setting up the Python environment:

Implementation: The Analysis Engine

Hermes scaffolded all 16 source files, installed dependencies, and verified the frontend build — all in a single session:

The heart of the application is the analyzeResume() function in server.js — around 300 lines of scoring, extraction, and question generation logic. Hermes helped me build this incrementally.

For the scoring system, I started with a basic keyword count approach, but Hermes helped me evolve it into a five-dimension model. Take the Experience Impact dimension:

let impact = 3;
if (/\d+%/.test(text)) impact += 2;
if (/\d+\+ (users|requests|events|bugs|projects|modules)/i.test(text)) impact += 1.5;
if (/reduced|improved|increased|optimized|accelerated/i.test(text)) impact += 1.5;
if (/led|owned|driven|spearheaded|initiated/i.test(text)) impact += 1;
if (/\d+K\+|\d+M\+|\d+TB|\$[\d,]+/i.test(text)) impact += 1;
impact = Math.min(Math.round(impact), 10);

Hermes helped me identify which regex patterns actually correlate with strong resumes — looking for quantified achievements, scale indicators, and action verbs that signal ownership. We iterated on the weights until the scores felt calibrated against real resumes.

For question generation, Hermes helped me design the conditional template system. Instead of random questions, each template is gated on what's actually in the resume:

if (has(["tensorflow","keras"])) {
  add("Deep Learning", "Hard",
    "You used transfer learning with MobileNetV2. Explain why you'd freeze early layers vs fine-tune them all.",
    "Your EarthSense-AI project used transfer learning — interviewers will probe the reasoning.");
}

This produces questions that reference the user's actual projects and explain why an interviewer would ask this. Hermes helped me write templates for 15+ technology areas.

Debugging: The Unicode Incident

The first real-world resume I uploaded crashed the app. The error:

UnicodeEncodeError: 'charmap' codec can't encode character '\ufb01'

That's the "fi" ligature — common in PDFs generated by LaTeX. On Windows, Python's default stdout uses cp1252 encoding, which doesn't support it.

Hermes immediately identified the root cause and proposed a two-layer fix. On the Node.js side, force the spawned Python process to use UTF-8:

const proc = spawn(pythonExe, [scriptPath, pdfPath, "--json"], {
  env: { ...process.env, PYTHONIOENCODING: "utf-8" },
});

On the Python side, wrap stdout if the console encoding isn't UTF-8:

if sys.stdout.encoding.casefold() != "utf-8":
    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")

This fixed the crash without losing any text content. Hermes knew exactly where to intervene because it understood both the Node.js child process API and Python's encoding stack.

Feature Refinement

Hermes drove several UX improvements that I wouldn't have prioritized on my own. Here's Hermes refactoring the FileUpload component to add progress tracking and cancel support — you can see the diff of what changed:

Duplicate detection — When multiple skill categories triggered similar questions, Hermes suggested the deduplication step with normalized comparison, then padding with fallback questions to guarantee exactly 20 technical and 10 HR.
AbortController integration — Hermes wired up the upload cancel button to actually abort the in-flight fetch request and clean up state, rather than just hiding the progress bar.
Export formatting — The "Download Report" feature generates a structured text file with headers, scores, and all questions. Hermes helped format the output so it reads well in any text editor.
CSS custom properties for theming — Instead of class-based theme switching, Hermes designed a CSS variable system with 25+ tokens that made adding the light theme a one-block-of-CSS addition rather than rewriting every component.

Development Velocity

Working with Hermes, I went from an empty directory to a functioning full-stack app in a single development session. The agent handled the scaffolding — Vite config, Express boilerplate, Multer setup — while I focused on the analysis logic and UI design decisions.

After writing the files, Hermes automatically verified the build and ran syntax checks before moving on:

When I hit the Unicode bug, Hermes fixed it in minutes rather than the hour I'd have spent reading Python encoding documentation. When I wanted to add search and filtering to the questions list, Hermes built the entire QuestionsList component with search, difficulty filter, topic filter, copy-per-question, and copy-all in one pass.

That's the real value: Hermes doesn't replace thinking, but it removes the friction between having an idea and seeing it work.

Technical Challenges

PDF Extraction Is Messier Than You Think

PDF is a page layout format, not a document format. Text inside a PDF can be fragmented across drawing commands, use arbitrary fonts with custom ligature tables, and contain Unicode characters that look normal on screen but break when piped through a process boundary. The "fi" ligature is just the most common offender — there are dozens more in PDFs generated by professional typesetting tools.

The fix required interventions at two layers: the Node.js process spawner (setting PYTHONIOENCODING) and the Python script itself (wrapping sys.stdout). A single-layer fix wouldn't have been robust.

Deduplication Without Losing Personality

When a resume lists React, Node.js, and TypeScript, the question generator might fire templates from the "React" bucket, the "Backend" bucket, and the "TypeScript" bucket — some of which produce overlapping questions. Simple string deduplication would miss near-duplicates, so I normalize the text (lowercase, collapse whitespace) before comparison:

function deduplicateQuestions(questions) {
  const seen = new Set();
  const result = [];
  for (const q of questions) {
    const key = q.question.trim().toLowerCase().replace(/\s+/g, " ");
    if (!seen.has(key)) {
      seen.add(key);
      result.push(q);
    }
  }
  return result;
}

After deduplication, I pad with fallback questions to guarantee the target count. The fallbacks are intentionally generic ("Describe a challenging bug you encountered") so they never feel redundant with the skill-specific ones.

Making a Rule-Based Engine Feel Intelligent

The hardest design challenge wasn't technical — it was making a rule-based system produce output that feels genuinely tailored rather than randomly selected. Three things made the difference:

Every question explains why it's being asked — "You have TensorFlow and Keras on your resume" or "Your EarthSense-AI project used transfer learning — interviewers will probe the reasoning." This transparency makes the output feel personalized even though it's template-driven.
HR questions adapt to career stage — The engine checks whether the text matches student patterns, internship signals, leadership keywords, or project count — and selects different question variants accordingly.
Suggestions map to scoring gaps — If the Experience Impact score is low, the suggestion to "Quantify your achievements" appears in the High Priority bucket. The suggestions aren't random — they're tied to the dimensions that scored weakest.

Frontend UX: Small Touches, Big Difference

Collapsible sections — Let you focus on what matters. When you're practicing technical questions, you don't need the suggestions panel open.
Search and filter on questions — Type a keyword, filter by difficulty (Easy, Medium, Hard), filter by topic (React, Databases, Security). The filter count updates in real time.
Copy to clipboard — Per question or all at once, useful for pasting into a study doc or sharing with a friend.
Progress simulation — The progress bar advances in random increments during the server round-trip, creating the feel of active processing rather than a dead spinner.

Lessons Learned

Rule-based doesn't mean dumb — A well-designed rule engine with good templates produces output that's consistent, explainable, and free. For structured tasks like scoring and question generation, you don't always need an LLM.
Cross-process encoding is a minefield — Node.js spawning Python on Windows has encoding assumptions at every layer: the child process environment, Python's stdout wrapper, and Node's buffer-to-string decoding. You need to control all of them.
Frontend polish is what separates a demo from a tool — Search, filter, copy, download, dark mode, collapsible sections — none of these are technically hard, but together they make the difference between "interesting prototype" and "I'd actually use this."
Error messages are user experience — Every error in this app tells you what went wrong and what to do: "Only PDF files are allowed," "File too large (max 10 MB)," "Could not extract meaningful text — it may be image-based." No stack traces in the browser.

Future Improvements

LLM-powered question generation — Integrate an optional local LLM (via Ollama or similar) to generate more varied, context-aware questions while keeping the API-free default.
Answer scaffolding — For each question, generate a starter answer outline based on the resume content.
Job description matching — Upload a job description alongside your resume and get a gap analysis: skills you have vs. skills they want, plus targeted questions for the gaps.
PDF report export — Generate a formatted PDF report instead of plain text, with the score visualization and color-coded question cards.
Session history — Save past analyses to localStorage so you can track how your resume improves over time.
ATS keyword checker — Compare your resume against common ATS keyword databases for specific job titles.

Conclusion

AI Interview Coach is a focused tool that solves a real problem: turning a generic resume PDF into a personalized interview preparation package — with scoring, skill extraction, tailored questions, and prioritized improvement suggestions. It runs entirely locally, requires no API keys, and produces results in seconds.

Hermes Agent was instrumental throughout development. It helped me make the right architecture decisions (rule-based over LLM, Python for PDF extraction), built the analysis engine incrementally with proper scoring weights and conditional templates, solved the cross-platform Unicode encoding bug in minutes, and drove UX refinements like deduplication, abort handling, and the CSS theming system. The collaboration wasn't about generating boilerplate — it was about making better design decisions faster and shipping a more polished product than I would have built alone.

The project is open source under MIT. Upload your resume and see what comes back — I'd love to hear whether the questions actually match your background.

Vectorized Conversations: Building a Quick RAG Chat Assistant Using Elasticsearch as a Vector Database

Ansuj Kumar Meher — Sat, 28 Feb 2026 06:03:47 +0000

This blog post was submitted to the Elastic Blogathon Contest and is eligible to win a prize.

Author Introduction

Hi, I’m Ansuj Kumar Meher, a developer deeply interested in search systems, distributed architecture, and AI-driven applications. Over the past few months, I’ve been exploring how vector search can transform traditional retrieval systems. For the Elastic Blogathon 2026, I wanted to move beyond theory and build something practical — a fully working Hybrid RAG assistant powered by Elasticsearch on Elastic Cloud.

This blog documents that journey — including architecture decisions, implementation details, and real observations from building the system.

Abstract

Large language models are impressive, but without grounding, they hallucinate. In this blog, I demonstrate how to build a Hybrid Retrieval-Augmented Generation (RAG) system using Elasticsearch as a vector database on Elastic Cloud. By combining BM25 keyword search, HNSW-based vector similarity, and Gemini 2.5 Flash for generation, we create a scalable and production-ready semantic search assistant.

1. The Problem: LLMs Without Grounding

When I first built a chatbot using an LLM, it felt magical. It could answer questions fluently and summarize information beautifully.

But then I asked it something outside its knowledge scope.

It still answered — confidently — and incorrectly.

That’s when I realized:

LLMs are great language generators.

They are not reliable retrieval systems.

If we want trustworthy AI systems, they must retrieve real information before generating answers.

This is where Retrieval-Augmented Generation (RAG) becomes essential.

2. Why Hybrid Search Instead of Just Vector Search?

While building this project, I tested three approaches:

Keyword-only search (BM25)
Vector-only search
Hybrid search (BM25 + vector similarity)

Each had strengths and weaknesses.

Keyword Search (BM25)

Excellent at lexical precision
Struggles with semantic intent

Vector Search

Understands meaning
Sometimes ignores important keywords

Hybrid Search

Balances precision and semantic understanding
Produces more stable ranking

For RAG systems, retrieval quality determines generation quality. Hybrid search consistently produced better grounding.

That’s why I built the system using Elasticsearch’s hybrid search capabilities.

3. System Architecture

The flow is simple but powerful:

User submits a query.
Query is converted into a 384-dimensional embedding using MiniLM.
Elasticsearch performs hybrid retrieval:
- BM25 keyword match
- kNN vector search using HNSW + cosine similarity
Top documents are retrieved.
Retrieved context is injected into the LLM prompt.
Gemini generates a grounded response.

The key idea is that the LLM never answers without context.

4. Deploying Elasticsearch on Elastic Cloud

Instead of running Elasticsearch locally, I deployed it on Elastic Cloud to simulate a production-ready environment.

Why Elastic Cloud?

Managed cluster
Built-in security
Automatic scaling
Production-grade infrastructure
Native vector search support

This ensures the architecture reflects real-world deployment patterns, not just a demo setup.

5. Configuring Elasticsearch as a Vector Database

To enable vector search, I created an index with a dense_vector field:

PUT chat_index
{
  "mappings": {
    "properties": {
      "content": {
        "type": "text"
      },
      "embedding": {
        "type": "dense_vector",
        "dims": 384,
        "index": true,
        "similarity": "cosine"
      }
    }
  }
}

Key points:

dims: 384 matches MiniLM embedding output.
similarity: cosine aligns with semantic embedding comparison.
index: true enables HNSW approximate nearest neighbor search.

This transforms Elasticsearch into a scalable vector database.

6. Understanding HNSW and Why It Matters

One challenge in vector search is performance.

Naively comparing a query vector against every stored vector is computationally expensive.

Elasticsearch solves this using HNSW (Hierarchical Navigable Small World graphs).

In simple terms:

Vectors are organized into graph layers.
Search navigates these layers efficiently.
Retrieval becomes fast even at scale.

This makes hybrid search practical for large datasets and production systems.

7. Implementing Hybrid Search

Here is the hybrid query I used:

GET chat_index/_search
{
  "query": {
    "bool": {
      "must": {
        "match": {
          "content": "Elasticsearch search"
        }
      }
    }
  },
  "knn": {
    "field": "embedding",
    "query_vector": [ ... 384 values ... ],
    "k": 3,
    "num_candidates": 10
  }
}

The _score reflects combined lexical and semantic relevance.

In my testing, hybrid retrieval produced more balanced and reliable results compared to vector-only search.

During experimentation, I also observed how tuning k and num_candidates impacted performance. Increasing num_candidates improved recall by exploring more potential nearest neighbors, but slightly increased latency. Similarly, raising k provided broader context for generation, but too many retrieved documents sometimes diluted answer precision. For small datasets this tradeoff is minimal, but at production scale, ANN parameter tuning becomes critical for balancing speed and retrieval quality.

8. Building the RAG Pipeline in Python

The full implementation is available here:

GitHub Repository:

https://github.com/ANSUJKMEHER/RagChat

Step 1: Generate Embeddings

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-MiniLM-L6-v2")
query_embedding = model.encode(query).tolist()

Step 2: Hybrid Retrieval

response = es.search(
    index="chat_index",
    query={
        "bool": {
            "must": {
                "match": {"content": query}
            }
        }
    },
    knn={
        "field": "embedding",
        "query_vector": query_embedding,
        "k": 3,
        "num_candidates": 10
    }
)

Step 3: Construct Context

retrieved_docs = [hit["_source"]["content"] for hit in response["hits"]["hits"]]
context = "\n".join(retrieved_docs)

This context is passed into the LLM prompt, ensuring grounded generation.

9. Integrating Gemini 2.5 Flash

import requests
import os

GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")

url = f"https://generativelanguage.googleapis.com/v1/models/gemini-2.5-flash:generateContent?key={GEMINI_API_KEY}"

payload = {
    "contents": [
        {"parts": [{"text": final_prompt}]}
    ]
}

response = requests.post(url, json=payload)
result = response.json()

The final answer now reflects retrieved Elastic documents rather than hallucinated content.

10. Sample Output

Example Query:

How does Elasticsearch improve search?

Example Output:

Supports hybrid search combining BM25 and vector similarity
Enables semantic similarity using dense vector embeddings
Scales efficiently using distributed architecture

11. Practical Applications

This architecture applies directly to:

Enterprise knowledge assistants
AI customer support bots
E-commerce semantic search
Log analysis in observability platforms
AI copilots grounded in proprietary data

For example, in an enterprise knowledge base, hybrid search prevents LLMs from fabricating internal policy details by forcing responses to rely strictly on indexed documentation. This significantly reduces hallucination risk while maintaining conversational fluency.

Hybrid search ensures meaning and precision coexist.

12. Key Observations from Building This

While building and testing this system, I observed:

Hybrid retrieval significantly improves answer grounding.
Retrieval quality impacts LLM output more than generation parameters.
Elastic Cloud simplifies scaling concerns.
Even small improvements in retrieval ranking dramatically improve answer quality.

One important realization:

In RAG systems, retrieval matters more than generation.

Conclusion + Takeaways

Vectorized thinking is not about replacing keyword search.

It is about enhancing it.

By combining:

Dense vector indexing
Hybrid search
HNSW-based ANN
Elastic Cloud deployment
RAG architecture

We create AI systems that are:

Reliable
Scalable
Context-aware
Production-ready

What surprised me most during this implementation was how much retrieval quality shapes generation quality. Adjusting embedding strategy and hybrid scoring had a larger impact on answer correctness than tweaking LLM temperature or prompt structure. This reinforced an important lesson: in production RAG systems, search engineering is not optional — it is foundational.

Elasticsearch demonstrates that search and vectors do not compete — they complement each other.

This project is a small step toward building grounded, trustworthy AI systems powered by Elastic.

GitHub Repository

Full source code available at:

https://github.com/ANSUJKMEHER/RagChat