diff --git a/client/app/components/SearchMovieModal/SearchMovieModal.tsx b/client/app/components/SearchMovieModal/SearchMovieModal.tsx
index 0466819..45bfcb4 100644
--- a/client/app/components/SearchMovieModal/SearchMovieModal.tsx
+++ b/client/app/components/SearchMovieModal/SearchMovieModal.tsx
@@ -16,7 +16,11 @@ interface SearchMovieModalProps {
   isLoading?: boolean;
 }
 
+export type SearchType = 'mongodb-search' | 'vector-search';
+
 export interface SearchParams {
+  searchType: SearchType;
+  // MongoDB Search fields
   plot?: string;
   fullplot?: string;
   directors?: string;
@@ -25,9 +29,13 @@ export interface SearchParams {
   limit?: number;
   skip?: number;
   search_operator?: 'must' | 'should' | 'mustNot' | 'filter';
+  // Vector Search fields
+  q?: string;
 }
 
 interface SearchFormData {
+  searchType: SearchType;
+  // MongoDB Search fields
   plot: string;
   fullplot: string;
   directors: string;
@@ -35,9 +43,13 @@ interface SearchFormData {
   cast: string;
   limit: string;
   search_operator: 'must' | 'should' | 'mustNot' | 'filter';
+  // Vector Search fields
+  q: string;
 }
 
 const getInitialFormData = (): SearchFormData => ({
+  searchType: 'mongodb-search',
+  // MongoDB Search fields
   plot: '',
   fullplot: '',
   directors: '',
@@ -45,6 +57,8 @@ const getInitialFormData = (): SearchFormData => ({
   cast: '',
   limit: '20',
   search_operator: 'must',
+  // Vector Search fields
+  q: '',
 });
 
 export default function SearchMovieModal({ 
@@ -58,15 +72,22 @@ export default function SearchMovieModal({
   const validateForm = () => {
     const newErrors: Record<string, string> = {};
 
-    // Check if at least one search field has a value
-    const hasSearchInput = formData.plot.trim() || 
-                          formData.fullplot.trim() || 
-                          formData.directors.trim() || 
-                          formData.writers.trim() || 
-                          formData.cast.trim();
+    if (formData.searchType === 'mongodb-search') {
+      // Check if at least one search field has a value for MongoDB Search
+      const hasSearchInput = formData.plot.trim() || 
+                            formData.fullplot.trim() || 
+                            formData.directors.trim() || 
+                            formData.writers.trim() || 
+                            formData.cast.trim();
 
-    if (!hasSearchInput) {
-      newErrors.general = 'Please enter search terms in at least one field';
+      if (!hasSearchInput) {
+        newErrors.general = 'Please enter search terms in at least one field';
+      }
+    } else if (formData.searchType === 'vector-search') {
+      // Check if query field has a value for Vector Search
+      if (!formData.q.trim()) {
+        newErrors.q = 'Please enter a search query.';
+      }
     }
 
     // Validate limit
@@ -86,27 +107,35 @@ export default function SearchMovieModal({
       return;
     }
 
-    // Build search parameters, only including non-empty fields
+    // Build search parameters based on search type
     const searchParams: SearchParams = {
-      search_operator: formData.search_operator,
+      searchType: formData.searchType,
       limit: parseInt(formData.limit),
-      skip: 0, // Always start from beginning for new search
     };
 
-    if (formData.plot.trim()) {
-      searchParams.plot = formData.plot.trim();
-    }
-    if (formData.fullplot.trim()) {
-      searchParams.fullplot = formData.fullplot.trim();
-    }
-    if (formData.directors.trim()) {
-      searchParams.directors = formData.directors.trim();
-    }
-    if (formData.writers.trim()) {
-      searchParams.writers = formData.writers.trim();
-    }
-    if (formData.cast.trim()) {
-      searchParams.cast = formData.cast.trim();
+    if (formData.searchType === 'mongodb-search') {
+      // Add MongoDB Search specific parameters
+      searchParams.search_operator = formData.search_operator;
+      searchParams.skip = 0; // Always start from beginning for new search
+
+      if (formData.plot.trim()) {
+        searchParams.plot = formData.plot.trim();
+      }
+      if (formData.fullplot.trim()) {
+        searchParams.fullplot = formData.fullplot.trim();
+      }
+      if (formData.directors.trim()) {
+        searchParams.directors = formData.directors.trim();
+      }
+      if (formData.writers.trim()) {
+        searchParams.writers = formData.writers.trim();
+      }
+      if (formData.cast.trim()) {
+        searchParams.cast = formData.cast.trim();
+      }
+    } else if (formData.searchType === 'vector-search') {
+      // Add Vector Search specific parameters
+      searchParams.q = formData.q.trim();
     }
 
     onSearch(searchParams);
@@ -140,7 +169,10 @@ export default function SearchMovieModal({
     <div className={styles.formContainer}>
       <h2 className={styles.formTitle}>Search Movies</h2>
       <p className={styles.batchDescription}>
-        Search across movie plots, directors, writers, and cast.
+        {formData.searchType === 'mongodb-search' 
+          ? 'Search across movie plots, directors, writers, and cast.'
+          : 'Find movies with similar plots using semantic search.'
+        }
       </p>
       
       {errors.general && (
@@ -150,135 +182,206 @@ export default function SearchMovieModal({
       )}
 
       <form onSubmit={handleSubmit} className={styles.form}>
-        {/* Search Fields */}
-        <div className={styles.formGrid}>
-          {/* Plot Search */}
-          <div className={styles.formGroup}>
-            <label htmlFor="plot" className={styles.label}>
-              Plot Keywords
-            </label>
-            <input
-              type="text"
-              id="plot"
-              value={formData.plot}
-              onChange={(e) => handleInputChange('plot', e.target.value)}
-              className={`${styles.input} ${errors.plot ? styles.inputError : ''}`}
-              disabled={isLoading}
-                            placeholder="Exact phrase search in plot summaries"
-            />
-            {errors.plot && <span className={styles.error}>{errors.plot}</span>}
-          </div>
-
-          {/* Full Plot Search */}
-          <div className={styles.formGroup}>
-            <label htmlFor="fullplot" className={styles.label}>
-              Full Plot Keywords
-            </label>
-            <input
-              type="text"
-              id="fullplot"
-              value={formData.fullplot}
-              onChange={(e) => handleInputChange('fullplot', e.target.value)}
-              className={`${styles.input} ${errors.fullplot ? styles.inputError : ''}`}
-              disabled={isLoading}
-              placeholder="Search in full plot descriptions"
-            />
-            {errors.fullplot && <span className={styles.error}>{errors.fullplot}</span>}
-          </div>
-
-          {/* Directors Search */}
-          <div className={styles.formGroup}>
-            <label htmlFor="directors" className={styles.label}>
-              Directors
-            </label>
-            <input
-              type="text"
-              id="directors"
-              value={formData.directors}
-              onChange={(e) => handleInputChange('directors', e.target.value)}
-              className={`${styles.input} ${errors.directors ? styles.inputError : ''}`}
-              disabled={isLoading}
-              placeholder="Director names"
-            />
-            {errors.directors && <span className={styles.error}>{errors.directors}</span>}
-          </div>
-
-          {/* Writers Search */}
-          <div className={styles.formGroup}>
-            <label htmlFor="writers" className={styles.label}>
-              Writers
-            </label>
-            <input
-              type="text"
-              id="writers"
-              value={formData.writers}
-              onChange={(e) => handleInputChange('writers', e.target.value)}
-              className={`${styles.input} ${errors.writers ? styles.inputError : ''}`}
-              disabled={isLoading}
-              placeholder="Writer names"
-            />
-            {errors.writers && <span className={styles.error}>{errors.writers}</span>}
-          </div>
-
-          {/* Cast Search */}
-          <div className={styles.formGroup}>
-            <label htmlFor="cast" className={styles.label}>
-              Cast
-            </label>
-            <input
-              type="text"
-              id="cast"
-              value={formData.cast}
-              onChange={(e) => handleInputChange('cast', e.target.value)}
-              className={`${styles.input} ${errors.cast ? styles.inputError : ''}`}
-              disabled={isLoading}
-              placeholder="Actor names"
-            />
-            {errors.cast && <span className={styles.error}>{errors.cast}</span>}
-          </div>
-
-          {/* Limit */}
-          <div className={styles.formGroup}>
-            <label htmlFor="limit" className={styles.label}>
-              Max Results
-            </label>
-            <input
-              type="number"
-              id="limit"
-              value={formData.limit}
-              onChange={(e) => handleInputChange('limit', e.target.value)}
-              className={`${styles.input} ${errors.limit ? styles.inputError : ''}`}
-              disabled={isLoading}
-              min="1"
-              max="100"
-            />
-            {errors.limit && <span className={styles.error}>{errors.limit}</span>}
-          </div>
-        </div>
-
-        {/* Search Operator */}
+        {/* Search Type Selector */}
         <div className={styles.formGroup}>
-          <label htmlFor="search_operator" className={styles.label}>
-            Search Logic
+          <label htmlFor="searchType" className={styles.label}>
+            Search Type
           </label>
           <select
-            id="search_operator"
-            value={formData.search_operator}
-            onChange={(e) => handleInputChange('search_operator', e.target.value)}
+            id="searchType"
+            value={formData.searchType}
+            onChange={(e) => handleInputChange('searchType', e.target.value)}
             className={styles.input}
             disabled={isLoading}
           >
-            {searchOperatorOptions.map((option) => (
-              <option key={option.value} value={option.value}>
-                {option.label}
-              </option>
-            ))}
+            <option value="mongodb-search">MongoDB Search</option>
+            <option value="vector-search">MongoDB Vector Search</option>
           </select>
           <small className={styles.searchOperatorDescription}>
-            {searchOperatorOptions.find(opt => opt.value === formData.search_operator)?.description}
+            {formData.searchType === 'mongodb-search' 
+              ? 'Search across multiple fields by using text matching and compound operators'
+              : 'Find movies with similar plots using AI-powered semantic search'
+            }
           </small>
         </div>
 
+        {/* Conditional Form Fields */}
+        {formData.searchType === 'mongodb-search' ? (
+          <>
+            {/* MongoDB Search Fields */}
+            <div className={styles.formGrid}>
+              {/* Plot Search */}
+              <div className={styles.formGroup}>
+                <label htmlFor="plot" className={styles.label}>
+                  Plot Keywords
+                </label>
+                <input
+                  type="text"
+                  id="plot"
+                  value={formData.plot}
+                  onChange={(e) => handleInputChange('plot', e.target.value)}
+                  className={`${styles.input} ${errors.plot ? styles.inputError : ''}`}
+                  disabled={isLoading}
+                  placeholder="Exact phrase search in plot summaries"
+                />
+                {errors.plot && <span className={styles.error}>{errors.plot}</span>}
+              </div>
+
+              {/* Full Plot Search */}
+              <div className={styles.formGroup}>
+                <label htmlFor="fullplot" className={styles.label}>
+                  Full Plot Keywords
+                </label>
+                <input
+                  type="text"
+                  id="fullplot"
+                  value={formData.fullplot}
+                  onChange={(e) => handleInputChange('fullplot', e.target.value)}
+                  className={`${styles.input} ${errors.fullplot ? styles.inputError : ''}`}
+                  disabled={isLoading}
+                  placeholder="Search in full plot descriptions"
+                />
+                {errors.fullplot && <span className={styles.error}>{errors.fullplot}</span>}
+              </div>
+
+              {/* Directors Search */}
+              <div className={styles.formGroup}>
+                <label htmlFor="directors" className={styles.label}>
+                  Directors
+                </label>
+                <input
+                  type="text"
+                  id="directors"
+                  value={formData.directors}
+                  onChange={(e) => handleInputChange('directors', e.target.value)}
+                  className={`${styles.input} ${errors.directors ? styles.inputError : ''}`}
+                  disabled={isLoading}
+                  placeholder="Director names"
+                />
+                {errors.directors && <span className={styles.error}>{errors.directors}</span>}
+              </div>
+
+              {/* Writers Search */}
+              <div className={styles.formGroup}>
+                <label htmlFor="writers" className={styles.label}>
+                  Writers
+                </label>
+                <input
+                  type="text"
+                  id="writers"
+                  value={formData.writers}
+                  onChange={(e) => handleInputChange('writers', e.target.value)}
+                  className={`${styles.input} ${errors.writers ? styles.inputError : ''}`}
+                  disabled={isLoading}
+                  placeholder="Writer names"
+                />
+                {errors.writers && <span className={styles.error}>{errors.writers}</span>}
+              </div>
+
+              {/* Cast Search */}
+              <div className={styles.formGroup}>
+                <label htmlFor="cast" className={styles.label}>
+                  Cast
+                </label>
+                <input
+                  type="text"
+                  id="cast"
+                  value={formData.cast}
+                  onChange={(e) => handleInputChange('cast', e.target.value)}
+                  className={`${styles.input} ${errors.cast ? styles.inputError : ''}`}
+                  disabled={isLoading}
+                  placeholder="Actor names"
+                />
+                {errors.cast && <span className={styles.error}>{errors.cast}</span>}
+              </div>
+
+              {/* Limit */}
+              <div className={styles.formGroup}>
+                <label htmlFor="limit" className={styles.label}>
+                  Max Results
+                </label>
+                <input
+                  type="number"
+                  id="limit"
+                  value={formData.limit}
+                  onChange={(e) => handleInputChange('limit', e.target.value)}
+                  className={`${styles.input} ${errors.limit ? styles.inputError : ''}`}
+                  disabled={isLoading}
+                  min="1"
+                  max="100"
+                />
+                {errors.limit && <span className={styles.error}>{errors.limit}</span>}
+              </div>
+            </div>
+
+            {/* Search Operator */}
+            <div className={styles.formGroup}>
+              <label htmlFor="search_operator" className={styles.label}>
+                Search Logic
+              </label>
+              <select
+                id="search_operator"
+                value={formData.search_operator}
+                onChange={(e) => handleInputChange('search_operator', e.target.value)}
+                className={styles.input}
+                disabled={isLoading}
+              >
+                {searchOperatorOptions.map((option) => (
+                  <option key={option.value} value={option.value}>
+                    {option.label}
+                  </option>
+                ))}
+              </select>
+              <small className={styles.searchOperatorDescription}>
+                {searchOperatorOptions.find(opt => opt.value === formData.search_operator)?.description}
+              </small>
+            </div>
+          </>
+        ) : (
+          <>
+            {/* Vector Search Fields */}
+            <div className={styles.formGroup}>
+              <label htmlFor="q" className={styles.label}>
+                Search Query
+              </label>
+              <textarea
+                id="q"
+                value={formData.q}
+                onChange={(e) => handleInputChange('q', e.target.value)}
+                className={`${styles.input} ${errors.q ? styles.inputError : ''}`}
+                disabled={isLoading}
+                placeholder="Describe the plot or theme you're looking for. e.g., 'A story about friendship and adventure in space'"
+                rows={3}
+              />
+              {errors.q && <span className={styles.error}>{errors.q}</span>}
+              <small className={styles.searchOperatorDescription}>
+                Describe the plot, theme, or mood you're looking for. MongoDB will find movies with similar content.
+              </small>
+            </div>
+
+            {/* Limit for Vector Search */}
+            <div className={styles.formGroup}>
+              <label htmlFor="limit_vector" className={styles.label}>
+                Max Results
+              </label>
+              <input
+                type="number"
+                id="limit_vector"
+                value={formData.limit}
+                onChange={(e) => handleInputChange('limit', e.target.value)}
+                className={`${styles.input} ${errors.limit ? styles.inputError : ''}`}
+                disabled={isLoading}
+                min="1"
+                max="50"
+              />
+              {errors.limit && <span className={styles.error}>{errors.limit}</span>}
+              <small className={styles.searchOperatorDescription}>
+                Vector search supports up to 50 results
+              </small>
+            </div>
+          </>
+        )}
+
         {/* Form Actions */}
         <div className={styles.formActions}>
           <button
@@ -302,7 +405,7 @@ export default function SearchMovieModal({
             className={`${styles.button} ${styles.saveButton}`}
             disabled={isLoading}
           >
-            {isLoading ? 'Searching...' : 'Search Movies'}
+            {isLoading ? 'Searching...' : `Search Movies`}
           </button>
         </div>
       </form>
diff --git a/client/app/components/SearchMovieModal/index.ts b/client/app/components/SearchMovieModal/index.ts
index 06150bc..ad9340f 100644
--- a/client/app/components/SearchMovieModal/index.ts
+++ b/client/app/components/SearchMovieModal/index.ts
@@ -1,2 +1,2 @@
 export { default } from './SearchMovieModal';
-export type { SearchParams } from './SearchMovieModal';
\ No newline at end of file
+export type { SearchParams, SearchType } from './SearchMovieModal';
\ No newline at end of file
diff --git a/client/app/lib/api.ts b/client/app/lib/api.ts
index 1d3929c..e8417e2 100644
--- a/client/app/lib/api.ts
+++ b/client/app/lib/api.ts
@@ -183,7 +183,7 @@ export async function deleteMovie(id: string): Promise<{ success: boolean; error
  */
 export async function createMovie(movieData: Omit<Movie, '_id'>): Promise<{ success: boolean; error?: string; movieId?: string }> {
   try {
-    const response = await fetch(`${API_BASE_URL}/api/movies/`, {
+    const response = await fetch(`${API_BASE_URL}/api/movies`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -276,7 +276,7 @@ export async function deleteMoviesBatch(movieIds: string[]): Promise<{ success:
       }
     };
 
-    const response = await fetch(`${API_BASE_URL}/api/movies/`, {
+    const response = await fetch(`${API_BASE_URL}/api/movies`, {
       method: 'DELETE',
       headers: {
         'Content-Type': 'application/json',
@@ -326,7 +326,7 @@ export async function updateMoviesBatch(movieIds: string[], updateData: Partial<
       }
     };
 
-    const response = await fetch(`${API_BASE_URL}/api/movies/`, {
+    const response = await fetch(`${API_BASE_URL}/api/movies`, {
       method: 'PATCH',
       headers: {
         'Content-Type': 'application/json',
@@ -364,80 +364,6 @@ export async function updateMoviesBatch(movieIds: string[], updateData: Partial<
   }
 }
 
-/**
- * Search movies using MongoDB Search across multiple fields with pagination support
- */
-export async function searchMovies(searchParams: {
-  plot?: string;
-  fullplot?: string;
-  directors?: string;
-  writers?: string;
-  cast?: string;
-  limit?: number;
-  skip?: number;
-  search_operator?: 'must' | 'should' | 'mustNot' | 'filter';
-}): Promise<{ success: boolean; error?: string; movies?: Movie[]; hasNextPage?: boolean; hasPrevPage?: boolean; totalCount?: number }> {
-  try {
-    // Build query parameters
-    const limit = searchParams.limit || 20;
-    const skip = searchParams.skip || 0;
-    
-    const queryParams = new URLSearchParams();
-    
-    if (searchParams.plot) queryParams.append('plot', searchParams.plot);
-    if (searchParams.fullplot) queryParams.append('fullplot', searchParams.fullplot);
-    if (searchParams.directors) queryParams.append('directors', searchParams.directors);
-    if (searchParams.writers) queryParams.append('writers', searchParams.writers);
-    if (searchParams.cast) queryParams.append('cast', searchParams.cast);
-    queryParams.append('limit', limit.toString());
-    queryParams.append('skip', skip.toString());
-    if (searchParams.search_operator) queryParams.append('search_operator', searchParams.search_operator);
-
-    const response = await fetch(`${API_BASE_URL}/api/movies/search?${queryParams}`, {
-      method: 'GET',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-    });
-
-    const result = await response.json();
-
-    if (!response.ok) {
-      return {
-        success: false,
-        error: result.message || result.error?.message || `Failed to search movies: ${response.status}`
-      };
-    }
-
-    if (!result.success) {
-      return {
-        success: false,
-        error: result.message || result.error?.message || 'API returned error response'
-      };
-    }
-
-    const responseData = result.data || {};
-    const movies = responseData.movies || [];
-    const totalCount = responseData.totalCount || 0;
-    const hasNextPage = skip + limit < totalCount;
-    const hasPrevPage = skip > 0;
-
-    return {
-      success: true,
-      movies,
-      hasNextPage,
-      hasPrevPage,
-      totalCount
-    };
-  } catch (error) {
-    console.error('Error searching movies:', error);
-    return { 
-      success: false, 
-      error: 'Network error occurred while searching movies' 
-    };
-  }
-}
-
 /**
  * Aggregation API Functions for Aggregations
  */
@@ -655,3 +581,156 @@ export async function fetchDirectorStats(limit: number = 20): Promise<{ success:
     };
   }
 }
+
+/**
+ * Search movies using MongoDB Search across multiple fields with pagination support
+ */
+export async function searchMovies(searchParams: {
+  plot?: string;
+  fullplot?: string;
+  directors?: string;
+  writers?: string;
+  cast?: string;
+  limit?: number;
+  skip?: number;
+  search_operator?: 'must' | 'should' | 'mustNot' | 'filter';
+}): Promise<{ success: boolean; error?: string; movies?: Movie[]; hasNextPage?: boolean; hasPrevPage?: boolean; totalCount?: number }> {
+  try {
+    // Build query parameters
+    const limit = searchParams.limit || 20;
+    const skip = searchParams.skip || 0;
+    
+    const queryParams = new URLSearchParams();
+    
+    if (searchParams.plot) queryParams.append('plot', searchParams.plot);
+    if (searchParams.fullplot) queryParams.append('fullplot', searchParams.fullplot);
+    if (searchParams.directors) queryParams.append('directors', searchParams.directors);
+    if (searchParams.writers) queryParams.append('writers', searchParams.writers);
+    if (searchParams.cast) queryParams.append('cast', searchParams.cast);
+    queryParams.append('limit', limit.toString());
+    queryParams.append('skip', skip.toString());
+    if (searchParams.search_operator) queryParams.append('search_operator', searchParams.search_operator);
+
+    const response = await fetch(`${API_BASE_URL}/api/movies/search?${queryParams}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      return {
+        success: false,
+        error: result.message || result.error?.message || `Failed to search movies: ${response.status}`
+      };
+    }
+
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.message || result.error?.message || 'API returned error response'
+      };
+    }
+
+    const responseData = result.data || {};
+    const movies = responseData.movies || [];
+    const totalCount = responseData.totalCount || 0;
+    const hasNextPage = skip + limit < totalCount;
+    const hasPrevPage = skip > 0;
+
+    return {
+      success: true,
+      movies,
+      hasNextPage,
+      hasPrevPage,
+      totalCount
+    };
+  } catch (error) {
+    console.error('Error searching movies:', error);
+    return { 
+      success: false, 
+      error: 'Network error occurred while searching movies' 
+    };
+  }
+}
+
+/**
+ * Search movies using MongoDB Vector Search to find movies with similar plots
+ */
+export async function vectorSearchMovies(searchParams: {
+  q: string;
+  limit?: number;
+}): Promise<{ success: boolean; error?: string; movies?: Movie[]; results?: any[] }> {
+  try {
+    const limit = searchParams.limit || 10;
+    
+    const queryParams = new URLSearchParams();
+    queryParams.append('q', searchParams.q);
+    queryParams.append('limit', limit.toString());
+
+    const response = await fetch(`${API_BASE_URL}/api/movies/vector-search?${queryParams}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    const result = await response.json();
+
+    if (!response.ok) {
+      return { 
+        success: false, 
+        error: result.error || `Failed to perform vector search: ${response.status}` 
+      };
+    }
+
+    if (!result.success) {
+      return { 
+        success: false, 
+        error: result.error || 'API returned error response' 
+      };
+    }
+
+    // Transform VectorSearchResult objects to Movie objects for backend compatibility
+    const movies: Movie[] = (result.data || []).map((item: any) => {
+      // Convert VectorSearchResult to Movie format
+      return {
+        _id: item._id || item.id, // Handle both _id (Python) and id (Java) field names
+        title: item.title || '',
+        plot: item.plot || '',
+        poster: item.poster,
+        year: item.year,
+        genres: item.genres || [],
+        directors: item.directors || [],
+        cast: item.cast || [],
+        // Add default values for fields not included in VectorSearchResult
+        fullplot: undefined,
+        released: undefined,
+        runtime: undefined,
+        writers: [],
+        countries: [],
+        languages: [],
+        rated: undefined,
+        awards: undefined,
+        imdb: undefined,
+        tomatoes: undefined,
+        metacritic: undefined,
+        type: undefined
+      } as Movie;
+    });
+
+    return { 
+      success: true, 
+      movies,
+      results: result.data || []
+    };
+  } catch (error) {
+    console.error('Error performing vector search:', error);
+    return { 
+      success: false, 
+      error: 'Network error occurred while performing vector search' 
+    };
+  }
+}
\ No newline at end of file
diff --git a/client/app/movies/movies.module.css b/client/app/movies/movies.module.css
index 477547f..f44e5b9 100644
--- a/client/app/movies/movies.module.css
+++ b/client/app/movies/movies.module.css
@@ -148,6 +148,17 @@
   text-align: center;
 }
 
+.searchInfo {
+  margin: 2rem 0;
+  padding: 1rem;
+  background: #f8f9fa;
+  border: 1px solid #e9ecef;
+  border-radius: 8px;
+  text-align: center;
+  font-size: 0.9rem;
+  color: #666;
+}
+
 .selectAllButton {
   padding: 0.5rem 1rem;
   background: #6c757d;
diff --git a/client/app/movies/page.tsx b/client/app/movies/page.tsx
index bfae6e1..504fa1a 100644
--- a/client/app/movies/page.tsx
+++ b/client/app/movies/page.tsx
@@ -6,11 +6,22 @@ import pageStyles from "./page.module.css";
 import movieStyles from "./movies.module.css";
 import { MovieCard, Pagination, PageSizeSelector, AddMovieForm, BatchEditMovieForm, SearchMovieModal } from "../components";
 import { ErrorDisplay, LoadingSpinner } from "../components/ui";
-import { fetchMovies, createMovie, createMoviesBatch, deleteMoviesBatch, updateMoviesBatch, searchMovies } from "../lib/api";
+import { fetchMovies, createMovie, createMoviesBatch, deleteMoviesBatch, updateMoviesBatch, searchMovies, vectorSearchMovies } from "../lib/api";
 import { Movie } from "../types/movie";
 import { APP_CONFIG, ROUTES } from "../lib/constants";
 import type { SearchParams } from "../components/SearchMovieModal";
 
+/**
+ * Movies Page Component
+ * 
+ * Main page for browsing movies with the following features:
+ * - Regular movie browsing with URL-based pagination
+ * - MongoDB text search with server-side pagination
+ * - Vector search with client-side pagination
+ * - CRUD operations (create, update, delete movies)
+ * - Batch operations on selected movies
+ * 
+ */
 export default function Movies() {
   const searchParams = useSearchParams();
   const router = useRouter();
@@ -31,6 +42,9 @@ export default function Movies() {
   const [error, setError] = useState<string | null>(null);
   const [successMessage, setSuccessMessage] = useState<string | null>(null);
   const [searchResults, setSearchResults] = useState<Movie[]>([]);
+  const [allVectorSearchResults, setAllVectorSearchResults] = useState<Movie[]>([]);
+  const [vectorSearchPage, setVectorSearchPage] = useState(1);
+  const [vectorSearchPageSize, setVectorSearchPageSize] = useState(20);
   const [searchHasNextPage, setSearchHasNextPage] = useState(false);
   const [searchHasPrevPage, setSearchHasPrevPage] = useState(false);
   const [searchTotalCount, setSearchTotalCount] = useState(0);
@@ -221,46 +235,100 @@ export default function Movies() {
     setError(null);
     setSuccessMessage(null);
 
-    // For new searches, start from page 1
-    const searchSkip = 0;
-    const searchLimitToUse = searchParams.limit || 20;
-    
-    const searchParamsWithPagination = {
-      ...searchParams,
-      limit: searchLimitToUse,
-      skip: searchSkip,
-    };
+    try {
+      let result;
+
+      if (searchParams.searchType === 'vector-search') {
+        // Vector Search: Fetch all results and implement client-side pagination
+        const vectorSearchParams = {
+          q: searchParams.q!,
+          limit: searchParams.limit || 50, // Get more results for better pagination experience
+        };
+        result = await vectorSearchMovies(vectorSearchParams);
+        
+        if (result.success) {
+          const allResults = result.movies || [];
+          const pageSize = searchParams.limit || 20;
+          setAllVectorSearchResults(allResults);
+          setVectorSearchPage(1);
+          setVectorSearchPageSize(pageSize);
+          
+          // Calculate first page of results for immediate display
+          const firstPageResults = allResults.slice(0, pageSize);
+          setSearchResults(firstPageResults);
+          
+          // Set pagination state based on total results
+          const totalPages = Math.ceil(allResults.length / pageSize);
+          setSearchHasNextPage(totalPages > 1);
+          setSearchHasPrevPage(false);
+          setSearchTotalCount(allResults.length);
+        }
+      } else {
+        // MongoDB Search
+        const searchSkip = 0; // Always start from page 1 for new searches
+        const searchLimitToUse = searchParams.limit || 20;
+        
+        const searchParamsWithPagination = {
+          ...searchParams,
+          limit: searchLimitToUse,
+          skip: searchSkip,
+        };
 
-    const result = await searchMovies(searchParamsWithPagination);
+        result = await searchMovies(searchParamsWithPagination);
+        
+        if (result.success) {
+          setSearchResults(result.movies || []);
+          setSearchHasNextPage(result.hasNextPage || false);
+          setSearchHasPrevPage(result.hasPrevPage || false);
+          setSearchTotalCount(result.totalCount || 0);
+        }
+      }
 
-    if (result.success) {
-      setSearchResults(result.movies || []);
-      setSearchHasNextPage(result.hasNextPage || false);
-      setSearchHasPrevPage(result.hasPrevPage || false);
-      setSearchTotalCount(result.totalCount || 0);
-      setIsSearchMode(true);
-      setSearchPage(1);
-      setSearchLimit(searchLimitToUse);
-      setCurrentSearchParams(searchParams);
-      setShowSearchModal(false);
-      setSelectedMovies(new Set()); // Clear selection when switching to search mode
-      
-      const totalCount = result.totalCount || 0;
-      if (totalCount === 0) {
-        setSuccessMessage('Search completed, but no movies matched your criteria. Try different search terms.');
+      if (result.success) {
+        setIsSearchMode(true);
+        setSearchPage(1);
+        setSearchLimit(searchParams.limit || 20);
+        setCurrentSearchParams(searchParams);
+        setShowSearchModal(false);
+        setSelectedMovies(new Set()); // Clear selection when switching to search mode
+        
+        if (searchParams.searchType === 'vector-search') {
+          const returnedCount = result.movies?.length || 0;
+          
+          if (returnedCount === 0) {
+            setSuccessMessage('Vector search completed, but no movies matched your query. Try different search terms.');
+          } else {
+            setSuccessMessage(`Found ${returnedCount} results using vector search.`);
+          }
+        } else {
+          // MongoDB text search success message
+          const totalCount = (result as any).totalCount || 0;
+          
+          if (totalCount === 0) {
+            setSuccessMessage('Search completed, but no movies matched your criteria. Try different search terms.');
+          } else {
+            setSuccessMessage(`Found ${totalCount} results using MongoDB search.`);
+          }
+        }
       } else {
-        setSuccessMessage(`Found ${totalCount} total movies matching your search criteria.`);
+        setError(result.error || 'Failed to search movies');
       }
-    } else {
-      setError(result.error || 'Failed to search movies');
+    } catch (err) {
+      setError('An unexpected error occurred while searching');
     }
 
     setIsSearching(false);
   };
 
+  /**
+   * Clears search mode and returns to regular movie browsing
+   * Resets all search-related state including vector search pagination
+   */
   const handleClearSearch = () => {
     setIsSearchMode(false);
     setSearchResults([]);
+    setAllVectorSearchResults([]);
+    setVectorSearchPage(1);
     setSearchHasNextPage(false);
     setSearchHasPrevPage(false);
     setSearchTotalCount(0);
@@ -275,9 +343,68 @@ export default function Movies() {
   // Get the movies to display based on current mode
   const displayMovies = isSearchMode ? searchResults : movies;
 
+  /**
+   * Helper function for vector search client-side pagination
+   * Calculates pagination data for the current vector search results
+   */
+  const getVectorSearchPageData = () => {
+    if (!isSearchMode || currentSearchParams?.searchType !== 'vector-search') {
+      return { paginatedResults: [], hasNext: false, hasPrev: false, totalPages: 0 };
+    }
+
+    const startIndex = (vectorSearchPage - 1) * vectorSearchPageSize;
+    const endIndex = startIndex + vectorSearchPageSize;
+    const paginatedResults = allVectorSearchResults.slice(startIndex, endIndex);
+    const totalPages = Math.ceil(allVectorSearchResults.length / vectorSearchPageSize);
+    
+    return {
+      paginatedResults,
+      hasNext: vectorSearchPage < totalPages,
+      hasPrev: vectorSearchPage > 1,
+      totalPages
+    };
+  };
+
+  /**
+   * Handles page navigation for vector search results (client-side pagination)
+   * Slices the cached results and updates the display
+   */
+  const handleVectorSearchPageChange = (newPage: number) => {
+    if (!isSearchMode || currentSearchParams?.searchType !== 'vector-search') return;
+    
+    const totalPages = Math.ceil(allVectorSearchResults.length / vectorSearchPageSize);
+    if (newPage < 1 || newPage > totalPages) return;
+    
+    setVectorSearchPage(newPage);
+    
+    // Update the displayed results based on the new page
+    const startIndex = (newPage - 1) * vectorSearchPageSize;
+    const endIndex = startIndex + vectorSearchPageSize;
+    const paginatedResults = allVectorSearchResults.slice(startIndex, endIndex);
+    
+    setSearchResults(paginatedResults);
+    setSearchHasNextPage(newPage < totalPages);
+    setSearchHasPrevPage(newPage > 1);
+    
+    // Clear selection and scroll to top for better UX
+    setSelectedMovies(new Set());
+    window.scrollTo({ top: 0, behavior: 'smooth' });
+  };
+
   const handleSearchPageChange = async (newPage: number) => {
     if (!currentSearchParams) return;
     
+    // This function handles MongoDB search pagination (server-side)
+    // Vector search uses handleVectorSearchPageChange for client-side pagination
+    if (currentSearchParams.searchType === 'vector-search') {
+      return;
+    }
+    
+    // Validate page number and prevent invalid navigation
+    if (newPage < 1) return;
+    if (isSearching) return;
+    if (newPage > searchPage && !searchHasNextPage) return;
+    
     setIsSearching(true);
     setError(null);
     
@@ -297,10 +424,17 @@ export default function Movies() {
         setSearchHasPrevPage(result.hasPrevPage || false);
         setSearchTotalCount(result.totalCount || 0);
         setSearchPage(newPage);
+        
+        // Clear any previously selected movies when changing pages
+        setSelectedMovies(new Set());
+        
+        // Scroll to top to show new results
+        window.scrollTo({ top: 0, behavior: 'smooth' });
       } else {
         setError(result.error || 'Failed to load search results');
       }
     } catch (error) {
+      console.error('Search pagination error:', error);
       setError('Failed to load search results');
     }
     
@@ -469,51 +603,107 @@ export default function Movies() {
                 
                 {/* Show pagination based on current mode */}
                 {isSearchMode ? (
-                  <nav className={movieStyles.pagination} aria-label="Search results pagination">
-                    <div className={movieStyles.paginationContainer}>
-                      {/* Previous Button */}
-                      {searchHasPrevPage ? (
-                        <button
-                          onClick={() => handleSearchPageChange(searchPage - 1)}
-                          className={movieStyles.pageButton}
-                          disabled={isSearching}
-                          aria-label="Go to previous page"
-                        >
-                          ← Previous
-                        </button>
-                      ) : (
-                        <span className={`${movieStyles.pageButton} ${movieStyles.disabled}`}>
-                          ← Previous
-                        </span>
-                      )}
-
-                      {/* Current Page Info */}
-                      <div className={movieStyles.pageInfo}>
-                        Page {searchPage}
+                  currentSearchParams?.searchType === 'mongodb-search' ? (
+                    <nav className={movieStyles.pagination} aria-label="Search results pagination">
+                      <div className={movieStyles.paginationContainer}>
+                        {/* Previous Button */}
+                        {searchHasPrevPage && !isSearching ? (
+                          <button
+                            onClick={() => handleSearchPageChange(searchPage - 1)}
+                            className={movieStyles.pageButton}
+                            disabled={isSearching}
+                            aria-label="Go to previous page"
+                          >
+                            ← Previous
+                          </button>
+                        ) : (
+                          <span className={`${movieStyles.pageButton} ${movieStyles.disabled}`}>
+                            ← Previous
+                          </span>
+                        )}
+
+                        {/* Current Page Info */}
+                        <div className={movieStyles.pageInfo}>
+                          Page {searchPage} {searchTotalCount > 0 ? `of ${Math.ceil(searchTotalCount / searchLimit)}` : ''}
+                        </div>
+
+                        {/* Next Button */}
+                        {searchHasNextPage && !isSearching ? (
+                          <button
+                            onClick={() => handleSearchPageChange(searchPage + 1)}
+                            className={movieStyles.pageButton}
+                            disabled={isSearching}
+                            aria-label="Go to next page"
+                          >
+                            Next →
+                          </button>
+                        ) : (
+                          <span className={`${movieStyles.pageButton} ${movieStyles.disabled}`}>
+                            Next →
+                          </span>
+                        )}
                       </div>
 
-                      {/* Next Button */}
-                      {searchHasNextPage ? (
-                        <button
-                          onClick={() => handleSearchPageChange(searchPage + 1)}
-                          className={movieStyles.pageButton}
-                          disabled={isSearching}
-                          aria-label="Go to next page"
-                        >
-                          Next →
-                        </button>
+                      {/* Additional Info */}
+                      <div className={movieStyles.additionalInfo}>
+                        {searchLimit} movies per page • {searchTotalCount} total results
+                      </div>
+                    </nav>
+                  ) : (
+                    /* Vector search results with client-side pagination */
+                    (() => {
+                      const { hasNext, hasPrev, totalPages } = getVectorSearchPageData();
+                      return totalPages > 1 ? (
+                        <nav className={movieStyles.pagination} aria-label="Vector search results pagination">
+                          <div className={movieStyles.paginationContainer}>
+                            {/* Previous Button */}
+                            {hasPrev ? (
+                              <button
+                                onClick={() => handleVectorSearchPageChange(vectorSearchPage - 1)}
+                                className={movieStyles.pageButton}
+                                aria-label="Go to previous page"
+                              >
+                                ← Previous
+                              </button>
+                            ) : (
+                              <span className={`${movieStyles.pageButton} ${movieStyles.disabled}`}>
+                                ← Previous
+                              </span>
+                            )}
+
+                            {/* Current Page Info */}
+                            <div className={movieStyles.pageInfo}>
+                              Page {vectorSearchPage} of {totalPages}
+                            </div>
+
+                            {/* Next Button */}
+                            {hasNext ? (
+                              <button
+                                onClick={() => handleVectorSearchPageChange(vectorSearchPage + 1)}
+                                className={movieStyles.pageButton}
+                                aria-label="Go to next page"
+                              >
+                                Next →
+                              </button>
+                            ) : (
+                              <span className={`${movieStyles.pageButton} ${movieStyles.disabled}`}>
+                                Next →
+                              </span>
+                            )}
+                          </div>
+
+                          {/* Additional Info */}
+                          <div className={movieStyles.additionalInfo}>
+                            {vectorSearchPageSize} movies per page • {allVectorSearchResults.length} total results
+                          </div>
+                        </nav>
                       ) : (
-                        <span className={`${movieStyles.pageButton} ${movieStyles.disabled}`}>
-                          Next →
-                        </span>
-                      )}
-                    </div>
-
-                    {/* Additional Info */}
-                    <div className={movieStyles.additionalInfo}>
-                      {searchLimit} movies per page
-                    </div>
-                  </nav>
+                        <div className={movieStyles.searchInfo}>
+                          Showing {allVectorSearchResults.length} results (vector search)
+                        </div>
+                      );
+                    })()
+                  )
                 ) : (
                   <Pagination
                     currentPage={page}
diff --git a/server/java-spring/src/main/java/com/mongodb/samplemflix/model/dto/VectorSearchResult.java b/server/java-spring/src/main/java/com/mongodb/samplemflix/model/dto/VectorSearchResult.java
index edcdf45..00dc38e 100644
--- a/server/java-spring/src/main/java/com/mongodb/samplemflix/model/dto/VectorSearchResult.java
+++ b/server/java-spring/src/main/java/com/mongodb/samplemflix/model/dto/VectorSearchResult.java
@@ -32,6 +32,31 @@ public class VectorSearchResult {
      */
     private String plot;
     
+    /**
+     * Movie poster URL.
+     */
+    private String poster;
+    
+    /**
+     * Movie release year.
+     */
+    private Integer year;
+    
+    /**
+     * Movie genres.
+     */
+    private java.util.List<String> genres;
+    
+    /**
+     * Movie directors.
+     */
+    private java.util.List<String> directors;
+    
+    /**
+     * Movie cast members.
+     */
+    private java.util.List<String> cast;
+    
     /**
      * Vector search similarity score (0.0 to 1.0, higher = more similar).
      */
diff --git a/server/java-spring/src/main/java/com/mongodb/samplemflix/service/MovieServiceImpl.java b/server/java-spring/src/main/java/com/mongodb/samplemflix/service/MovieServiceImpl.java
index 6248fa9..3b6ee5a 100644
--- a/server/java-spring/src/main/java/com/mongodb/samplemflix/service/MovieServiceImpl.java
+++ b/server/java-spring/src/main/java/com/mongodb/samplemflix/service/MovieServiceImpl.java
@@ -17,6 +17,7 @@
 import java.net.http.HttpResponse;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Pattern;
@@ -807,6 +808,18 @@ public List<Movie> findSimilarMovies(String movieId, Integer limit) {
         }
     }
 
+    /**
+     * Performs vector search on movie plots using MongoDB Vector Search.
+     * 
+     * This method uses a two-step process:
+     * 1. Query the embedded_movies collection (which has vector embeddings) to get movie IDs and similarity scores
+     * 2. Fetch complete movie data from the movies collection using those IDs
+     * 
+     * This approach ensures that:
+     * - Vector search works correctly with the embedded data
+     * - Returned movie objects are compatible with CRUD operations on the movies collection
+     * - Complete movie metadata is available in the response
+     */
     @Override
     public List<VectorSearchResult> vectorSearchMovies(String query, Integer limit) {
         // Validate query parameter
@@ -838,34 +851,103 @@ public List<VectorSearchResult> vectorSearchMovies(String query, Integer limit)
                     .append("limit", resultLimit)
             );
 
-            // Project the fields we need in the response
+            // Project only the fields we need from embedded_movies: _id and score
             Document projectStage = new Document("$project", new Document()
                     .append("_id", 1)
-                    .append("title", 1)
-                    .append("plot", 1)
                     .append("score", new Document("$meta", "vectorSearchScore"))
             );
 
             // Execute the aggregation pipeline on the embedded_movies collection
             List<Document> aggregationPipeline = List.of(vectorSearchStage, projectStage);
 
-            List<VectorSearchResult> results = new ArrayList<>();
+            // Step 1: Get movie IDs and scores from embedded_movies (which has the vector embeddings)
+            List<ObjectId> movieIds = new ArrayList<>();
+            Map<String, Double> scoreMap = new HashMap<>();
+
             mongoTemplate.getCollection("embedded_movies")
                     .aggregate(aggregationPipeline)
                     .forEach(doc -> {
-                        VectorSearchResult result = VectorSearchResult.builder()
-                                .id(doc.getObjectId("_id").toString())
-                                .title(doc.getString("title"))
-                                .plot(doc.getString("plot"))
-                                .score(doc.getDouble("score"))
-                                .build();
-                        results.add(result);
+                        ObjectId movieId = doc.getObjectId("_id");
+                        movieIds.add(movieId);
+                        scoreMap.put(movieId.toString(), doc.getDouble("score"));
                     });
 
+            // Step 2: Fetch complete movie data from the movies collection (for CRUD compatibility)
+            // Use aggregation to safely handle dirty data in the year field
+            List<VectorSearchResult> results = new ArrayList<>();
+
+            if (!movieIds.isEmpty()) {
+                // Build aggregation pipeline to safely convert year field
+                Document matchStage = new Document("$match", new Document("_id", new Document("$in", movieIds)));
+
+                // Project stage to safely convert year to integer, handling dirty data
+                Document projectStage2 = new Document("$project", new Document()
+                        .append("_id", 1)
+                        .append("title", 1)
+                        .append("plot", 1)
+                        .append("poster", 1)
+                        .append("genres", 1)
+                        .append("directors", 1)
+                        .append("cast", 1)
+                        // Safely convert year to integer, handling strings and dirty data
+                        .append("year", new Document("$cond", new Document()
+                                .append("if", new Document("$and", java.util.Arrays.asList(
+                                        new Document("$ne", java.util.Arrays.asList("$year", null)),
+                                        new Document("$eq", java.util.Arrays.asList(new Document("$type", "$year"), "int"))
+                                )))
+                                .append("then", "$year")
+                                .append("else", null)
+                        ))
+                );
+
+                List<Document> moviePipeline = List.of(matchStage, projectStage2);
+
+                // Execute aggregation and manually build VectorSearchResult objects
+                mongoTemplate.getCollection("movies").aggregate(moviePipeline)
+                        .forEach(doc -> {
+                            ObjectId movieIdObj = doc.getObjectId("_id");
+                            if (movieIdObj == null) {
+                                return;
+                            }
+
+                            String movieIdStr = movieIdObj.toString();
+                            Double score = scoreMap.get(movieIdStr);
+
+                            if (score != null) {  // Only include movies that have vector scores
+                                // Safely get list fields, defaulting to null if not present
+                                List<String> genres = doc.getList("genres", String.class);
+                                List<String> directors = doc.getList("directors", String.class);
+                                List<String> cast = doc.getList("cast", String.class);
+
+                                VectorSearchResult result = VectorSearchResult.builder()
+                                        .id(movieIdStr)
+                                        .title(doc.getString("title"))
+                                        .plot(doc.getString("plot"))
+                                        .poster(doc.getString("poster"))
+                                        .year(doc.getInteger("year"))  // Will be null for dirty data
+                                        .genres(genres)
+                                        .directors(directors)
+                                        .cast(cast)
+                                        .score(score)
+                                        .build();
+                                results.add(result);
+                            }
+                        });
+            }
+
             return results;
 
+        } catch (IOException e) {
+            // Handle Voyage AI API errors
+            String errorMsg = e.getMessage() != null ? e.getMessage() : "Network error calling Voyage AI API";
+            throw new DatabaseOperationException("Error performing vector search: " + errorMsg);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new DatabaseOperationException("Vector search was interrupted");
         } catch (Exception e) {
-            throw new DatabaseOperationException("Error performing vector search: " + e.getMessage());
+            // Handle other errors (e.g., MongoDB errors, parsing errors)
+            String errorMsg = e.getMessage() != null ? e.getMessage() : e.getClass().getSimpleName();
+            throw new DatabaseOperationException("Error performing vector search: " + errorMsg);
         }
     }
 
@@ -911,7 +993,26 @@ private List<Double> generateVoyageEmbedding(String text, String apiKey) throws
         // Parse the JSON response to extract the embedding
         ObjectMapper mapper = new ObjectMapper();
         JsonNode root = mapper.readTree(response.body());
-        JsonNode embeddingNode = root.path("data").get(0).path("embedding");
+
+        // Validate response structure
+        if (!root.has("data")) {
+            throw new IOException("Invalid Voyage AI API response: missing 'data' field. Response: " + response.body());
+        }
+
+        JsonNode dataNode = root.get("data");
+        if (dataNode == null || !dataNode.isArray() || dataNode.size() == 0) {
+            throw new IOException("Invalid Voyage AI API response: 'data' field is empty or not an array. Response: " + response.body());
+        }
+
+        JsonNode firstElement = dataNode.get(0);
+        if (firstElement == null || !firstElement.has("embedding")) {
+            throw new IOException("Invalid Voyage AI API response: missing 'embedding' field. Response: " + response.body());
+        }
+
+        JsonNode embeddingNode = firstElement.get("embedding");
+        if (embeddingNode == null || !embeddingNode.isArray()) {
+            throw new IOException("Invalid Voyage AI API response: 'embedding' is not an array. Response: " + response.body());
+        }
 
         // Convert the embedding to a List<Double>
         List<Double> embedding = new ArrayList<>();
diff --git a/server/python/src/models/models.py b/server/python/src/models/models.py
index f6d5dda..8c2528a 100644
--- a/server/python/src/models/models.py
+++ b/server/python/src/models/models.py
@@ -120,6 +120,11 @@ class VectorSearchResult(BaseModel):
     id: Optional[str] = Field(alias="_id")
     title: str
     plot: Optional[str] = None
+    poster: Optional[str] = None
+    year: Optional[int] = None
+    genres: Optional[list[str]] = None
+    directors: Optional[list[str]] = None
+    cast: Optional[list[str]] = None
     score: float
 
     model_config = {
diff --git a/server/python/src/routers/movies.py b/server/python/src/routers/movies.py
index df4c213..a1b3d3f 100644
--- a/server/python/src/routers/movies.py
+++ b/server/python/src/routers/movies.py
@@ -1,5 +1,5 @@
 from fastapi import APIRouter, Query, Path, Body
-from src.database.mongo_client import db, get_collection
+from src.database.mongo_client import db, get_collection, voyage_ai_available
 from src.models.models import VectorSearchResult, CreateMovieRequest, Movie, MovieFilter, SuccessResponse, UpdateMovieRequest, SearchMoviesResponse, BatchUpdateRequest, BatchDeleteRequest
 
 from typing import List
@@ -340,6 +340,22 @@ async def vector_search_movies(
                     "_id": 1,
                     "title": 1,
                     "plot": 1,
+                    "poster": 1,
+                    "year": {
+                        "$cond": {
+                            "if": {
+                                "$and": [
+                                    {"$ne": ["$year", None]},
+                                    {"$eq": [{"$type": "$year"}, "int"]}
+                                ]
+                            },
+                            "then": "$year",
+                            "else": None
+                        }
+                    },
+                    "genres": 1,
+                    "directors": 1,
+                    "cast": 1,
                     "score": {
                         "$meta": "vectorSearchScore"
                     }