feat: fetch semantic search results via GraphQL instead of in-memory catalog lookup

Author: vaclisinc

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

@@ -31,11 +31,17 @@ import { GradeDistributionModule } from "../grade-distribution/generated-types/m
 const EMPTY_GRADE_DISTRIBUTIONS: readonly IGradeDistributionItem[] =
   [] as const;
 
+export interface CourseIdentifier {
+  subject: string;
+  courseNumber: string;
+}
+
 // TODO: Pagination, filtering
 export const getCatalog = async (
   year: number,
   semester: string,
-  info: GraphQLResolveInfo
+  info: GraphQLResolveInfo,
+  identifiers?: CourseIdentifier[]
 ) => {
   /**
    * TODO:
@@ -60,6 +66,9 @@ export const getCatalog = async (
       year,
       semester,
       anyPrintInScheduleOfClasses: true,
+      ...(identifiers?.length
+        ? { $or: identifiers.map((i) => ({ subject: i.subject, courseNumber: i.courseNumber })) }
+        : {}),
     }).lean(),
   ]);
 
@@ -348,3 +357,13 @@ export const getCatalog = async (
 
   return reducedClasses;
 };
+
+export const getClassesByIdentifiers = (
+  year: number,
+  semester: string,
+  identifiers: CourseIdentifier[],
+  info: GraphQLResolveInfo
+) => {
+  if (identifiers.length === 0) return Promise.resolve([]);
+  return getCatalog(year, semester, info, identifiers);
+};

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

@@ -1,11 +1,14 @@
-import { getCatalog } from "./controller";
+import { getCatalog, getClassesByIdentifiers } from "./controller";
 import { CatalogModule } from "./generated-types/module-types";
 
 const resolvers: CatalogModule.Resolvers = {
   Query: {
     catalog: async (_, { year, semester }, __, info) => {
       return await getCatalog(year, semester, info);
     },
+    classesByIdentifiers: async (_, { year, semester, identifiers }, __, info) => {
+      return await getClassesByIdentifiers(year, semester, identifiers, info);
+    },
   },
 };
 

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

@@ -1,7 +1,17 @@
 import { gql } from "graphql-tag";
 
 export const catalogTypeDef = gql`
+  input CourseIdentifierInput {
+    subject: String!
+    courseNumber: CourseNumber!
+  }
+
   type Query {
     catalog(year: Int!, semester: Semester!): [Class!]!
+    classesByIdentifiers(
+      year: Int!
+      semester: Semester!
+      identifiers: [CourseIdentifierInput!]!
+    ): [Class!]!
   }
 `;

apps/frontend/src/components/ClassBrowser/index.tsx

@@ -1,10 +1,14 @@
 import { useEffect, useMemo, useState } from "react";
 
-import { useQuery } from "@apollo/client/react";
+import { useApolloClient, useQuery } from "@apollo/client/react";
 import classNames from "classnames";
 import { useSearchParams } from "react-router-dom";
 
 import { ITerm } from "@/lib/api";
+import {
+  GET_CLASSES_BY_IDENTIFIERS,
+  ICatalogClass,
+} from "@/lib/api/classes";
 import { GetCanonicalCatalogDocument, Semester } from "@/lib/generated/graphql";
 
 import styles from "./ClassBrowser.module.scss";
@@ -102,11 +106,11 @@ export default function ClassBrowser({
     useState<EnrollmentFilter | null>(null);
   const [localOnline, setLocalOnline] = useState<boolean>(false);
   const [aiSearchActive, setAiSearchActive] = useState<boolean>(false);
-  const [semanticResults, setSemanticResults] = useState<
-    Array<{ subject: string; courseNumber: string; score: number }>
-  >([]);
+  const [semanticResults, setSemanticResults] = useState<ICatalogClass[]>([]);
   const [semanticLoading, setSemanticLoading] = useState(false);
 
+  const apolloClient = useApolloClient();
+
   const { data, loading } = useQuery(GetCanonicalCatalogDocument, {
     variables: {
       semester: currentSemester,
@@ -296,23 +300,10 @@ export default function ClassBrowser({
   const index = useMemo(() => getIndex(includedClasses), [includedClasses]);
 
   const filteredClasses = useMemo(() => {
-    // If AI search is active and we have semantic results, filter by those
+    // If AI search is active and we have semantic results, return them directly
+    // They are already full class objects sorted by semantic score from the backend
     if (aiSearchActive && semanticResults.length > 0) {
-      // Backend already applies threshold filtering and sorting
-      // We need to maintain the order from API response
-      const classMap = new Map(
-        includedClasses.map((cls) => [
-          `${cls.subject}-${cls.courseNumber}`,
-          cls,
-        ])
-      );
-
-      // Map semantic results to actual class objects, preserving order
-      const filtered = semanticResults
-        .map((r) => classMap.get(`${r.subject}-${r.courseNumber}`))
-        .filter((cls) => cls !== undefined);
-
-      return filtered;
+      return semanticResults;
     }
 
     // Otherwise use normal fuzzy search
@@ -385,10 +376,41 @@ export default function ClassBrowser({
         throw new Error("Semantic search failed");
       }
 
-      const data = await response.json();
-      setSemanticResults(data.results || []);
-    } catch (error) {
-      console.error("Semantic search error:", error);
+      const responseData = await response.json();
+      const identifiers: Array<{ subject: string; courseNumber: string; score: number }> =
+        responseData.results || [];
+
+      if (identifiers.length === 0) {
+        setSemanticResults([]);
+        return;
+      }
+
+      const { data: gqlData } = await apolloClient.query({
+        query: GET_CLASSES_BY_IDENTIFIERS,
+        variables: {
+          year: currentYear,
+          semester: currentSemester,
+          identifiers: identifiers.map((r) => ({
+            subject: r.subject,
+            courseNumber: r.courseNumber,
+          })),
+        },
+        fetchPolicy: "no-cache",
+      });
+
+      const classesById = new Map(
+        (gqlData?.classesByIdentifiers ?? []).map((cls: ICatalogClass) => [
+          `${cls.subject}-${cls.courseNumber}`,
+          cls,
+        ])
+      );
+
+      const sorted = identifiers
+        .map((r) => classesById.get(`${r.subject}-${r.courseNumber}`))
+        .filter((cls): cls is ICatalogClass => cls !== undefined);
+
+      setSemanticResults(sorted);
+    } catch {
       setSemanticResults([]);
     } finally {
       setSemanticLoading(false);

apps/frontend/src/lib/api/classes.ts

@@ -455,6 +455,78 @@ export type IMeeting = ISection["meetings"][number];
  */
 export const GET_CANONICAL_CATALOG = gql(GET_CANONICAL_CATALOG_QUERY);
 
+export const GET_CLASSES_BY_IDENTIFIERS = gql`
+  query GetClassesByIdentifiers(
+    $year: Int!
+    $semester: Semester!
+    $identifiers: [CourseIdentifierInput!]!
+  ) {
+    classesByIdentifiers(
+      year: $year
+      semester: $semester
+      identifiers: $identifiers
+    ) {
+      subject
+      courseNumber
+      number
+      sessionId
+      title
+      unitsMax
+      unitsMin
+      viewCount
+      gradingBasis
+      primarySection {
+        online
+        sectionAttributes(attributeCode: "GE") {
+          attribute {
+            code
+          }
+          value {
+            description
+          }
+        }
+        enrollment {
+          latest {
+            endTime
+            status
+            enrolledCount
+            maxEnroll
+            activeReservedMaxCount
+            waitlistedCount
+            maxWaitlist
+          }
+        }
+        meetings {
+          days
+          startTime
+          endTime
+        }
+      }
+      course {
+        title
+        departmentNicknames
+        gradeDistribution {
+          average
+          pnpPercentage
+        }
+        academicCareer
+        academicOrganization
+        academicOrganizationName
+        ratingsCount
+        aggregatedRatings {
+          metrics {
+            metricName
+            weightedAverage
+          }
+        }
+      }
+      requirementDesignation {
+        description
+      }
+    }
+  }
+`;
+
 export type ICatalogClass = NonNullable<
   GetCanonicalCatalogQuery["catalog"]
 >[number];

packages/gql-typedefs/catalog.ts

@@ -1,7 +1,17 @@
 import { gql } from "graphql-tag";
 
 export const catalogTypeDef = gql`
+  input CourseIdentifierInput {
+    subject: String!
+    courseNumber: CourseNumber!
+  }
+
   type Query {
     catalog(year: Int!, semester: Semester!): [Class!]!
+    classesByIdentifiers(
+      year: Int!
+      semester: Semester!
+      identifiers: [CourseIdentifierInput!]!
+    ): [Class!]!
   }
 `;