refactor: reduce semantic search overhead … (#1128)

* refactor: reduce semantic search overhead                                             - Strip (title, description, score, and text) from the python microservice, remain only neccessary (subject, courseNumber)
- Replace post-Python CatalogClassModel.find() with the in-memory catalog cache already populated by fuzzy search, eliminating a edundant MongoDB round-trip on warm cache

* fix: codex code review comment

Author: vaclisinc

apps/backend/src/modules/catalog/catalog-cache.ts

@@ -31,7 +31,7 @@ const evictOldest = () => {
   }
 };
 
-const getCachedCatalog = async (
+export const getCachedCatalog = async (
   year: number,
   semester: string
 ): Promise<ICatalogClassItem[]> => {

apps/backend/src/modules/catalog/controller.ts

@@ -32,7 +32,7 @@ import { formatCourse } from "../course/formatter";
 import { formatEnrollment } from "../enrollment/formatter";
 import type { EnrollmentModule } from "../enrollment/generated-types/module-types";
 import type { GradeDistributionModule } from "../grade-distribution/generated-types/module-types";
-import { getSearchIndex } from "./catalog-cache";
+import { getCachedCatalog, getSearchIndex } from "./catalog-cache";
 
 export interface CatalogQueryParams {
   year: number;
@@ -160,40 +160,39 @@ const getCatalogWithSemanticSearch = async ({
   limit: number;
   skip: number;
 }) => {
-  // Throws if the semantic service is unavailable — surfaces as GraphQL error
   const response = await searchSemantic(searchTerm, year, semester);
 
   if (response.results.length === 0) {
     return { results: [], totalCount: 0 };
   }
 
-  // Throws if the semantic service is unavailable — surfaces as GraphQL error
   // Python already returns results sorted by score descending — preserve that order.
   // Build a rank map: "subject-courseNumber" → position in Python's ranked list
   const rankMap = new Map<string, number>();
   response.results.forEach(({ subject, courseNumber }, index) => {
     rankMap.set(`${subject}-${courseNumber}`, index);
   });
 
-  const query = buildFilterQuery(year, semester, filters);
-  query.$or = response.results.map(({ subject, courseNumber }) => ({
-    subject,
-    courseNumber,
-  })) as unknown as CatalogFilterCondition[];
+  // Reuse the server-side catalog cache (same one fuzzy search uses) to avoid
+  // a redundant MongoDB round-trip.
+  const allCatalog = await getCachedCatalog(year, semester);
+
+  const semanticMatches = allCatalog.filter((item) =>
+    rankMap.has(`${item.subject}-${item.courseNumber}`)
+  );
 
-  // Fetch all matching docs — semantic result sets are small (bounded by threshold)
-  const allResults = await CatalogClassModel.find(query).lean();
+  const filtered = applyInMemoryFilters(semanticMatches, filters);
 
   // Sort by Python's relevance rank, then by section number within the same course
-  allResults.sort((a, b) => {
+  filtered.sort((a, b) => {
     const rankA = rankMap.get(`${a.subject}-${a.courseNumber}`) ?? 999;
     const rankB = rankMap.get(`${b.subject}-${b.courseNumber}`) ?? 999;
     if (rankA !== rankB) return rankA - rankB;
     return a.number.localeCompare(b.number);
   });
 
-  const totalCount = allResults.length;
-  const results = allResults.slice(skip, skip + limit);
+  const totalCount = filtered.length;
+  const results = filtered.slice(skip, skip + limit);
 
   return { results, totalCount };
 };

apps/backend/src/modules/semantic-search/client.ts

@@ -3,10 +3,6 @@ import { config } from "../../../../../packages/common/src/utils/config";
 interface SemanticSearchResult {
   subject: string;
   courseNumber: string;
-  title: string;
-  description: string;
-  score: number;
-  text: string;
 }
 
 interface SemanticSearchResponse {

apps/backend/src/modules/semantic-search/controller.ts

@@ -26,11 +26,9 @@ export async function searchCourses(req: Request, res: Response) {
       thresholdNum
     );
 
-    // Return lightweight response: only subject + courseNumber + score
     const courseIds = results.results.map((r) => ({
       subject: r.subject,
       courseNumber: r.courseNumber,
-      score: r.score,
     }));
 
     return res.json({

apps/semantic-search/app/engine.py

@@ -325,34 +325,25 @@ def search(
         vq = VectorQuery(
             vector=query_vec.tolist(),
             vector_field_name="embedding",
-            return_fields=["subject", "course_number", "title", "description", "course_text"],
+            return_fields=["subject", "course_number"],
             num_results=search_k,
         )
 
         raw_results = entry.index.query(vq)
 
         # RedisVL COSINE distance = 1 - cosine_similarity, so convert threshold accordingly
         distance_threshold = 1.0 - threshold
-        results = []
+        scored = []
         for r in raw_results:
             dist = float(r.get("vector_distance", 1.0))
             if dist > distance_threshold:
                 continue
-            results.append(
-                {
-                    "subject": r.get("subject") or None,
-                    "courseNumber": r.get("course_number") or None,
-                    "title": r.get("title") or "",
-                    "description": r.get("description") or "",
-                    "score": 1.0 - dist,
-                    "text": r.get("course_text") or "",
-                }
-            )
+            scored.append((1.0 - dist, r.get("subject") or None, r.get("course_number") or None))
 
-        # Sort by score only - semantic similarity is more accurate than keyword matching
-        results.sort(key=lambda r: r["score"], reverse=True)
+        # Sort by score descending — backend preserves this order for ranking
+        scored.sort(key=lambda x: x[0], reverse=True)
 
-        # Return all results above threshold
+        results = [{"subject": subj, "courseNumber": cn} for _, subj, cn in scored]
         return results, entry
 
     def describe_indices(self) -> List[Dict]: