MERN Stack + MongoDB Atlas Vector Search: Build AI-Ready Apps in 2026

{
  "fields": [
    {
      "type": "vector",
      "path": "embedding",
      "numDimensions": 1536,
      "similarity": "cosine"
    },
    {
      "type": "filter",
      "path": "remote"
    },
    {
      "type": "filter",
      "path": "salary"
    }
  ]
}

mkdir ai-job-board && cd ai-job-board
npm init -y
npm install express mongoose dotenv openai @langchain/openai @langchain/mongodb langchain cors

// models/Job.js
import mongoose from "mongoose";

const jobSchema = new mongoose.Schema({
  title: String,
  company: String,
  description: String,
  requirements: [String],
  salary: { min: Number, max: Number },
  remote: Boolean,
  location: String,
  embedding: {
    type: [Number],
    required: true,
  },
  createdAt: { type: Date, default: Date.now }
});

export const Job = mongoose.model("Job", jobSchema);

// services/embedding.js
import { OpenAIEmbeddings } from "@langchain/openai";

const embeddings = new OpenAIEmbeddings({
  model: "text-embedding-3-small",
  openAIApiKey: process.env.OPENAI_API_KEY
});

export async function generateEmbedding(text) {
  const result = await embeddings.embedQuery(text);
  return result;
}

// Create searchable text from job object
export function jobToSearchText(job) {
  return `${job.title} ${job.company} ${job.description} ${job.requirements.join(" ")}`;
}

// scripts/seedJobs.js
import { Job } from "../models/Job.js";
import { generateEmbedding, jobToSearchText } from "../services/embedding.js";

const jobs = [
  {
    title: "Senior React Developer",
    company: "TechStartup Inc",
    description: "Build next-gen web applications using React and modern tooling. Remote-first culture.",
    requirements: ["React", "TypeScript", "Node.js", "5+ years experience"],
    salary: { min: 120000, max: 160000 },
    remote: true,
    location: "USA"
  },
  // ... more jobs
];

for (const job of jobs) {
  const text = jobToSearchText(job);
  const embedding = await generateEmbedding(text);
  await Job.create({ ...job, embedding });
}

// routes/search.js
import express from "express";
import mongoose from "mongoose";
import { generateEmbedding } from "../services/embedding.js";

const router = express.Router();

router.post("/semantic-search", async (req, res) => {
  const { query, filters = {}, limit = 10 } = req.body;

  // Generate embedding for search query
  const queryEmbedding = await generateEmbedding(query);

  // Build Atlas Vector Search aggregation pipeline
  const pipeline = [
    {
      $vectorSearch: {
        index: "job_vector_index",
        queryVector: queryEmbedding,
        path: "embedding",
        numCandidates: 100,
        limit: limit,
        filter: buildFilter(filters)
      }
    },
    {
      $addFields: {
        score: { $meta: "vectorSearchScore" }
      }
    },
    {
      $project: {
        embedding: 0 // Exclude embedding from response
      }
    }
  ];

  const jobs = await mongoose.connection.db
    .collection("jobs")
    .aggregate(pipeline)
    .toArray();

  res.json({ results: jobs, count: jobs.length });
});

function buildFilter(filters) {
  const filter = {};
  if (filters.remote !== undefined) filter.remote = { $eq: filters.remote };
  if (filters.minSalary) filter["salary.min"] = { $gte: filters.minSalary };
  return Object.keys(filter).length > 0 ? filter : undefined;
}

export default router;

// routes/recommend.js
router.post("/recommend-jobs", async (req, res) => {
  const { candidateProfile } = req.body;
  // Profile: { skills, experience, preferences, pastRoles }

  const profileText = `
    Skills: ${candidateProfile.skills.join(", ")}
    Experience: ${candidateProfile.experience} years
    Preferred role: ${candidateProfile.preferredRole}
    Work style: ${candidateProfile.workStyle}
  `;

  const profileEmbedding = await generateEmbedding(profileText);

  const recommendations = await mongoose.connection.db
    .collection("jobs")
    .aggregate([
      {
        $vectorSearch: {
          index: "job_vector_index",
          queryVector: profileEmbedding,
          path: "embedding",
          numCandidates: 50,
          limit: 5
        }
      },
      { $addFields: { matchScore: { $meta: "vectorSearchScore" } } },
      { $project: { embedding: 0 } }
    ]).toArray();

  res.json({ recommendations });
});

// src/components/AISearch.jsx
import { useState } from "react";

export default function AISearch() {
  const [query, setQuery] = useState("");
  const [results, setResults] = useState([]);
  const [loading, setLoading] = useState(false);

  const handleSearch = async () => {
    setLoading(true);
    const response = await fetch("/api/search/semantic-search", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        query,
        filters: { remote: true }
      })
    });
    const data = await response.json();
    setResults(data.results);
    setLoading(false);
  };

  return (
    <div className="ai-search">
      <div className="search-bar">
        <input
          type="text"
          value={query}
          onChange={(e) => setQuery(e.target.value)}
          placeholder="Try: 'remote React job, no degree required, startup culture'"
          onKeyDown={(e) => e.key === "Enter" && handleSearch()}
        />
        <button onClick={handleSearch} disabled={loading}>
          {loading ? "Searching..." : "AI Search"}
        </button>
      </div>

      <div className="results">
        {results.map((job) => (
          <JobCard key={job._id} job={job} score={job.score} />
        ))}
      </div>
    </div>
  );
}