Vector search : Where meaning is matched, not keywords

Md. Mehedi Hasan — Mon, 13 Jul 2026 05:22:28 +0000

Ever wondered how searching "comfortable shoes for long walks" instantly finds the perfect pair—even when those exact words aren't in the product title?

Vector Search takes search to the next level by understanding the intent behind user queries. In this article, I break down how it works, where it's used, and when your application actually needs it, why it's becoming essential in modern AI applications, its benefits and challenges.

What is Vector Search?

Vector search is an AI-powered search technique that converts both user queries and stored data into numerical vectors (embeddings). Instead of matching words, it compares the meaning of the query with the meaning of the stored data and returns the closest results.

For example, searching "coat for snow" can return winter jackets, even if the word snow doesn't exist in the product title.

How Does It Work?

The process is simple:

Convert all products, documents, or images into vector embeddings.
Convert the user's search query into an embedding using the same AI model.
Compare the query embedding with stored embeddings using similarity algorithms such as Cosine Similarity or Euclidean Distance.
Return the most relevant results based on semantic similarity.

What Are Vectors and Embeddings?

A vector is simply a list of numbers representing the meaning of data.

An embedding is the AI-generated vector created from text, images, audio, or other data types. Similar content produces similar embeddings, making semantic search possible.

Popular embedding models include:

BERT
Word2Vec
GloVe

Benefits of Vector Search

✅ Better Search Results

Understands user intent instead of relying on exact keywords.

✅ Handles Unstructured Data

Works with text, images, videos, audio, and documents.

✅ Multilingual Search

Can match similar meanings across different languages.

✅ Personalized Experience

Learns user preferences to deliver more relevant recommendations.

✅ Powers AI Features

Used in chatbots, recommendation engines, virtual assistants, and Retrieval-Augmented Generation (RAG) systems.

Challenges

Although powerful, vector search comes with some trade-offs.

High computational and storage requirements
More complex implementation than traditional search
Choosing the right embedding model is critical
Harder to debug because results are based on semantic similarity
Requires careful handling of privacy and sensitive data

Common Use Cases

Vector search is widely used across industries, including:

🛒 E-commerce product search and recommendations
🤖 AI chatbots and customer support
📄 Document search and retrieval
🖼️ Image similarity search
🎤 Voice assistants
🏥 Medical image analysis
😊 Sentiment analysis
🔍 Hybrid search (keyword + vector search)

Should Every Application Use Vector Search?

Not necessarily.

For most applications, especially MVPs, traditional search combined with filters and full-text search is enough.

Vector search becomes valuable when you need semantic understanding, AI-powered recommendations, personalized experiences, or natural language search.

Final Thoughts

Vector search is changing how modern applications retrieve information. Instead of matching words, it understands meaning, making search more natural and accurate.

As AI continues to evolve, vector search is becoming a core technology behind intelligent applications—from e-commerce and recommendation systems to chatbots and enterprise search.

If you're building an AI-powered product, learning vector search is a skill worth investing in.

The `Never` type - the typeScript feature most developers ignore… Until It Breaks Their Code

Md. Mehedi Hasan — Wed, 17 Jun 2026 04:42:26 +0000

TypeScript is known for catching bugs before runtime.

But one of its most underrated features is the never type, especially for exhaustive type checking.

Most developers know void.

Fewer understand never.

Even fewer actually use it correctly.

Yet this tiny feature can prevent entire classes of bugs in production.

🔹 `void` vs `never` (Quick Reality Check)

void  → function finishes normally (no return value)
never → function never finishes normally (throws or infinite loop)

Example:

function logMessage(): void {
  console.log("Hello");
}

function throwError(): never {
  throw new Error("Something went wrong");
}

💥 The Real Problem (Missing Exhaustiveness)

We define a union type:

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number };

And write a function:

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;

    case "rectangle":
      return shape.width * shape.height;

    case "triangle":
      return (shape.base * shape.height) / 2;

    default:
      return 0;
      // ❌ Problem: TypeScript assumes this is fine
      // ❌ But we are NOT ensuring all cases are handled
  }
}

⚠️ Hidden Bug (When Type Changes)

Later, a new requirement comes:

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number }
  | { kind: "square"; side: number }; // NEW

Now our function is silently broken:

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;

    case "rectangle":
      return shape.width * shape.height;

    case "triangle":
      return (shape.base * shape.height) / 2;

    default:
      return 0;

      /*
        ❌ PROBLEM:
        - "square" is NOT handled
        - No TypeScript error
        - No warning
        - This will fail silently in production
      */
  }
}

🧠 The Fix: `never` (Exhaustive Checking)

We create a helper:

function assertNever(value: never): never {
  throw new Error(`Unexpected value: ${value}`);
}

🔥 Safe Version (WITH `never` — Fully Exhaustive)

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "triangle"; base: number; height: number }
  | { kind: "square"; side: number }; // NEW SHAPE ADDED

function assertNever(value: never): never {
  throw new Error(`Unexpected value: ${value}`);
}

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;

    case "rectangle":
      return shape.width * shape.height;

    case "triangle":
      return (shape.base * shape.height) / 2;

    default:
          return assertNever(shape);
      /*
        🔥 This is where magic happens

        If ANY new shape is added and NOT handled,
        TypeScript will throw an error here.
      */

  }
}

🚨 What Happens Now?

If someone adds:

{ kind: "square"; side: number }

TypeScript shows:

❌ Argument of type '"square"' is not assignable to parameter of type 'never'

🧠 Meaning of This Error

“You said you handled all cases… but you didn’t.”

📊 Before vs After Mental Model

❌ Without `never`

Type changes
   ↓
Switch not updated
   ↓
No TypeScript error
   ↓
💥 Bug reaches production

✅ With `never`

Type changes
   ↓
Switch not updated
   ↓
TypeScript compile error
   ↓
🛑 Bug stopped before runtime

💡 Why This Matters in Real Projects

This pattern is extremely useful in:

🧾 Payment systems
📦 Order status flows
👤 Role-based access control
🌐 API response handling
🎯 UI state machines

🚀 Final Thought

never is not just a TypeScript trick.

It is a compile-time safety guarantee for your business logic.

If you're not using exhaustive checking yet, you're only partially using TypeScript.

🧠 One-line summary

“If you're not using never for exhaustive checks, TypeScript is not fully protecting your logic.”

DEV Community: Md. Mehedi Hasan