Forem: Manas Mishra

I Built a Token Compressor That Cuts LLM Context Size by 60%

Manas Mishra — Fri, 27 Mar 2026 12:37:01 +0000

Every token you send to an LLM costs money and eats into your context window. If you're stuffing structured data - JSON arrays, database records, API responses - into your prompts, you're probably wasting more than half your tokens on repeated keys, redundant values, and verbose formatting.

I built ctx-compressor( https://www.npmjs.com/package/ctx-compressor ) to fix that.

The Problem

Say you have 100 user records that look like this:

  {
    "name": "Adeel Solangi",
    "language": "Sindhi",
    "id": "V59OF92YF627HFY0",
    "bio": "Donec lobortis eleifend condimentum...",
    "version": 6.1
  },
  {
    "name": "Afzal Ghaffar",
    "language": "Sindhi",
    "id": "ENTOCR13RSCLZ6KU",
    "bio": "...",
    "version": 3.2
  }
  // ... 98 more records
]

That JSON blob eats up 19,338 tokens and 63,732 characters when you feed it to a model. Every single object repeats "name", "language", "id", "bio", "version" - that's pure waste.

The Solution

ctx-compressor analyzes your data, extracts a schema, deduplicates repeated values, and encodes everything into a compact format that LLMs can still understand:

CTX/2
$name:s|language:s|id:s|bio:t|version:n2
&0=Sindhi
&1=Uyghur
&2=Galician
&3=Maltese
&4=Sesotho sa Leboa
&5=isiZulu
&6=Icelandic
Adeel Solangi|&0|V59OF92YF627HFY0|Donec lobortis...|6.1
Afzal Ghaffar|&0|ENTOCR13RSCLZ6KU|...|3.2

The same data compresses down to 7,442 tokens and 13,746 characters.

That's a 61.5% reduction in tokens and a 78.4% reduction in characters.

How It Works

The compression relies on a few key ideas:

Schema extraction: Instead of repeating key names in every object, define them once at the top with type hints (s for string, n for number, t for text, etc.).

Value deduplication: Values that appear frequently (like "Sindhi" across many records) get assigned short aliases (&0, &1, ...) and referenced by alias instead of repeated in full.

Pipe-delimited rows: Each record becomes a single line with values separated by |, positionally mapped to the schema. No braces, no quotes, no colons.

The result is a format that's dense for the tokenizer but still perfectly readable by the LLM.

Usage

npm install ctx-compressor

import { compress, decompress } from 'ctx-compressor';

const data = [
  { name: "Adeel Solangi", language: "Sindhi", id: "V59OF92YF627HFY0", bio: "...", version: 6.1 },
  // ... more records
];

const compressed = compress(data);
// Send `compressed` to your LLM instead of JSON.stringify(data)

// Need the original structure back?
const original = decompress(compressed);

When To Use This

ctx-compressor shines when you're sending arrays of similarly-shaped objects to an LLM, think database query results, API responses, CSV-style data, user lists, product catalogs, log entries, etc.

It's particularly effective when:

Your data has repeated field names across many objects
Certain field values repeat frequently (categories, statuses, languages)
You're hitting context window limits or trying to reduce API costs
You're doing RAG and want to pack more retrieved documents into context

Benchmark Results

Tested on a dataset of 100 user records with name, language, ID, and version fields:

Raw JSON: 19,338 tokens
ctx-compressor: 7,442 tokens
Savings: 61.5%

LLM Compatibility

The compressed format includes the schema definition and alias table right in the output, so the LLM has everything it needs to interpret the data. In my testing, models handle it well; you can ask questions about the data, filter, aggregate, and reason over it just like you would with raw JSON.

You can also include a brief instruction in your system prompt, like: "The following data is in CTX/2 compressed format. The schema and alias definitions are included at the top." - though most modern models figure it out without any extra prompting.

What's Next

I'm actively working on this and would love feedback. Some directions I'm exploring:

Nested object support
Streaming compression for large datasets
Built-in integrations with popular LLM SDKs
A CLI tool for quick compression from the terminal
Handling text prompt compression

Check out the package on npm and let me know what you think. If you're spending too much on tokens for structured data, give it a try; that 60% savings adds up fast

If you found this useful, consider giving the repo a star, as it helps more people discover the project.

Quantum Computing Might Change AI More Than GPUs Did

Manas Mishra — Sun, 15 Mar 2026 05:51:21 +0000

A Moment That Changed Computing

In 2019, a quantum computer completed a calculation in 200 seconds that researchers estimated would take one of the world's most powerful supercomputers thousands of years to finish.

The experiment was conducted by Google using a quantum processor called Sycamore. At the time, the result sparked debate across the scientific community. Critics argued that the task had little real-world value, while supporters saw it as something much bigger.

For the first time, a machine built on the principles of quantum mechanics had demonstrated that it could outperform classical computers on a specific task.

The moment was called quantum supremacy.

For years after that announcement, many people still believed quantum computing was something that belonged in research labs and physics departments - impressive, but far from practical.

But the last few years have changed that narrative.

By 2026, quantum computing is quietly transitioning from an experimental technology into a tool designed to solve some of the most complex computational problems humanity faces.

To understand why this shift matters, we first need to understand what makes quantum computers fundamentally different from the computers we use today.

The Difference Between Bits and Qubits

Every computer we use today, from smartphones to supercomputers is built on a simple foundation: bits.

A bit can hold one of two values: 0 or 1. All modern software, algorithms, and digital systems ultimately rely on this binary representation.

Quantum computers operate differently.

Instead of bits, they use quantum bits, or qubits. A qubit uses the strange behavior of subatomic particles to exist in multiple states at once through a phenomenon known as superposition.

In simple terms, while a classical bit must be either 0 or 1, a qubit can be both at the same time.

This single property dramatically changes how computation works.

A classical computer evaluates possibilities one after another. A quantum computer can explore many possibilities simultaneously, making it uniquely suited for problems that grow exponentially in complexity.

That is why quantum computing harnesses the power of quantum mechanics to overcome the limitations that classical computing increasingly faces.

Why Quantum Computing Is Suddenly Back in the Spotlight

For decades, quantum computing research progressed slowly. The technology faced enormous challenges: fragile qubits, high error rates, and extremely complex hardware requirements.

The machines were fascinating from a physics perspective, but impractical for real-world use.

Then the field entered what researchers called the NISQ era : the age of Noisy Intermediate-Scale Quantum devices. These machines had limited capabilities but allowed scientists to experiment with real quantum hardware.

Now, something important is happening.

The industry is beginning to move beyond NISQ systems toward early fault-tolerant quantum computers, where errors can be corrected as systems scale.

This transition is widely considered the tipping point for practical quantum computing.

The reason is simple: many of the problems quantum computers aim to solve, from molecular simulation to complex optimization, become exponentially harder for classical computers as systems grow larger.

Quantum computers approach these problems differently. Instead of approximating quantum behavior with massive computational resources, they map the problem directly onto quantum hardware.

The Economic Stakes Are Growing

As the technology matures, the economic interest surrounding quantum computing has grown dramatically.

According to McKinsey, the global quantum computing market could reach $80 billion by 2035–2040.

Industries most likely to benefit include:

cryptography and cybersecurity
pharmaceutical research and drug discovery
logistics and optimization
financial modeling
large-scale data analysis
artificial intelligence

The reason these industries are paying attention is simple: they all rely on solving computationally expensive problems.

And that’s exactly where quantum computing shines.

The Breakthroughs That Changed the Conversation (2024–2026)

Over the last few years, quantum computing has seen a wave of breakthroughs across hardware, algorithms, and commercial adoption.

Suddenly, what once looked like distant research is starting to resemble a new computing platform.

Hardware Is Finally Catching Up

Several major technology companies have recently announced significant advances in quantum processors.

Google’s “Willow” chip, introduced in late 2024 and further benchmarked in 2025, contains 105 qubits and demonstrated something researchers had struggled with for years: below-threshold error correction.

In practical terms, this means that adding more qubits actually reduces overall system errors, a milestone many scientists thought was still years away.

Around the same time, Microsoft unveiled the “Majorana 1” processor, built using topological qubits derived from a new state of matter called topoconductors. These qubits are inherently more stable and may allow quantum chips to scale toward millions of qubits on a single device.

Meanwhile, IBM continued advancing its quantum roadmap with the Loon and Heron processors. The Heron chip has already been used to simulate complex molecular structures that challenge even advanced classical computing methods.

Researchers at Caltech also demonstrated a system containing over 6,100 neutral-atom qubits, showing that large-scale quantum systems may be achievable with entirely different hardware architectures.

China also released their open source Quantum OS,named Origin Pilot, and its world's first Open Source Quantum OS

In other words, the race toward scalable quantum hardware is accelerating.

When Quantum Algorithms Started Showing Real Advantage

Hardware alone is not enough. Quantum computers become meaningful only when they run algorithms that outperform classical ones.

In October 2025, Google introduced an algorithm called Quantum Echoes, which ran 13,000 times faster on the Willow processor than the best known classical algorithm running on a supercomputer.

Unlike earlier demonstrations of quantum supremacy, this result was verifiable and reproducible, which made the breakthrough far more convincing to the scientific community.

Researchers are now using this approach as a “molecular ruler”, allowing them to measure atomic interactions with extraordinary precision.

Quantum Computing Is Already Entering the Real World

The technology is also beginning to move beyond research labs.

In March 2026, the Bengaluru startup QpiAI launched QpiAI-Indus, India’s first full-stack quantum computer. The 25-qubit system is designed specifically for hybrid AI-quantum workloads.

Financial institutions are experimenting as well. In 2025, HSBC reported a 34% improvement in bond trading predictions by using IBM’s Heron processor to extract hidden signals from complex financial data.

Investment in quantum startups is also surging. In 2025 alone, funding for quantum companies reached nearly $3.8 billion within the first nine months.

The Next Big Frontier: Quantum AI

One of the most exciting developments is the intersection of quantum computing and artificial intelligence.

Rather than replacing classical AI systems, quantum computers are increasingly being used as accelerators for specific parts of AI workflows.

Because quantum systems evaluate multiple solution paths simultaneously, they could significantly reduce the time required to train large neural networks.

Researchers are also exploring quantum word embeddings, where language representations are mapped directly into quantum circuits.

This could allow AI models to capture the probabilistic structure of human language more naturally than classical architectures.

Early experiments suggest that quantum techniques could improve tasks such as:

causal inference
complex optimization
ambiguity resolution in language models

While the field is still young, the idea of Quantum AI is rapidly gaining attention.

The Beginning of a New Computing Era

Quantum computers will not replace classical computers anytime soon. Your laptop, phone, and cloud servers will still rely on traditional computing architectures for everyday tasks.

But quantum machines are emerging as specialized accelerators for problems that classical computers struggle to solve.

After decades of slow progress, the field has finally reached a moment where breakthroughs in hardware, algorithms, and software ecosystems are beginning to align.

The result is something that once sounded like science fiction:

A new type of computer that doesn’t just process information faster —
but processes it in an entirely different way.

And if current progress continues, quantum computing may become one of the most transformative technologies of the 21st century.

References & Further Reading

Quantum Supremacy (Google Sycamore)

Arute, F. et al. (2019). Quantum supremacy using a programmable superconducting processor. Nature.

https://www.nature.com/articles/s41586-019-1666-5
Google AI Quantum. Quantum Supremacy using a Programmable Superconducting Processor.

https://ai.googleblog.com/2019/10/quantum-supremacy-using-programmable.html

Core Concepts of Quantum Computing

Nielsen, M., & Chuang, I. (2010). Quantum Computation and Quantum Information. Cambridge University Press.
Preskill, J. (2018). Quantum Computing in the NISQ Era and Beyond.

https://arxiv.org/abs/1801.00862

NISQ Era

Preskill, J. (2018). Quantum Computing in the NISQ era and beyond. https://arxiv.org/abs/1801.00862

Google Willow Quantum Processor

Google Quantum AI. Meet Willow, our state-of-the-art quantum chip.

https://blog.google/innovation-and-ai/technology/research/google-willow-quantum-chip/
Acharya, R. et al. (2024). Quantum error correction below the surface code threshold. Nature.

https://www.nature.com/articles/s41586-024-08449-y
Castelvecchi, D. (2024). Google’s new quantum chip achieves accuracy milestone. Nature News.

https://www.nature.com/articles/d41586-024-04028-3
Google Quantum AI. Willow processor specification sheet.

https://quantumai.google/static/site-assets/downloads/willow-spec-sheet.pdf

Microsoft Topological Qubits / Majorana Research

Microsoft Quantum. Topological qubits and Majorana zero modes.

https://learn.microsoft.com/en-us/azure/quantum/concepts-topological-qubits
Aasen, D. et al. (2016). Milestones Toward Majorana-Based Quantum Computing. Physical Review X.

https://journals.aps.org/prx/abstract/10.1103/PhysRevX.6.031016

IBM Quantum Processors

IBM Quantum. IBM Quantum Roadmap.

https://www.ibm.com/quantum/roadmap
IBM Research. Heron Quantum Processor Architecture.

https://www.ibm.com/quantum/blog/quantum-roadmap-2033

Quantum Finance Experiment (HSBC)

HSBC. HSBC demonstrates quantum-enabled algorithmic bond trading with IBM.

https://www.hsbc.com/news-and-views/news/media-releases/2025/hsbc-demonstrates-worlds-first-known-quantum-enabled-algorithmic-trading-with-ibm
Ciceri, A. et al. (2025). Enhanced fill probability estimates in institutional algorithmic bond trading using quantum computers.

https://arxiv.org/abs/2509.17715

Quantum Market Forecast

McKinsey & Company. The Year of Quantum: From Concept to Reality (2025).

https://www.mckinsey.com/capabilities/tech-and-ai/our-insights/the-year-of-quantum-from-concept-to-reality-in-2025
McKinsey. Quantum computing use cases are getting real.

https://www.mckinsey.com/capabilities/quantumblack/our-insights/quantum-computing-use-cases

China Quantum Operating System (Origin Pilot)

Origin Quantum. Origin Pilot – Quantum Operating System.

https://qcloud.originqc.com.cn/en/programming/pilotos
Origin Quantum. Origin Pilot Whitepaper.

https://arxiv.org/abs/2105.10730

Neutral Atom Quantum Systems

Ebadi, S. et al. (2021). Quantum phases of matter on a programmable quantum simulator. Nature. https://www.nature.com/articles/s41586-021-03582-4

Quantum AI / Quantum Machine Learning

Biamonte, J. et al. (2017). Quantum Machine Learning. Nature.

https://www.nature.com/articles/nature23474
Schuld, M., Sinayskiy, I., & Petruccione, F. (2015). An introduction to quantum machine learning.

https://arxiv.org/abs/1409.3097

Additional Resources

National Institute of Standards and Technology (NIST). Post-Quantum Cryptography Standardization.

https://www.nist.gov/pqcrypto
IBM Quantum Network.

https://www.ibm.com/quantum

AI Can Write Code. But It Can’t Build Products.

Manas Mishra — Sat, 28 Feb 2026 17:09:51 +0000

It's been 2 years since I started doing AI development, but there is one thing that was lacking when AI hype started, and it's still lacking now.

Its decision-making, context awareness, and context longevity.

You may have already heard that Claude made a C compiler, Cloudflare made their own Next.js app, etc., but it's only possible when the person behind it was giving very clear instructions.

I saw multiple founders being stuck in a loop, where they have a good idea, but not technical, try to build using Google AI Studio or Replit, lovable, etc., but it's a sinkhole for them. They start well, but are never able to finalize it. They always need a developer who can do the final refinement or solve the issues that AI made for them.

The first problem I am talking about is that AI can start things in a good way, but as you start building a product with vibe coding, then AI falls back, because it lacks the long-term context awareness, or you can say, memory. It doesn't have a long term memory.

The second problem is that AI can write code, but it's not correctly structured, and it's bad. Ihave beenm seeing it for 2 years. The structure of the code used to be very bad before (it's improved a little, but not as much as it's hyped ). I literally told AI to create a React project from the start, and instead of running a command, it literally started creating files one by one, which eventually ran, but it's not what I meant when I said to create a React project ( I meant Vite create ).

The third problem is decision-making. For example, I want to create a website like Uber, and I said the same to AI, and it will create a plan for me. But, is it going to plan the whole architecture? iIsit going to consider the number of users I am targeting? Is it going to consider the database, which will be good for the target user? Is it going to decide the cloud architecture for me? No, iit'snot. It can pretend to do all of that, if you ask AI to do it, but with a simple prompt like "Build me a uber like website,, it's not.

Now, the solution.
I want to build a website that does all of that. Which means that not everyone is a good prompt engineer ( including me ), and I don't want to spend my time refining prompts word by word, so that AI can understand me better. I want to give the power to AI, where it can make decisions, plan exactly what you want ( and take confirmation before doing anything ), and do everything that a senior developer, project manager, or architect is able to do. Provide you complete picture of what's going on. Let you intervene, and be a decision maker ( if you want to be ), otherwise, make a decision for you, and be able to understand the point of the product you want to build, and don't lose context.

I understand that all of the above that I want to build is already possible, but is it possible for you?

Docker done better

Manas Mishra — Sat, 28 Feb 2026 07:29:18 +0000

Chapter 1: What I did

I have been building my own project for 3-4 weeks now, and I just realized something after I launched my website.

The tech stack is built on Next.js, Node.js, Strapi, OpenAI, MongoDB, etc., and I am using Docker to containerize it.

Initially, I didn't pay much attention as I wanted to launch it ASAP, but now, when I am focusing on the storage consumption of the Docker images, then its off the charts.

My Next.JS Docker image is of size 3.01 GB

Yes, it's hilarious. Because I am doing it the wrong way.

The real culprit (it's me, I guess ):

My initial Dockerfile of Next.js looks like this

# Use official Node image
FROM node:22

# Create app directory
WORKDIR /app

# Copy package files first
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy the rest of the project
COPY . .

# Build the Next.js app
RUN npm run build

# Expose port
EXPOSE 3000

# Start the app
CMD ["npm", "start"]

You can clearly see the issue here:

The default node:22 image is Debian-based and large (~1GB+).
RUN npm install installs dependencies and devDependencies in production, and you don't need devDependencies in prod.
RUN npm run build is building and running in the same container.

How does it matter in production

It matters because the container image size directly affects speed, cost, security, and scalability - especially for real SaaS apps like the ones I am building.

Every time I push to GitHub, CI builds a Docker image, pushes to ECR, EC2/Lambda pulls the image

The entire image must be transferred.

If the image is 1GB+, then it means slow push + slow pull
And in production, that means Slower releases, longer downtime during deploy, and slower blue/green swaps

With this image size (3 GB), if I try to scale to 10 containers in the future, that means 30GB of pull.

Huh, it's expensive.

The Solution

Yeah, its same Next.js app, no code changes, nothing else, just the change of Dockerfile, and the image size is reduced to 219 MB from 3.1 GB.

The real solution is this

# -------- Base Image --------
FROM node:20-alpine AS base
WORKDIR /app

# Install dependencies needed for some npm packages
RUN apk add --no-cache libc6-compat

# -------- Dependencies Stage --------
FROM base AS deps
COPY package.json package-lock.json* ./
RUN npm ci

# -------- Builder Stage --------
FROM base AS builder
COPY --from=deps /app/node_modules ./node_modules
COPY . .

# Build Next.js app
RUN npm run build

# -------- Production Stage --------
FROM node:20-alpine AS runner
WORKDIR /app

ENV NODE_ENV=production

# Create non-root user
RUN addgroup -S nextjs && adduser -S nextjs -G nextjs

# Copy standalone build
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
COPY --from=builder /app/public ./public

USER nextjs

EXPOSE 3000

ENV PORT=3000

CMD ["node", "server.js"]

Smaller Base image FROM node:20-alpine
Multi-stage build, because I separated the dependencies stage, the builder stage, and the production stage, which means that build tools will never reach the production image.
COPY --from=builder /app/.next/standalone ./ This is HUGE, standalone contains only required runtime files, only required production dependencies, which removed unused packages, devDependecies and even unnecessary Node modules
For security, I used `RUN addgroup -S nextjs && adduser -S nextjs -G nextjs USER nextjs. The old Dockerfile was running as root, but the new one runs as a limited user. So, if someone eill exploits your app, they don't get root access.

Real impact in Production

If traffic spike, the old Docker will spin up the container slowly, while the new one will be faster.
The old Docker had more CVE's, but the new one has fewer.

Let me know if you have used a different approach for docker.

Top 5 Mistakes Engineers Make While Building RAG Systems

Manas Mishra — Tue, 24 Feb 2026 06:44:18 +0000

Story Time 😁

I was working on a project that is highly dependent on RAG. User can be able to upload any document ( pdf, Word, PPT, ppt etc ), and AI can be able to answer any type of question from it.

When I started building the project, the first choice was always RAG, but the way I handled it broke a lot of things.

I uploaded the document regarding a security protocol of a school, it was 100 page pdf, and I asked a question, "Tell me which protocols to follow," and it answered beautifully.

But then the second question was, "Summarize the document." It's not able to consider everything in the document. Then the third question was "how many pages does this document have?" It's not able to answer that either.

Retrieval-Augmented Generation (RAG) looks simple on a whiteboard:

Embed → Store → Retrieve → Prompt → Generate.

In production, it’s rarely that clean.

After building and testing multiple RAG pipelines, I’ve noticed the same engineering mistakes repeated.

Here are the top 5.

1. Using Default Chunk Size Without Thinking

Most of you will pick:

500 tokens
1000 tokens
Or whatever the framework defaults to

Chunking is not about token count - it’s about semantic boundaries.

Bad chunking causes Context fragmentation, Low retrieval precision, and Hallucinated stitching between unrelated paragraphs

The better approach that I used in my production RAGs is:

Chunk by section headers
Preserve semantic completeness
Use overlap strategically (not blindly)

Chunking quality directly impacts retrieval quality, so you can't ignore it.

2. Ignoring Metadata Filtering

Many systems store embeddings like this:

{ vector, text }

That’s not enough.

In production, you need structured metadata:

{
  vector,
  text,
  source,
  document_type,
  timestamp,
  user_id,
  version
}

If you don't focus on metadata filtering, then retrieval becomes noisy, results mix unrelated documents, and also the multi-tenant systems break

Metadata filtering dramatically improves precision before semantic ranking even starts.

3. Not Evaluating Retrieval Quality

Most teams evaluate only the final LLM output.

You must evaluate the following 4 too:

Precision@k
Recall@k
MRR (Mean Reciprocal Rank)
Context relevance score

If retrieval is wrong, generation doesn’t matter.

RAG is a retrieval problem first, a generation problem second.

4. No Reranking Layer

A typical pipeline:

Vector Search → Top 5 → Send to LLM

And this is incomplete.

Dense retrieval optimizes for similarity - not relevance.

You should add a cross-encoder reranker

Yes, it adds latency.
But in high-value systems, accuracy > milliseconds.

5. Storing Raw PDFs Blindly

PDFs are messy:

Headers
Footers
Page numbers
Tables split across pages

You should do the preprocessing first, as it:

Remove boilerplate
Normalize structure
Clean tables
Remove repeated artifacts

Garbage in → garbage retrieval → hallucinated output.

RAG is not just:
"Add a vector database and call it a day."

It’s an information retrieval system wrapped around a generative model.

If retrieval is weak, the entire architecture collapses.

The database that AI uses

Manas Mishra — Sun, 22 Feb 2026 13:14:43 +0000

Imagine you have a huge toy box

Inside it are thousands of toys — cars, dolls, robots, animals.

Now suppose I ask you:

“Can you find toys that are similar to this red racing car?”

You wouldn’t look for toys with the same name.
You’d look for toys that feel similar - maybe other cars, maybe fast-looking toys, maybe red ones.

That’s how a vector database works.

Turning Things into Numbers

Computers don’t understand toys, pictures, or sentences the way humans do, so they convert everything into numbers. These special lists of numbers are called vectors. For example, a picture of a cat, a sentence like “I love pizza”, or even a voice recording can all be transformed into long lists of numbers such as
[0.21, 0.88, 0.03, 0.77, ...]

That list of numbers is called a vector.

Storing the Vectors

A vector database is just a special toy box. But instead of toys, it stores those number lists (vectors).

It doesn’t organize them alphabetically. Instead, it organizes them by how similar they are.

Finding Similar Things

If you show it a new sentence: "Pizza is my favorite food". It turns that sentence into numbers too.

Then it looks inside the database and asks:
"Which stored number list is most similar to this one?"

Even if the words are different, they can understand that the meaning is close. That’s why AI chatbots can:

Find similar documents
Answer questions from your files
Recognize similar images
Recommend products

Simple Example

Think of it like this:

Normal database: Finds exact matches (same name).
Vector database: Finds similar matches (same meaning or feeling).

Stop Writing Documentation Manually. I’m Trying Something Different.

Manas Mishra — Thu, 19 Feb 2026 09:17:20 +0000

Documentation always starts strong.

We write a clean README.
We add architecture notes.
We promise ourselves we’ll “keep docs updated.”

Then reality hits.

Features ship quickly.
Refactors happen.
Dead code disappears.

And documentation slowly becomes fiction.

The Real Problem

Documentation doesn’t fail because developers are lazy.

It fails because:

It’s manual.
It’s disconnected from code.
It doesn’t evolve automatically.

In fast-moving teams, code is the source of truth.

Docs should evolve with it.

But they don’t.

What I’m Building

I’m experimenting with a tool called DocFlow.

The idea is simple:

Connect your GitHub repo
Analyze the structure of your codebase
Generate structured documentation automatically
Keep documentation updated as the code changes

Instead of writing docs manually, they’re derived from the actual codebase.

Still Early

Right now, this is in the validation stage.

I’ve put up a simple waitlist while building the core engine:
👉 https://docflow.mmopro.in/

I’m trying to answer a few questions:

Would you trust AI-generated documentation?
What would make this genuinely useful?
Should this be a SaaS platform or GitHub Action first?
What language support is essential at launch?

Why I’m Sharing Early

Because I’d rather validate the problem deeply before building too much.

If documentation drift has ever annoyed you, I’d love your honest thoughts.

Even if it’s:
“This won’t work.”

Graph RAG: Why Vector Search Alone Is Not Enough for Serious Backend Systems

Manas Mishra — Wed, 24 Dec 2025 09:56:48 +0000

Most Retrieval-Augmented Generation (RAG) systems look impressive in demos and quietly fail in production

They retrieve something, generate something, and hope users trust it.

This article is about Graph RAG, not as an AI buzzword, but as a server-side architectural evolution that fixes fundamental problems in vector-only RAG systems.

The Problem With “Standard” RAG

Classic RAG architecture is deceptively simple:

Chunk documents
Generate embeddings
Store in a vector database
Retrieve top-K chunks
Inject into prompt

This works well only when:

Data is flat
Context is local
Relationships don’t matter

Where Vector RAG Breaks Down

As systems grow, vector-only RAG fails in predictable ways:

Loss of relational context
Vector search retrieves similar text, not related facts.
Inconsistent answers
Two queries with the same intent return different chunks.
Poor explainability
You cannot answer why a piece of information was retrieved.
Hallucinations from missing edges
The model fills gaps where relationships were never retrieved.

This is not an LLM problem.
This is a data modeling problem

Graph RAG: Treat Knowledge Like an Engineer Would

Graph RAG introduces something backend engineers already respect:
explicit structure.

Instead of treating knowledge as disconnected text blobs, we model it as:

Nodes: entities, concepts, documents, users, features
Edges: relationships, dependencies, references, ownership

The graph becomes the source of truth, while vectors become a search accelerator, not the core model.

How Graph RAG Actually Works

A production-grade Graph RAG pipeline usually looks like this:

Knowledge Ingestion

Documents are parsed
Entities are extracted
Relationships are inferred or explicitly defined
Nodes and edges are created

This is schema design, not prompt engineering.

Hybrid Retrieval

At query time:

Vector search finds relevant entry points
Graph traversal expands contextual neighborhood
Backend logic controls depth, filters, and constraints

Context Assembly

Instead of dumping top-K chunks:

Rank nodes by relevance
Remove redundant paths
Preserve relational order
Attach provenance metadata

Generation With Guardrails

The LLM is no longer "figuring things out".
It summarizes structured knowledge.

Example: Why Graph RAG Beats Vector RAG

User Query:

“Why was feature X deprecated, and what replaced it?”

Vector RAG:

Retrieves feature X documentation
Misses internal decision context
Hallucinates the reason

Graph RAG:

Node: Feature X
Edge: deprecated_by → ADR-42
Edge: replaced_by → Feature Y
Edge: owned_by → Platform Team

The answer is now deterministic, not probabilistic.

Operational Advantages

Debuggability

You can answer:

Which nodes were retrieved?
Which edges were traversed?
Why this answer was generated?

This matters in audits, enterprise clients, and regulated systems.

Controlled Hallucination Surface

Graph RAG limits what the model can invent because:

Missing edges mean missing context
The model cannot “assume” relationships

Performance Predictability

Vector-only RAG scales unpredictably.
Graph traversal cost is bounded and measurable.

Cost Control

You retrieve:

Smaller, richer context
Fewer redundant tokens
More reusable subgraphs

When NOT to Use Graph RAG

Graph RAG is not free.

Avoid it if:

Data is small and static
No real relationships exist
You only need a semantic search

Graph RAG adds engineering overhead, not magic.

Graph RAG works not because models are smarter-but because backend systems are.

Caddy: Free SSL over server

Manas Mishra — Wed, 30 Oct 2024 09:54:22 +0000

I have always been a fan of Nginx, but with Nginx, I always have to buy SSL for the domain configuration, with HTTPS. And, when it comes to Wildcard SSL, it costs more than the normal SSL.

Recently, I have been working with a server architect, and I came to know about Caddy - The Ultimate Server, and it's fascinating to see how it can obtain and renew the SSL certificates, automatically.

It provides the same features as Nginx but with fewer configurations and security has been added automatically too.

It supports Compression, Virtual file systems, TLS configurations, etc.

How to configure it in AWS: EC2

I created an EC2 instance, with AMI ( Amazon Linux v3 ) as an image.

After creating an instance, you can connect it either via SSH or directly through the EC2, and then you have to enter the following commands to install it

sudo yum -y install yum-plugin-copr
sudo yum -y copr enable @caddy/caddy epel-8-$(arch)
sudo yum -y install caddy

This will install the caddy server in the EC2 instance.

Creating the CaddyFile

After installing the caddy in your EC2 instance, you have to create a Caddyfile, in /etc/caddy folder.

To create the Caddyfile, you have to enter the below command.

sudo nano /etc/caddy/Caddyfile

And, after creating the file, you have to enter the following configuration

domain_name {
    reverse_proxy Ip_address:port 
}

For example, I have deployed the frontend and backend code in the EC2 and now I want to configure the caddy for the frontend and backend, by attaching the domain name to it.

app.aceinterview.co {
    reverse_proxy 3.24.60.134:3000
}

api.aceinterview.co {
    reverse_proxy 3.24.60.145:8000
}

As you can see in the example, I configured two different domains, one for the frontend and the other for the backend.

Run the caddy server

First, you have to enable the caddy server.

sudo systemctl enable caddy

The above step will create the symlink of the caddy.

Then, you have to start the caddy

sudo systemctl start caddy

Hurray!. Your caddy server configuration is completed. Now, you got reverse proxy, SSL configuration, etc.

More commands to handle caddy in EC2.

To stop the caddy server

sudo systemctl stop caddy

If you change something in Caddyfile, then you have to restart it to take effect.

sudo systemctl restart caddy

Today I have highlighted the basic setup of caddy, and this setup will do the most of the job. For more information, you can directly checkout the caddy server website https://caddyserver.com/

A new way to create desktop applications: Tauri + React

Manas Mishra — Wed, 28 Aug 2024 12:25:13 +0000

Welcome to this article. If you a programmer, you must have heard about electron.js, by using which, whatsapp, slack, skype, discord desktop application has been created. But, then why am I saying that Tauri is a new way to create desktop applications ? Let's look into some of the pros and cons of it.

Electron vs Tauri:

Performance

Tauri is designed to be more lightweight and faster than Electron, as it uses less memory and CPU resources

Security

Tauri is built with security in mind and aims to be more secure than Electron by using a Rust-based native layer instead of a JavaScript-based layer

Size

Tauri apps have smaller binary sizes than Electron apps because it’s using rust instead of javascript and other web technologies

Access to native APIs

Tauri apps have access to more system-level APIs than Electron apps, because of the use of rust

You can have a look at the below table, to compare Tauri and Electron Completely.

But, comparison doesn't make sense, till we jump to the code. So, let's create a basic todo app in both Electron and Tauri in React, and then we can see the comparison in between.

Electron App

To create electron app, use the below command and steps to create the electron app in react.



yarn create vite

1. Project-name: <add a name of the project>
2. Select a framework: select Others
3. Select create-electron-vite
4. Project template: React

Move into the electron project and you can open it in VSCode, and install all the packages



yarn install 
yarn add jotai

NOTE: We are using jotai for state management.

You can start the electron app using the below command



yarn dev

And, you can view an app something like this,

NOTE: As I am using Linux, so headers of the app and the icon are a little different. It will look different for Windows and Mac.

I cleaned everything in the App.tsx, App.css and index.css files, and the application will be blank for me.



import './App.css'

function App() {

  return (
    <>

    </>
  )
}

export default App

Now, Let's start creating the Todo Application.

I created a Components folder and store in the src folder and created two files, one inside the Components folder and one in the store folder.



src
|-- Components
    |-- Input.tsx
    |-- TodoList.tsx
|-- store
    |-- store.ts

Input.tsx: The input component is for the input box where we can type the todo app.

TodoList.tsx: This component will be used to show the list of the todos.

store.ts: This file is being handled to create the global store.



//store.ts
import { atom } from "jotai";

export const inputDataStore = atom<String[]>([])

Here, we are initializing the store using jotai Atom and giving it a type of Array of strings.



// Input.tsx
import { useAtom } from "jotai"
import { inputDataStore } from "../store/store"
import { useState } from "react"

const Input = () => {
  const [_, setData] = useAtom(inputDataStore)
  const [inputData, setInputData] = useState('')


  return (
    <div className="input-container">
        <input type="text" onChange={(e) => {
          setInputData(e.target.value)
        }} />
        <button onClick={() => {
          setData((el) => [...el, inputData])
        }}>
          Add Todo
        </button>
    </div>
  )
}

export default Input

As you can see, in the above code, I created an input box, and a button to add the entered value in the input box to move to the global todo list array.



// TodoList.tsx

import { useAtom } from 'jotai'
import { inputDataStore } from '../store/store'

const TodoList = () => {
  const [data] = useAtom(inputDataStore)

  return (
    <ul>
        {data?.map((item, index) => {
            return (
                <li key={index}>
                    {item}
                </li>
            )
        })}
    </ul>
  )
}

export default TodoList

The above code represents the list of the todo, which has been entered in the Input.tsx file.



// App.tsx
import './App.css'
import Input from './Components/Input'
import TodoList from './Components/TodoList'

function App() {

  return (
    <div className='app-container'>
      <Input />
      <TodoList />
    </div>
  )
}

export default App

Finally, all the components are combined and added to the App.tsx file.

Build the Electron App

To build the electron app, please run the below command.

yarn build

The above command will build the code and also create a folder named, release which has the build of the app to run on a desktop, according to your OS.

As I am running Linux, it created an AppImage for me, for 102.2 MB.

Tauri App

To create the Tauri app, use the below command and steps to create the Tauri app in React.



yarn create tauri-app

1. Project name: <name of the project>
2. Identifier: <project identifier>
3. Choose language: Typescript / Javascript
4. Choose Package Manager: yarn
5. Choose UI template: React
6. Choose UI flavour: Typescript

Now, You can cd into the tauri app, depending on what name you gave to your project.



cd <project_name>

Install all the packages and add jotai as a package for state management.



yarn install
yarn add jotai

The folder structure will be the same as the React project, and codebase too.

To run the project locally, please use the below command



yarn tauri dev

And, it will run the desktop application on your OS.

To build the desktop application, please run the below command.



yarn tauri build

Considering the tauri app with the same codebase and same packages to be used, the tauri size is only 30.8 KB

Stop Using dotenv package

Manas Mishra — Thu, 22 Aug 2024 05:54:41 +0000

Whenever it comes to securing the API keys or something that we don't want to be exposed to the public for our Open Source Project, we always tend towards the .env file, and every week, 29k+ developers download a trendy package, dotenv.

Why is the filename only .env?

It's a myth, that the filename can only start with .env. You can name it anything and it will still be working fine with node.js.

For example, this is my folder structure to test this feature, and as you can see, instead of .env, I added my name as a filename.

This file contains a PORT, which I want to print in my main file

And, as you can see, the PORT is being printed in the console.

Why we should be using dot( . ), in front of the environment file ?

When it comes to environment files, it's considered good to use a dot ( . ), in front of the filename, because adding a dot in front of any file name, makes it a hidden file or folder.

That's why there are multiple folders in your OS, that are hidden and can only be accessed via CLI, For example, .ssh, .github, .vscode, etc.

How to access the environment file without using dotenv?

Instead of using dotenv to read environment files, you can use the node.js inbuilt method to read them, which is



node --env-file=.env app.js

Here, instead of using .env as a file name, you can use any file name that is in your root folder.

Better Way To Docker

Manas Mishra — Wed, 11 Oct 2023 11:43:19 +0000

Did you ever use docker in any of your project. I prefer to run the docker in production, and combining it with the Kubernetes to handle the scaling of the user base. Docker shows us a new way of handling the very basic "But, it works on my system", issue.

At the end, We can't give our PC to every user, so, we have to use docker in production to stop this issue.

Prerequisite

Before anything, you need to have the docker desktop installed in your system or either the docker CLI, and then you will be able to good to go with docker.

I am making this tutorial for a node.js project. But, you can use the same for any of the project you wanted with some tweaks.

Check for the open containers

The first step of setting up the docker in your project is to find out, if you have any containers already running that you don't want to have currently.

And for that, you can use the following docker command to run list all the running docker containers

docker ps

As you can see in the above image, currently, I dont have any running containers.

Delete all the unused data

After listing the container with docker ps, if you find any containers, and you dont want any of them or caches, networks, volumes, or images that you want right now and wanted to delete every unsused data, then you can use the below command to do it.

docker system prune --all

As, you can see, that docker system prune command deleted one of my unused network.

Creating the Dockerfile

Now, the second step of setting up the docker in your project is creating the dockerfile, which is also the most important of them all.

In this step, at first you have to create a Dockerfile in the root of your project, and this file will contain all the commands that you want to run over the docker.

FROM node:18

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

ENV PORT=8080

EXPOSE 8080

CMD ["npm", "start"]

FROM node:18: This command install the image, on which you want to run the project. Here, node is the image and 18 is the version of the node.

WORKDIR /app: With this command, you define the base directory of your OS, which is /app and your whole project will be in this directory.

COPY package*.json ./: This command will copy the package.json and package-lock.json file from the local project to the docker.

RUN npm install: This command will run the npm install command over the server and install everything that has been specified under package.json and create a node_modules file over the docker.

COPY . .: This command will copy all of the other project code to its base directory, /app.

ENV PORT=8080: With this command, you can define the port that you want to expose to the local environment, as you may have using the .env.

EXPOSE 8080: This command will expose the same 8080 port defined before to the local codebase.

CMD ["npm", "start"]: This command will combine npm start and run it the docker, to run the project.

Build The DockerFile

After creating the dockerfile, you have to build the dockerfile, so that you can use it to publish later, to be used by other users.

docker build -t <name>:<version> .

The above command specifies:

docker build: This part of the command instructs Docker to build an image.

-t <name>:<version>: This is the -t (or --tag) option, which is used to specify a name and optionally a version tag for the Docker image. Here's what each part means:

<name>: This should be replaced with the desired name for your Docker image. The name is typically in lowercase and can consist of letters, numbers, hyphens, and underscores. It is used to identify your image.
<version>: This should be replaced with a version tag for your Docker image. The version tag is optional and is used to differentiate different versions or releases of the same image. It's common to use a version number or a version name (e.g., 1.0, latest, or a date) for this field.
.: The period (.) at the end of the command specifies the build context, which is the directory where the Dockerfile and any related files for building the image are located. In this case, it tells Docker to use the current directory as the build context.

Run the project over docker

After the above command, you are able to see an image in the docker desktop, and either you can run the below command to check the list of images running

docker images

Now, you can copy this Image ID, and paste the Image ID with the below command to run the project in the docker server.

docker run -p 5000:8000 b4ccb712e301

The command docker run -p 5000:8000 b4ccb712e301 is used to run a Docker container from the image with the image ID b4ccb712e301. Let's break down the command and its components:

docker run: This is the command to run a Docker container.

-p 5000:8000: The -p option is used to specify port mapping, allowing you to map ports on your host system to ports inside the container. In this case, it's mapping port 5000 on your host to port 8000 inside the container. This means that if the application inside the container listens on port 8000, you can access it from your host machine using port 5000.

b4ccb712e301: This is the image ID of the Docker image from which you want to create a container. The image with this ID is used as the base for the container.

So, when you run this command, Docker will create a new container based on the image with ID b4ccb712e301, and it will map port 5000 on your host to port 8000 inside the container. If the container contains a service or application that listens on port 8000, you can access that service on your host machine by connecting to http://localhost:5000.

For example, if you have a web application running inside the container on port 8000, you can access it from your web browser by going to http://localhost:5000.

Keep in mind that the image ID b4ccb712e301 should correspond to a valid Docker image that contains the application or service you want to run. If the image doesn't exist on your system, Docker will attempt to pull it from a Docker registry (like Docker Hub) if it's available there.

With the help of the above commands and files, you will be able to run your project over docker. There are many things, that you still need to apply in your project with docker to make it more scalable, which will be discussed in later articles.