diff --git a/src/collections/collection/index.ts b/src/collections/collection/index.ts
index 3fa1108c..c4164352 100644
--- a/src/collections/collection/index.ts
+++ b/src/collections/collection/index.ts
@@ -14,7 +14,7 @@ import { Iterator } from '../iterator/index.js';
 import query, { Query } from '../query/index.js';
 import sort, { Sort } from '../sort/index.js';
 import tenants, { TenantBase, Tenants } from '../tenants/index.js';
-import { QueryMetadata, QueryProperty, QueryReference } from '../types/index.js';
+import { QueryMetadata, QueryProperty, QueryReference, ReturnVectors } from '../types/index.js';
 import { IncludeVector } from '../types/internal.js';
 import multiTargetVector, { MultiTargetVector } from '../vectors/multiTargetVector.js';
 
@@ -55,15 +55,19 @@ export interface Collection<T = undefined, N = string, V = undefined> {
    * This iterator keeps a record of the last object that it returned to be used in each subsequent call to Weaviate.
    * Once the collection is exhausted, the iterator exits.
    *
+   * @typeParam I - The vector(s) to include in the response. If using named vectors, pass an array of strings to include only specific vectors.
+   * @typeParam RV - The vectors(s) to be returned in the response depending on the input in opts.includeVector.
    * @param {IteratorOptions<T>} opts The options to use when fetching objects from Weaviate.
    * @returns {Iterator<T>} An iterator over the objects in the collection as an async generator.
    *
    * @description If `return_properties` is not provided, all the properties of each object will be
    * requested from Weaviate except for its vector as this is an expensive operation. Specify `include_vector`
-   * to request the vector back as well. In addition, if `return_references=None` then none of the references
+   * to request the vectors back as well. In addition, if `return_references=None` then none of the references
    * are returned. Use `wvc.QueryReference` to specify which references to return.
    */
-  iterator: (opts?: IteratorOptions<T, V>) => Iterator<T, V>;
+  iterator: <I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    opts?: IteratorOptions<T, I>
+  ) => Iterator<T, RV>;
   /**
    * Use this method to return the total number of objects in the collection.
    *
@@ -95,8 +99,8 @@ export interface Collection<T = undefined, N = string, V = undefined> {
   withTenant: <TT extends TenantBase>(tenant: string | TT) => Collection<T, N, V>;
 }
 
-export type IteratorOptions<T, V> = {
-  includeVector?: IncludeVector<V>;
+export type IteratorOptions<T, I> = {
+  includeVector?: I;
   returnMetadata?: QueryMetadata;
   returnProperties?: QueryProperty<T>[];
   returnReferences?: QueryReference<T>[];
@@ -146,10 +150,10 @@ const collection = <T, N, V>(
     sort: sort<T>(),
     tenants: tenants(connection, capitalizedName, dbVersionSupport),
     exists: () => new ClassExists(connection).withClassName(capitalizedName).do(),
-    iterator: (opts?: IteratorOptions<T, V>) =>
-      new Iterator<T, V>((limit: number, after?: string) =>
+    iterator: <I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(opts?: IteratorOptions<T, I>) =>
+      new Iterator<T, RV>((limit: number, after?: string) =>
         queryCollection
-          .fetchObjects({
+          .fetchObjects<I, RV>({
             limit,
             after,
             includeVector: opts?.includeVector,
diff --git a/src/collections/generate/index.ts b/src/collections/generate/index.ts
index 381e29d4..db532b71 100644
--- a/src/collections/generate/index.ts
+++ b/src/collections/generate/index.ts
@@ -33,7 +33,9 @@ import {
   GenerativeGroupByReturn,
   GenerativeReturn,
   GroupByOptions,
+  ReturnVectors,
 } from '../types/index.js';
+import { IncludeVector } from '../types/internal.js';
 import { Generate } from './types.js';
 
 class GenerateManager<T, V> implements Generate<T, V> {
@@ -55,19 +57,19 @@ class GenerateManager<T, V> implements Generate<T, V> {
     );
   }
 
-  private async parseReply<C extends GenerativeConfigRuntime | undefined>(reply: SearchReply) {
+  private async parseReply<RV, C extends GenerativeConfigRuntime | undefined>(reply: SearchReply) {
     const deserialize = await Deserialize.use(this.check.dbVersionSupport);
-    return deserialize.generate<T, V, C>(reply);
+    return deserialize.generate<T, RV, C>(reply);
   }
 
-  private async parseGroupByReply<C extends GenerativeConfigRuntime | undefined>(
-    opts: SearchOptions<T, V> | GroupByOptions<T> | undefined,
+  private async parseGroupByReply<RV, C extends GenerativeConfigRuntime | undefined>(
+    opts: SearchOptions<any, any> | GroupByOptions<any> | undefined,
     reply: SearchReply
   ) {
     const deserialize = await Deserialize.use(this.check.dbVersionSupport);
     return Serialize.search.isGroupBy(opts)
-      ? deserialize.generateGroupBy<T, V>(reply)
-      : deserialize.generate<T, V, C>(reply);
+      ? deserialize.generateGroupBy<T, RV>(reply)
+      : deserialize.generate<T, RV, C>(reply);
   }
 
   public fetchObjects<C extends GenerativeConfigRuntime | undefined = undefined>(
@@ -90,21 +92,29 @@ class GenerateManager<T, V> implements Generate<T, V> {
       .then((reply) => this.parseReply(reply));
   }
 
-  public bm25<C extends GenerativeConfigRuntime | undefined = undefined>(
+  public bm25<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts?: BaseBm25Options<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
-  public bm25<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts?: BaseBm25Options<T, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
+  public bm25<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts: GroupByBm25Options<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
-  public bm25<C extends GenerativeConfigRuntime | undefined = undefined>(
-    query: string,
-    generate: GenerateOptions<T, C>,
-    opts?: Bm25Options<T, V>
-  ): GenerateReturn<T, V, C> {
+    opts: GroupByBm25Options<T, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
+  public bm25<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(query: string, generate: GenerateOptions<T, C>, opts?: Bm25Options<T, I>): GenerateReturn<T, RV, C> {
     return Promise.all([
       this.check.bm25(opts),
       this.check.supportForSingleGroupedGenerative(),
@@ -121,21 +131,29 @@ class GenerateManager<T, V> implements Generate<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public hybrid<C extends GenerativeConfigRuntime | undefined = undefined>(
-    query: string,
-    generate: GenerateOptions<T, C>,
-    opts?: BaseHybridOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
-  public hybrid<C extends GenerativeConfigRuntime | undefined = undefined>(
+  public hybrid<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts: GroupByHybridOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
-  public hybrid<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts?: BaseHybridOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
+  public hybrid<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts?: HybridOptions<T, V>
-  ): GenerateReturn<T, V, C> {
+    opts: GroupByHybridOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
+  public hybrid<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(query: string, generate: GenerateOptions<T, C>, opts?: HybridOptions<T, V, I>): GenerateReturn<T, RV, C> {
     return Promise.all([
       this.check.hybridSearch(opts),
       this.check.supportForSingleGroupedGenerative(),
@@ -166,21 +184,33 @@ class GenerateManager<T, V> implements Generate<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearImage<C extends GenerativeConfigRuntime | undefined = undefined>(
+  public nearImage<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     image: string | Buffer,
     generate: GenerateOptions<T, C>,
-    opts?: BaseNearOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
-  public nearImage<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
+  public nearImage<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     image: string | Buffer,
     generate: GenerateOptions<T, C>,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
-  public nearImage<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
+  public nearImage<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     image: string | Buffer,
     generate: GenerateOptions<T, C>,
-    opts?: NearOptions<T, V>
-  ): GenerateReturn<T, V, C> {
+    opts?: NearOptions<T, V, I>
+  ): GenerateReturn<T, RV, C> {
     return Promise.all([
       this.check.nearSearch(opts),
       this.check.supportForSingleGroupedGenerative(),
@@ -204,21 +234,29 @@ class GenerateManager<T, V> implements Generate<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearObject<C extends GenerativeConfigRuntime | undefined = undefined>(
-    id: string,
-    generate: GenerateOptions<T, C>,
-    opts?: BaseNearOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
-  public nearObject<C extends GenerativeConfigRuntime | undefined = undefined>(
+  public nearObject<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     id: string,
     generate: GenerateOptions<T, C>,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
-  public nearObject<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
+  public nearObject<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     id: string,
     generate: GenerateOptions<T, C>,
-    opts?: NearOptions<T, V>
-  ): GenerateReturn<T, V, C> {
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
+  public nearObject<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(id: string, generate: GenerateOptions<T, C>, opts?: NearOptions<T, V, I>): GenerateReturn<T, RV, C> {
     return Promise.all([
       this.check.nearSearch(opts),
       this.check.supportForSingleGroupedGenerative(),
@@ -242,21 +280,33 @@ class GenerateManager<T, V> implements Generate<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearText<C extends GenerativeConfigRuntime | undefined = undefined>(
+  public nearText<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string | string[],
     generate: GenerateOptions<T, C>,
-    opts?: BaseNearTextOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
-  public nearText<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts?: BaseNearTextOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
+  public nearText<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string | string[],
     generate: GenerateOptions<T, C>,
-    opts: GroupByNearTextOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
-  public nearText<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts: GroupByNearTextOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
+  public nearText<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string | string[],
     generate: GenerateOptions<T, C>,
-    opts?: NearOptions<T, V>
-  ): GenerateReturn<T, V, C> {
+    opts?: NearOptions<T, V, I>
+  ): GenerateReturn<T, RV, C> {
     return Promise.all([
       this.check.nearSearch(opts),
       this.check.supportForSingleGroupedGenerative(),
@@ -280,21 +330,33 @@ class GenerateManager<T, V> implements Generate<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearVector<C extends GenerativeConfigRuntime | undefined = undefined>(
+  public nearVector<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     vector: number[],
     generate: GenerateOptions<T, C>,
-    opts?: BaseNearOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
-  public nearVector<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
+  public nearVector<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     vector: number[],
     generate: GenerateOptions<T, C>,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
-  public nearVector<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
+  public nearVector<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     vector: number[],
     generate: GenerateOptions<T, C>,
-    opts?: NearOptions<T, V>
-  ): GenerateReturn<T, V, C> {
+    opts?: NearOptions<T, V, I>
+  ): GenerateReturn<T, RV, C> {
     return Promise.all([
       this.check.nearVector(vector, opts),
       this.check.supportForSingleGroupedGenerative(),
@@ -325,24 +387,36 @@ class GenerateManager<T, V> implements Generate<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearMedia<C extends GenerativeConfigRuntime | undefined = undefined>(
+  public nearMedia<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     media: string | Buffer,
     type: NearMediaType,
     generate: GenerateOptions<T, C>,
-    opts?: BaseNearOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
-  public nearMedia<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
+  public nearMedia<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     media: string | Buffer,
     type: NearMediaType,
     generate: GenerateOptions<T, C>,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
-  public nearMedia<C extends GenerativeConfigRuntime | undefined = undefined>(
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
+  public nearMedia<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     media: string | Buffer,
     type: NearMediaType,
     generate: GenerateOptions<T, C>,
-    opts?: NearOptions<T, V>
-  ): GenerateReturn<T, V, C> {
+    opts?: NearOptions<T, V, I>
+  ): GenerateReturn<T, RV, C> {
     return Promise.all([
       this.check.nearSearch(opts),
       this.check.supportForSingleGroupedGenerative(),
diff --git a/src/collections/generate/types.ts b/src/collections/generate/types.ts
index f29160ec..b9022f7c 100644
--- a/src/collections/generate/types.ts
+++ b/src/collections/generate/types.ts
@@ -21,7 +21,9 @@ import {
   GenerativeConfigRuntime,
   GenerativeGroupByReturn,
   GenerativeReturn,
+  ReturnVectors,
 } from '../types/index.js';
+import { IncludeVector } from '../types/internal.js';
 
 interface Bm25<T, V> {
   /**
@@ -36,11 +38,15 @@ interface Bm25<T, V> {
    * @param {BaseBm25Options<T, V>} [opts] - The available options for performing the BM25 search.
    * @return {Promise<GenerativeReturn<T, V, C>>} - The results of the search including the generated data.
    */
-  bm25<C extends GenerativeConfigRuntime | undefined = undefined>(
+  bm25<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts?: BaseBm25Options<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
+    opts?: BaseBm25Options<T, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a keyword-based BM25 search of objects in this collection.
    *
@@ -53,11 +59,15 @@ interface Bm25<T, V> {
    * @param {GroupByBm25Options<T, V>} opts - The available options for performing the BM25 search.
    * @return {Promise<GenerativeGroupByReturn<T, V, C>>} - The results of the search including the generated data grouped by the specified properties.
    */
-  bm25<C extends GenerativeConfigRuntime | undefined = undefined>(
+  bm25<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts: GroupByBm25Options<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
+    opts: GroupByBm25Options<T, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a keyword-based BM25 search of objects in this collection.
    *
@@ -70,11 +80,15 @@ interface Bm25<T, V> {
    * @param {Bm25Options<T, V>} [opts] - The available options for performing the BM25 search.
    * @return {GenerateReturn<T, V, C>} - The results of the search including the generated data.
    */
-  bm25<C extends GenerativeConfigRuntime | undefined = undefined>(
+  bm25<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts?: Bm25Options<T, V>
-  ): GenerateReturn<T, V, C>;
+    opts?: Bm25Options<T, I>
+  ): GenerateReturn<T, RV, C>;
 }
 
 interface Hybrid<T, V> {
@@ -90,11 +104,15 @@ interface Hybrid<T, V> {
    * @param {BaseHybridOptions<T, V>} [opts] - The available options for performing the hybrid search.
    * @return {Promise<GenerativeReturn<T, V, C>>} - The results of the search including the generated data.
    */
-  hybrid<C extends GenerativeConfigRuntime | undefined = undefined>(
+  hybrid<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts?: BaseHybridOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
+    opts?: BaseHybridOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of an object search in this collection using the hybrid algorithm blending keyword-based BM25 and vector-based similarity.
    *
@@ -107,11 +125,15 @@ interface Hybrid<T, V> {
    * @param {GroupByHybridOptions<T, V>} opts - The available options for performing the hybrid search.
    * @return {Promise<GenerativeGroupByReturn<T, V, C>>} - The results of the search including the generated data grouped by the specified properties.
    */
-  hybrid<C extends GenerativeConfigRuntime | undefined = undefined>(
+  hybrid<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts: GroupByHybridOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
+    opts: GroupByHybridOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of an object search in this collection using the hybrid algorithm blending keyword-based BM25 and vector-based similarity.
    *
@@ -124,11 +146,15 @@ interface Hybrid<T, V> {
    * @param {HybridOptions<T, V>} [opts] - The available options for performing the hybrid search.
    * @return {GenerateReturn<T, V, C>} - The results of the search including the generated data.
    */
-  hybrid<C extends GenerativeConfigRuntime | undefined = undefined>(
+  hybrid<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string,
     generate: GenerateOptions<T, C>,
-    opts?: HybridOptions<T, V>
-  ): GenerateReturn<T, V, C>;
+    opts?: HybridOptions<T, V, I>
+  ): GenerateReturn<T, RV, C>;
 }
 
 interface NearMedia<T, V> {
@@ -147,12 +173,16 @@ interface NearMedia<T, V> {
    * @param {BaseNearOptions<T, V>} [opts] - The available options for performing the near-media search.
    * @return {Promise<GenerativeReturn<T, V, C>>} - The results of the search including the generated data.
    */
-  nearMedia<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearMedia<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     media: string | Buffer,
     type: NearMediaType,
     generate: GenerateOptions<T, C>,
-    opts?: BaseNearOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a by-audio object search in this collection using an audio-capable vectorization module and vector-based similarity search.
    *
@@ -168,12 +198,16 @@ interface NearMedia<T, V> {
    * @param {GroupByNearOptions<T, V>} opts - The available options for performing the near-media search.
    * @return {Promise<GenerativeGroupByReturn<T, V, C>>} - The results of the search including the generated data grouped by the specified properties.
    */
-  nearMedia<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearMedia<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     media: string | Buffer,
     type: NearMediaType,
     generate: GenerateOptions<T, C>,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a by-audio object search in this collection using an audio-capable vectorization module and vector-based similarity search.
    *
@@ -189,12 +223,16 @@ interface NearMedia<T, V> {
    * @param {NearOptions<T, V>} [opts] - The available options for performing the near-media search.
    * @return {GenerateReturn<T, V, C>} - The results of the search including the generated data.
    */
-  nearMedia<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearMedia<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     media: string | Buffer,
     type: NearMediaType,
     generate: GenerateOptions<T, C>,
-    opts?: NearOptions<T, V>
-  ): GenerateReturn<T, V, C>;
+    opts?: NearOptions<T, V, I>
+  ): GenerateReturn<T, RV, C>;
 }
 
 interface NearObject<T, V> {
@@ -210,11 +248,15 @@ interface NearObject<T, V> {
    * @param {BaseNearOptions<T, V>} [opts] - The available options for performing the near-object search.
    * @return {Promise<GenerativeReturn<T, V, C>>} - The results of the search including the generated data.
    */
-  nearObject<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearObject<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     id: string,
     generate: GenerateOptions<T, C>,
-    opts?: BaseNearOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a by-object object search in this collection using a vector-based similarity search.
    *
@@ -227,11 +269,15 @@ interface NearObject<T, V> {
    * @param {GroupByNearOptions<T, V>} opts - The available options for performing the near-object search.
    * @return {Promise<GenerativeGroupByReturn<T, V, C>>} - The results of the search including the generated data grouped by the specified properties.
    */
-  nearObject<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearObject<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     id: string,
     generate: GenerateOptions<T, C>,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a by-object object search in this collection using a vector-based similarity search.
    *
@@ -244,11 +290,15 @@ interface NearObject<T, V> {
    * @param {NearOptions<T, V>} [opts] - The available options for performing the near-object search.
    * @return {GenerateReturn<T, V, C>} - The results of the search including the generated data.
    */
-  nearObject<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearObject<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     id: string,
     generate: GenerateOptions<T, C>,
-    opts?: NearOptions<T, V>
-  ): GenerateReturn<T, V, C>;
+    opts?: NearOptions<T, V, I>
+  ): GenerateReturn<T, RV, C>;
 }
 
 interface NearText<T, V> {
@@ -266,11 +316,15 @@ interface NearText<T, V> {
    * @param {BaseNearTextOptions<T, V>} [opts] - The available options for performing the near-text search.
    * @return {Promise<GenerativeReturn<T, V, C>>} - The results of the search including the generated data.
    */
-  nearText<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearText<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string | string[],
     generate: GenerateOptions<T, C>,
-    opts?: BaseNearTextOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
+    opts?: BaseNearTextOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a by-image object search in this collection using the image-capable vectorization module and vector-based similarity search.
    *
@@ -285,11 +339,15 @@ interface NearText<T, V> {
    * @param {GroupByNearTextOptions<T, V>} opts - The available options for performing the near-text search.
    * @return {Promise<GenerativeGroupByReturn<T, V, C>>} - The results of the search including the generated data grouped by the specified properties.
    */
-  nearText<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearText<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string | string[],
     generate: GenerateOptions<T, C>,
-    opts: GroupByNearTextOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
+    opts: GroupByNearTextOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a by-image object search in this collection using the image-capable vectorization module and vector-based similarity search.
    *
@@ -304,11 +362,15 @@ interface NearText<T, V> {
    * @param {NearTextOptions<T, V>} [opts] - The available options for performing the near-text search.
    * @return {GenerateReturn<T, V, C>} - The results of the search including the generated data.
    */
-  nearText<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearText<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     query: string | string[],
     generate: GenerateOptions<T, C>,
-    opts?: NearTextOptions<T, V>
-  ): GenerateReturn<T, V, C>;
+    opts?: NearTextOptions<T, V, I>
+  ): GenerateReturn<T, RV, C>;
 }
 
 interface NearVector<T, V> {
@@ -324,11 +386,15 @@ interface NearVector<T, V> {
    * @param {BaseNearOptions<T, V>} [opts] - The available options for performing the near-vector search.
    * @return {Promise<GenerativeReturn<T, V, C>>} - The results of the search including the generated data.
    */
-  nearVector<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearVector<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     vector: NearVectorInputType,
     generate: GenerateOptions<T, C>,
-    opts?: BaseNearOptions<T, V>
-  ): Promise<GenerativeReturn<T, V, C>>;
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<GenerativeReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a by-vector object search in this collection using vector-based similarity search.
    *
@@ -341,11 +407,15 @@ interface NearVector<T, V> {
    * @param {GroupByNearOptions<T, V>} opts - The available options for performing the near-vector search.
    * @return {Promise<GenerativeGroupByReturn<T, V, C>>} - The results of the search including the generated data grouped by the specified properties.
    */
-  nearVector<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearVector<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     vector: NearVectorInputType,
     generate: GenerateOptions<T, C>,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GenerativeGroupByReturn<T, V, C>>;
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GenerativeGroupByReturn<T, RV, C>>;
   /**
    * Perform retrieval-augmented generation (RaG) on the results of a by-vector object search in this collection using vector-based similarity search.
    *
@@ -358,11 +428,15 @@ interface NearVector<T, V> {
    * @param {NearOptions<T, V>} [opts] - The available options for performing the near-vector search.
    * @return {GenerateReturn<T, V, C>} - The results of the search including the generated data.
    */
-  nearVector<C extends GenerativeConfigRuntime | undefined = undefined>(
+  nearVector<
+    I extends IncludeVector<V>,
+    RV extends ReturnVectors<V, I>,
+    C extends GenerativeConfigRuntime | undefined = undefined
+  >(
     vector: NearVectorInputType,
     generate: GenerateOptions<T, C>,
-    opts?: NearOptions<T, V>
-  ): GenerateReturn<T, V, C>;
+    opts?: NearOptions<T, V, I>
+  ): GenerateReturn<T, RV, C>;
 }
 
 export interface Generate<T, V>
diff --git a/src/collections/query/check.ts b/src/collections/query/check.ts
index c090cadc..8cc1230f 100644
--- a/src/collections/query/check.ts
+++ b/src/collections/query/check.ts
@@ -40,7 +40,7 @@ export class Check<T, V> {
 
   private getSearcher = () => this.connection.search(this.name, this.consistencyLevel, this.tenant);
 
-  private checkSupportForNamedVectors = async (opts?: BaseNearOptions<T, V>) => {
+  private checkSupportForNamedVectors = async (opts?: BaseNearOptions<any, any, any>) => {
     if (!Serialize.isNamedVectors(opts)) return;
     const check = await this.dbVersionSupport.supportsNamedVectors();
     if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message);
@@ -48,20 +48,22 @@ export class Check<T, V> {
 
   private checkSupportForBm25AndHybridGroupByQueries = async (
     query: 'Bm25' | 'Hybrid',
-    opts?: SearchOptions<T, V> | GroupByOptions<T>
+    opts?: SearchOptions<any, any> | GroupByOptions<any>
   ) => {
     if (!Serialize.search.isGroupBy(opts)) return;
     const check = await this.dbVersionSupport.supportsBm25AndHybridGroupByQueries();
     if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message(query));
   };
 
-  private checkSupportForHybridNearTextAndNearVectorSubSearches = async (opts?: HybridOptions<T, V>) => {
+  private checkSupportForHybridNearTextAndNearVectorSubSearches = async (
+    opts?: HybridOptions<any, any, any>
+  ) => {
     if (opts?.vector === undefined || Array.isArray(opts.vector)) return;
     const check = await this.dbVersionSupport.supportsHybridNearTextAndNearVectorSubsearchQueries();
     if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message);
   };
 
-  private checkSupportForMultiTargetSearch = async (opts?: BaseNearOptions<T, V>) => {
+  private checkSupportForMultiTargetSearch = async (opts?: BaseNearOptions<any, any, any>) => {
     if (!Serialize.isMultiTarget(opts)) return false;
     const check = await this.dbVersionSupport.supportsMultiTargetVectorSearch();
     if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message);
@@ -79,7 +81,7 @@ export class Check<T, V> {
     return check.supports;
   };
 
-  private checkSupportForMultiWeightPerTargetSearch = async (opts?: BaseNearOptions<T, V>) => {
+  private checkSupportForMultiWeightPerTargetSearch = async (opts?: BaseNearOptions<any, any, any>) => {
     if (!Serialize.isMultiWeightPerTarget(opts)) return false;
     const check = await this.dbVersionSupport.supportsMultiWeightsPerTargetSearch();
     if (!check.supports) throw new WeaviateUnsupportedFeatureError(check.message);
@@ -119,7 +121,7 @@ export class Check<T, V> {
     return check.supports;
   };
 
-  public nearSearch = (opts?: BaseNearOptions<T, V>) => {
+  public nearSearch = (opts?: BaseNearOptions<any, any, any>) => {
     return Promise.all([
       this.getSearcher(),
       this.checkSupportForMultiTargetSearch(opts),
@@ -132,7 +134,7 @@ export class Check<T, V> {
     });
   };
 
-  public nearVector = (vec: NearVectorInputType, opts?: BaseNearOptions<T, V>) => {
+  public nearVector = (vec: NearVectorInputType, opts?: BaseNearOptions<any, any, any>) => {
     return Promise.all([
       this.getSearcher(),
       this.checkSupportForMultiTargetSearch(opts),
@@ -164,7 +166,7 @@ export class Check<T, V> {
     );
   };
 
-  public hybridSearch = (opts?: BaseHybridOptions<T, V>) => {
+  public hybridSearch = (opts?: BaseHybridOptions<any, any, any>) => {
     return Promise.all([
       this.getSearcher(),
       this.checkSupportForMultiTargetSearch(opts),
@@ -198,19 +200,19 @@ export class Check<T, V> {
     );
   };
 
-  public fetchObjects = (opts?: FetchObjectsOptions<T, V>) => {
+  public fetchObjects = (opts?: FetchObjectsOptions<any, any>) => {
     return Promise.all([this.getSearcher(), this.checkSupportForNamedVectors(opts)]).then(([search]) => {
       return { search };
     });
   };
 
-  public fetchObjectById = (opts?: FetchObjectByIdOptions<T, V>) => {
+  public fetchObjectById = (opts?: FetchObjectByIdOptions<any, any>) => {
     return Promise.all([this.getSearcher(), this.checkSupportForNamedVectors(opts)]).then(([search]) => {
       return { search };
     });
   };
 
-  public bm25 = (opts?: BaseBm25Options<T, V>) => {
+  public bm25 = (opts?: BaseBm25Options<any, any>) => {
     return Promise.all([
       this.getSearcher(),
       this.checkSupportForNamedVectors(opts),
diff --git a/src/collections/query/index.ts b/src/collections/query/index.ts
index 1dda49bf..81581502 100644
--- a/src/collections/query/index.ts
+++ b/src/collections/query/index.ts
@@ -8,9 +8,16 @@ import { DbVersionSupport } from '../../utils/dbVersion.js';
 import { SearchReply } from '../../proto/v1/search_get.js';
 import { Deserialize } from '../deserialize/index.js';
 import { Serialize } from '../serialize/index.js';
-import { GroupByOptions, GroupByReturn, WeaviateObject, WeaviateReturn } from '../types/index.js';
+import {
+  GroupByOptions,
+  GroupByReturn,
+  ReturnVectors,
+  WeaviateObject,
+  WeaviateReturn,
+} from '../types/index.js';
 
 import { WeaviateInvalidInputError } from '../../errors.js';
+import { IncludeVector } from '../types/internal.js';
 import { Check } from './check.js';
 import {
   BaseBm25Options,
@@ -53,51 +60,71 @@ class QueryManager<T, V> implements Query<T, V> {
     );
   }
 
-  private async parseReply(reply: SearchReply) {
+  private async parseReply<RV>(reply: SearchReply) {
     const deserialize = await Deserialize.use(this.check.dbVersionSupport);
-    return deserialize.query<T, V>(reply);
+    return deserialize.query<T, RV>(reply);
   }
 
-  private async parseGroupByReply(
-    opts: SearchOptions<T, V> | GroupByOptions<T> | undefined,
+  private async parseGroupByReply<RV>(
+    opts: SearchOptions<any, any> | GroupByOptions<any> | undefined,
     reply: SearchReply
   ) {
     const deserialize = await Deserialize.use(this.check.dbVersionSupport);
     return Serialize.search.isGroupBy(opts)
-      ? deserialize.queryGroupBy<T, V>(reply)
-      : deserialize.query<T, V>(reply);
+      ? deserialize.queryGroupBy<T, RV>(reply)
+      : deserialize.query<T, RV>(reply);
   }
 
-  public fetchObjectById(
+  public fetchObjectById<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
     id: string,
-    opts?: FetchObjectByIdOptions<T, V>
-  ): Promise<WeaviateObject<T, V> | null> {
+    opts?: FetchObjectByIdOptions<T, I>
+  ): Promise<WeaviateObject<T, RV> | null> {
     return this.check
       .fetchObjectById(opts)
       .then(({ search }) => search.withFetch(Serialize.search.fetchObjectById({ id, ...opts })))
-      .then((reply) => this.parseReply(reply))
+      .then((reply) => this.parseReply<RV>(reply))
       .then((ret) => (ret.objects.length === 1 ? ret.objects[0] : null));
   }
 
-  public fetchObjects(opts?: FetchObjectsOptions<T, V>): Promise<WeaviateReturn<T, V>> {
+  public fetchObjects<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    opts?: FetchObjectsOptions<T, I>
+  ): Promise<WeaviateReturn<T, RV>> {
     return this.check
       .fetchObjects(opts)
       .then(({ search }) => search.withFetch(Serialize.search.fetchObjects(opts)))
       .then((reply) => this.parseReply(reply));
   }
 
-  public bm25(query: string, opts?: BaseBm25Options<T, V>): Promise<WeaviateReturn<T, V>>;
-  public bm25(query: string, opts: GroupByBm25Options<T, V>): Promise<GroupByReturn<T, V>>;
-  public bm25(query: string, opts?: Bm25Options<T, V>): QueryReturn<T, V> {
+  public bm25<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts?: BaseBm25Options<T, I>
+  ): Promise<WeaviateReturn<T, RV>>;
+  public bm25<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts: GroupByBm25Options<T, I>
+  ): Promise<GroupByReturn<T, RV>>;
+  public bm25<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts?: Bm25Options<T, I>
+  ): QueryReturn<T, RV> {
     return this.check
       .bm25(opts)
       .then(({ search }) => search.withBm25(Serialize.search.bm25(query, opts)))
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public hybrid(query: string, opts?: BaseHybridOptions<T, V>): Promise<WeaviateReturn<T, V>>;
-  public hybrid(query: string, opts: GroupByHybridOptions<T, V>): Promise<GroupByReturn<T, V>>;
-  public hybrid(query: string, opts?: HybridOptions<T, V>): QueryReturn<T, V> {
+  public hybrid<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts?: BaseHybridOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
+  public hybrid<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts: GroupByHybridOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
+  public hybrid<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts?: HybridOptions<T, V, I>
+  ): QueryReturn<T, RV> {
     return this.check
       .hybridSearch(opts)
       .then(
@@ -125,9 +152,18 @@ class QueryManager<T, V> implements Query<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearImage(image: string | Buffer, opts?: BaseNearOptions<T, V>): Promise<WeaviateReturn<T, V>>;
-  public nearImage(image: string | Buffer, opts: GroupByNearOptions<T, V>): Promise<GroupByReturn<T, V>>;
-  public nearImage(image: string | Buffer, opts?: NearOptions<T, V>): QueryReturn<T, V> {
+  public nearImage<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    image: string | Buffer,
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
+  public nearImage<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    image: string | Buffer,
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
+  public nearImage<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    image: string | Buffer,
+    opts?: NearOptions<T, V, I>
+  ): QueryReturn<T, RV> {
     return this.check
       .nearSearch(opts)
       .then(({ search, supportsTargets, supportsWeightsForTargets }) => {
@@ -147,17 +183,21 @@ class QueryManager<T, V> implements Query<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearMedia(
+  public nearMedia<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    media: string | Buffer,
+    type: NearMediaType,
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
+  public nearMedia<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
     media: string | Buffer,
     type: NearMediaType,
-    opts?: BaseNearOptions<T, V>
-  ): Promise<WeaviateReturn<T, V>>;
-  public nearMedia(
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
+  public nearMedia<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
     media: string | Buffer,
     type: NearMediaType,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GroupByReturn<T, V>>;
-  public nearMedia(media: string | Buffer, type: NearMediaType, opts?: NearOptions<T, V>): QueryReturn<T, V> {
+    opts?: NearOptions<T, V, I>
+  ): QueryReturn<T, RV> {
     return this.check
       .nearSearch(opts)
       .then(({ search, supportsTargets, supportsWeightsForTargets }) => {
@@ -197,9 +237,18 @@ class QueryManager<T, V> implements Query<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearObject(id: string, opts?: BaseNearOptions<T, V>): Promise<WeaviateReturn<T, V>>;
-  public nearObject(id: string, opts: GroupByNearOptions<T, V>): Promise<GroupByReturn<T, V>>;
-  public nearObject(id: string, opts?: NearOptions<T, V>): QueryReturn<T, V> {
+  public nearObject<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    id: string,
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
+  public nearObject<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    id: string,
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
+  public nearObject<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    id: string,
+    opts?: NearOptions<T, V, I>
+  ): QueryReturn<T, RV> {
     return this.check
       .nearSearch(opts)
       .then(({ search, supportsTargets, supportsWeightsForTargets }) => ({
@@ -217,9 +266,18 @@ class QueryManager<T, V> implements Query<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearText(query: string | string[], opts?: BaseNearTextOptions<T, V>): Promise<WeaviateReturn<T, V>>;
-  public nearText(query: string | string[], opts: GroupByNearTextOptions<T, V>): Promise<GroupByReturn<T, V>>;
-  public nearText(query: string | string[], opts?: NearTextOptions<T, V>): QueryReturn<T, V> {
+  public nearText<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string | string[],
+    opts?: BaseNearTextOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
+  public nearText<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string | string[],
+    opts: GroupByNearTextOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
+  public nearText<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string | string[],
+    opts?: NearTextOptions<T, V, I>
+  ): QueryReturn<T, RV> {
     return this.check
       .nearSearch(opts)
       .then(({ search, supportsTargets, supportsWeightsForTargets }) => ({
@@ -237,12 +295,18 @@ class QueryManager<T, V> implements Query<T, V> {
       .then((reply) => this.parseGroupByReply(opts, reply));
   }
 
-  public nearVector(vector: NearVectorInputType, opts?: BaseNearOptions<T, V>): Promise<WeaviateReturn<T, V>>;
-  public nearVector(
+  public nearVector<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    vector: NearVectorInputType,
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
+  public nearVector<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    vector: NearVectorInputType,
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
+  public nearVector<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
     vector: NearVectorInputType,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GroupByReturn<T, V>>;
-  public nearVector(vector: NearVectorInputType, opts?: NearOptions<T, V>): QueryReturn<T, V> {
+    opts?: NearOptions<T, V, I>
+  ): QueryReturn<T, RV> {
     return this.check
       .nearVector(vector, opts)
       .then(
diff --git a/src/collections/query/types.ts b/src/collections/query/types.ts
index 6255e03c..0cbf3580 100644
--- a/src/collections/query/types.ts
+++ b/src/collections/query/types.ts
@@ -1,5 +1,5 @@
 import { FilterValue } from '../filters/index.js';
-import { MultiTargetVectorJoin } from '../index.js';
+import { MultiTargetVectorJoin, ReturnVectors } from '../index.js';
 import { Sorting } from '../sort/classes.js';
 import {
   GroupByOptions,
@@ -14,9 +14,9 @@ import {
 import { IncludeVector, PrimitiveKeys } from '../types/internal.js';
 
 /** Options available in the `query.fetchObjectById` method */
-export type FetchObjectByIdOptions<T, V> = {
+export type FetchObjectByIdOptions<T, I> = {
   /** Whether to include the vector of the object in the response. If using named vectors, pass an array of strings to include only specific vectors. */
-  includeVector?: IncludeVector<V>;
+  includeVector?: I;
   /**
    * Which properties of the object to return. Can be primitive, in which case specify their names, or nested, in which case
    * use the QueryNested<T> type. If not specified, all properties are returned.
@@ -27,7 +27,7 @@ export type FetchObjectByIdOptions<T, V> = {
 };
 
 /** Options available in the `query.fetchObjects` method */
-export type FetchObjectsOptions<T, V> = {
+export type FetchObjectsOptions<T, I> = {
   /** How many objects to return in the query */
   limit?: number;
   /** How many objects to skip in the query. Incompatible with the `after` cursor */
@@ -39,7 +39,7 @@ export type FetchObjectsOptions<T, V> = {
   /** The sorting to be applied to the query. Use `weaviate.sort.*` to create sorting */
   sort?: Sorting<T>;
   /** Whether to include the vector of the object in the response. If using named vectors, pass an array of strings to include only specific vectors. */
-  includeVector?: IncludeVector<V>;
+  includeVector?: I;
   /** Which metadata of the object to return. If not specified, no metadata is returned. */
   returnMetadata?: QueryMetadata;
   /**
@@ -52,7 +52,7 @@ export type FetchObjectsOptions<T, V> = {
 };
 
 /** Base options available to all the query methods that involve searching. */
-export type SearchOptions<T, V> = {
+export type SearchOptions<T, I> = {
   /** How many objects to return in the query */
   limit?: number;
   /** How many objects to skip in the query. Incompatible with the `after` cursor */
@@ -64,7 +64,7 @@ export type SearchOptions<T, V> = {
   /** How to rerank the query results. Requires a configured [reranking](https://weaviate.io/developers/weaviate/concepts/reranking) module. */
   rerank?: RerankOptions<T>;
   /** Whether to include the vector of the object in the response. If using named vectors, pass an array of strings to include only specific vectors. */
-  includeVector?: IncludeVector<V>;
+  includeVector?: I;
   /** Which metadata of the object to return. If not specified, no metadata is returned. */
   returnMetadata?: QueryMetadata;
   /**
@@ -90,16 +90,16 @@ export type Bm25SearchOptions<T> = {
 };
 
 /** Base options available in the `query.bm25` method */
-export type BaseBm25Options<T, V> = SearchOptions<T, V> & Bm25SearchOptions<T>;
+export type BaseBm25Options<T, I> = SearchOptions<T, I> & Bm25SearchOptions<T>;
 
 /** Options available in the `query.bm25` method when specifying the `groupBy` parameter. */
-export type GroupByBm25Options<T, V> = BaseBm25Options<T, V> & {
+export type GroupByBm25Options<T, I> = BaseBm25Options<T, I> & {
   /** The group by options to apply to the search. */
   groupBy: GroupByOptions<T>;
 };
 
 /** Options available in the `query.bm25` method */
-export type Bm25Options<T, V> = BaseBm25Options<T, V> | GroupByBm25Options<T, V> | undefined;
+export type Bm25Options<T, I> = BaseBm25Options<T, I> | GroupByBm25Options<T, I> | undefined;
 
 /** Options available to the hybrid search type only */
 export type HybridSearchOptions<T, V> = {
@@ -118,7 +118,7 @@ export type HybridSearchOptions<T, V> = {
 };
 
 /** Base options available in the `query.hybrid` method */
-export type BaseHybridOptions<T, V> = SearchOptions<T, V> & HybridSearchOptions<T, V>;
+export type BaseHybridOptions<T, V, I> = SearchOptions<T, I> & HybridSearchOptions<T, V>;
 
 export type HybridSubSearchBase = {
   certainty?: number;
@@ -136,13 +136,13 @@ export type HybridNearVectorSubSearch = HybridSubSearchBase & {
 };
 
 /** Options available in the `query.hybrid` method when specifying the `groupBy` parameter. */
-export type GroupByHybridOptions<T, V> = BaseHybridOptions<T, V> & {
+export type GroupByHybridOptions<T, V, I> = BaseHybridOptions<T, V, I> & {
   /** The group by options to apply to the search. */
   groupBy: GroupByOptions<T>;
 };
 
 /** Options available in the `query.hybrid` method */
-export type HybridOptions<T, V> = BaseHybridOptions<T, V> | GroupByHybridOptions<T, V> | undefined;
+export type HybridOptions<T, V, I> = BaseHybridOptions<T, V, I> | GroupByHybridOptions<T, V, I> | undefined;
 
 export type NearSearchOptions<V> = {
   /** The minimum similarity score to return. Incompatible with the `distance` param. */
@@ -154,10 +154,10 @@ export type NearSearchOptions<V> = {
 };
 
 /** Base options for the near search queries. */
-export type BaseNearOptions<T, V> = SearchOptions<T, V> & NearSearchOptions<V>;
+export type BaseNearOptions<T, V, I> = SearchOptions<T, I> & NearSearchOptions<V>;
 
 /** Options available in the near search queries when specifying the `groupBy` parameter. */
-export type GroupByNearOptions<T, V> = BaseNearOptions<T, V> & {
+export type GroupByNearOptions<T, V, I> = BaseNearOptions<T, V, I> & {
   /** The group by options to apply to the search. */
   groupBy: GroupByOptions<T>;
 };
@@ -170,13 +170,13 @@ export type MoveOptions = {
 };
 
 /** Base options for the `query.nearText` method. */
-export type BaseNearTextOptions<T, V> = BaseNearOptions<T, V> & {
+export type BaseNearTextOptions<T, V, I> = BaseNearOptions<T, V, I> & {
   moveTo?: MoveOptions;
   moveAway?: MoveOptions;
 };
 
 /** Options available in the near text search queries when specifying the `groupBy` parameter. */
-export type GroupByNearTextOptions<T, V> = BaseNearTextOptions<T, V> & {
+export type GroupByNearTextOptions<T, V, I> = BaseNearTextOptions<T, V, I> & {
   groupBy: GroupByOptions<T>;
 };
 
@@ -227,11 +227,16 @@ interface Bm25<T, V> {
    *
    * This overload is for performing a search without the `groupBy` param.
    *
+   * @typeParam I - The vector(s) to include in the response. If using named vectors, pass an array of strings to include only specific vectors.
+   * @typeParam RV - The vectors(s) to be returned in the response depending on the input in opts.includeVector.
    * @param {string} query - The query to search for.
-   * @param {BaseBm25Options<T, V>} [opts] - The available options for the search excluding the `groupBy` param.
-   * @returns {Promise<WeaviateReturn<T, V>>} - The result of the search within the fetched collection.
+   * @param {BaseBm25Options<T, I>} [opts] - The available options for the search excluding the `groupBy` param.
+   * @returns {Promise<WeaviateReturn<T, ReturnVectors<V, I>>>} - The result of the search within the fetched collection.
    */
-  bm25(query: string, opts?: BaseBm25Options<T, V>): Promise<WeaviateReturn<T, V>>;
+  bm25<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts?: BaseBm25Options<T, I>
+  ): Promise<WeaviateReturn<T, RV>>;
   /**
    * Search for objects in this collection using the keyword-based BM25 algorithm.
    *
@@ -239,11 +244,16 @@ interface Bm25<T, V> {
    *
    * This overload is for performing a search with the `groupBy` param.
    *
+   * @typeParam I - The vector(s) to include in the response. If using named vectors, pass an array of strings to include only specific vectors.
+   * @typeParam RV - The vectors(s) to be returned in the response depending on the input in opts.includeVector.
    * @param {string} query - The query to search for.
-   * @param {GroupByBm25Options<T, V>} opts - The available options for the search including the `groupBy` param.
+   * @param {GroupByBm25Options<T, I>} opts - The available options for the search including the `groupBy` param.
    * @returns {Promise<GroupByReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  bm25(query: string, opts: GroupByBm25Options<T, V>): Promise<GroupByReturn<T, V>>;
+  bm25<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts: GroupByBm25Options<T, I>
+  ): Promise<GroupByReturn<T, RV>>;
   /**
    * Search for objects in this collection using the keyword-based BM25 algorithm.
    *
@@ -251,11 +261,16 @@ interface Bm25<T, V> {
    *
    * This overload is for performing a search with a programmatically defined `opts` param.
    *
+   * @typeParam I - The vector(s) to include in the response. If using named vectors, pass an array of strings to include only specific vectors.
+   * @typeParam RV - The vectors(s) to be returned in the response depending on the input in opts.includeVector.
    * @param {string} query - The query to search for.
    * @param {Bm25Options<T, V>} [opts] - The available options for the search including the `groupBy` param.
    * @returns {Promise<GroupByReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  bm25(query: string, opts?: Bm25Options<T, V>): QueryReturn<T, V>;
+  bm25<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts?: Bm25Options<T, I>
+  ): QueryReturn<T, RV>;
 }
 
 interface Hybrid<T, V> {
@@ -266,11 +281,16 @@ interface Hybrid<T, V> {
    *
    * This overload is for performing a search without the `groupBy` param.
    *
+   * @typeParam I - The vector(s) to include in the response. If using named vectors, pass an array of strings to include only specific vectors.
+   * @typeParam RV - The vectors(s) to be returned in the response depending on the input in opts.includeVector.
    * @param {string} query - The query to search for in the BM25 keyword search..
    * @param {BaseHybridOptions<T, V>} [opts] - The available options for the search excluding the `groupBy` param.
    * @returns {Promise<WeaviateReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  hybrid(query: string, opts?: BaseHybridOptions<T, V>): Promise<WeaviateReturn<T, V>>;
+  hybrid<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts?: BaseHybridOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
   /**
    * Search for objects in this collection using the hybrid algorithm blending keyword-based BM25 and vector-based similarity.
    *
@@ -278,11 +298,16 @@ interface Hybrid<T, V> {
    *
    * This overload is for performing a search with the `groupBy` param.
    *
+   * @typeParam I - The vector(s) to include in the response. If using named vectors, pass an array of strings to include only specific vectors.
+   * @typeParam RV - The vectors(s) to be returned in the response depending on the input in opts.includeVector.
    * @param {string} query - The query to search for in the BM25 keyword search..
    * @param {GroupByHybridOptions<T, V>} opts - The available options for the search including the `groupBy` param.
    * @returns {Promise<GroupByReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  hybrid(query: string, opts: GroupByHybridOptions<T, V>): Promise<GroupByReturn<T, V>>;
+  hybrid<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts: GroupByHybridOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
   /**
    * Search for objects in this collection using the hybrid algorithm blending keyword-based BM25 and vector-based similarity.
    *
@@ -294,7 +319,10 @@ interface Hybrid<T, V> {
    * @param {HybridOptions<T, V>} [opts] - The available options for the search including the `groupBy` param.
    * @returns {Promise<QueryReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  hybrid(query: string, opts?: HybridOptions<T, V>): QueryReturn<T, V>;
+  hybrid<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string,
+    opts?: HybridOptions<T, V, I>
+  ): QueryReturn<T, RV>;
 }
 
 interface NearImage<T, V> {
@@ -311,7 +339,10 @@ interface NearImage<T, V> {
    * @param {BaseNearOptions<T, V>} [opts] - The available options for the search excluding the `groupBy` param.
    * @returns {Promise<WeaviateReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  nearImage(image: string | Buffer, opts?: BaseNearOptions<T, V>): Promise<WeaviateReturn<T, V>>;
+  nearImage<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    image: string | Buffer,
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
   /**
    * Search for objects by image in this collection using an image-capable vectorization module and vector-based similarity search.
    * You must have an image-capable vectorization module installed in order to use this method,
@@ -325,7 +356,10 @@ interface NearImage<T, V> {
    * @param {GroupByNearOptions<T, V>} opts - The available options for the search including the `groupBy` param.
    * @returns {Promise<GroupByReturn<T, V>>} - The group by result of the search within the fetched collection.
    */
-  nearImage(image: string | Buffer, opts: GroupByNearOptions<T, V>): Promise<GroupByReturn<T, V>>;
+  nearImage<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    image: string | Buffer,
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
   /**
    * Search for objects by image in this collection using an image-capable vectorization module and vector-based similarity search.
    * You must have an image-capable vectorization module installed in order to use this method,
@@ -339,7 +373,10 @@ interface NearImage<T, V> {
    * @param {NearOptions<T, V>} [opts] - The available options for the search.
    * @returns {QueryReturn<T, V>} - The result of the search within the fetched collection.
    */
-  nearImage(image: string | Buffer, opts?: NearOptions<T, V>): QueryReturn<T, V>;
+  nearImage<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    image: string | Buffer,
+    opts?: NearOptions<T, V, I>
+  ): QueryReturn<T, RV>;
 }
 
 interface NearMedia<T, V> {
@@ -356,11 +393,11 @@ interface NearMedia<T, V> {
    * @param {BaseNearOptions<T, V>} [opts] - The available options for the search excluding the `groupBy` param.
    * @returns {Promise<WeaviateReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  nearMedia(
+  nearMedia<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
     media: string | Buffer,
     type: NearMediaType,
-    opts?: BaseNearOptions<T, V>
-  ): Promise<WeaviateReturn<T, V>>;
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
   /**
    * Search for objects by image in this collection using an image-capable vectorization module and vector-based similarity search.
    * You must have a multi-media-capable vectorization module installed in order to use this method, e.g. `multi2vec-bind` or `multi2vec-palm`.
@@ -374,11 +411,11 @@ interface NearMedia<T, V> {
    * @param {GroupByNearOptions<T, V>} opts - The available options for the search including the `groupBy` param.
    * @returns {Promise<GroupByReturn<T, V>>} - The group by result of the search within the fetched collection.
    */
-  nearMedia(
+  nearMedia<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
     media: string | Buffer,
     type: NearMediaType,
-    opts: GroupByNearOptions<T, V>
-  ): Promise<GroupByReturn<T, V>>;
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
   /**
    * Search for objects by image in this collection using an image-capable vectorization module and vector-based similarity search.
    * You must have a multi-media-capable vectorization module installed in order to use this method, e.g. `multi2vec-bind` or `multi2vec-palm`.
@@ -392,7 +429,11 @@ interface NearMedia<T, V> {
    * @param {NearOptions<T, V>} [opts] - The available options for the search.
    * @returns {QueryReturn<T, V>} - The result of the search within the fetched collection.
    */
-  nearMedia(media: string | Buffer, type: NearMediaType, opts?: NearOptions<T, V>): QueryReturn<T, V>;
+  nearMedia<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    media: string | Buffer,
+    type: NearMediaType,
+    opts?: NearOptions<T, V, I>
+  ): QueryReturn<T, RV>;
 }
 
 interface NearObject<T, V> {
@@ -407,7 +448,10 @@ interface NearObject<T, V> {
    * @param {BaseNearOptions<T, V>} [opts] - The available options for the search excluding the `groupBy` param.
    * @returns {Promise<WeaviateReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  nearObject(id: string, opts?: BaseNearOptions<T, V>): Promise<WeaviateReturn<T, V>>;
+  nearObject<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    id: string,
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
   /**
    * Search for objects in this collection by another object using a vector-based similarity search.
    *
@@ -419,7 +463,10 @@ interface NearObject<T, V> {
    * @param {GroupByNearOptions<T, V>} opts - The available options for the search including the `groupBy` param.
    * @returns {Promise<GroupByReturn<T, V>>} - The group by result of the search within the fetched collection.
    */
-  nearObject(id: string, opts: GroupByNearOptions<T, V>): Promise<GroupByReturn<T, V>>;
+  nearObject<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    id: string,
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
   /**
    * Search for objects in this collection by another object using a vector-based similarity search.
    *
@@ -431,7 +478,10 @@ interface NearObject<T, V> {
    * @param {NearOptions<T, V>} [opts] - The available options for the search.
    * @returns {QueryReturn<T, V>} - The result of the search within the fetched collection.
    */
-  nearObject(id: string, opts?: NearOptions<T, V>): QueryReturn<T, V>;
+  nearObject<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    id: string,
+    opts?: NearOptions<T, V, I>
+  ): QueryReturn<T, RV>;
 }
 
 interface NearText<T, V> {
@@ -448,7 +498,10 @@ interface NearText<T, V> {
    * @param {BaseNearTextOptions<T, V>} [opts] - The available options for the search excluding the `groupBy` param.
    * @returns {Promise<WeaviateReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  nearText(query: string | string[], opts?: BaseNearTextOptions<T, V>): Promise<WeaviateReturn<T, V>>;
+  nearText<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string | string[],
+    opts?: BaseNearTextOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
   /**
    * Search for objects in this collection by text using text-capable vectorization module and vector-based similarity search.
    * You must have a text-capable vectorization module installed in order to use this method,
@@ -462,7 +515,10 @@ interface NearText<T, V> {
    * @param {GroupByNearTextOptions<T, V>} opts - The available options for the search including the `groupBy` param.
    * @returns {Promise<GroupByReturn<T, V>>} - The group by result of the search within the fetched collection.
    */
-  nearText(query: string | string[], opts: GroupByNearTextOptions<T, V>): Promise<GroupByReturn<T, V>>;
+  nearText<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string | string[],
+    opts: GroupByNearTextOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
   /**
    * Search for objects in this collection by text using text-capable vectorization module and vector-based similarity search.
    * You must have a text-capable vectorization module installed in order to use this method,
@@ -476,7 +532,10 @@ interface NearText<T, V> {
    * @param {NearTextOptions<T, V>} [opts] - The available options for the search.
    * @returns {QueryReturn<T, V>} - The result of the search within the fetched collection.
    */
-  nearText(query: string | string[], opts?: NearTextOptions<T, V>): QueryReturn<T, V>;
+  nearText<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    query: string | string[],
+    opts?: NearTextOptions<T, V, I>
+  ): QueryReturn<T, RV>;
 }
 
 interface NearVector<T, V> {
@@ -491,7 +550,10 @@ interface NearVector<T, V> {
    * @param {BaseNearOptions<T, V>} [opts] - The available options for the search excluding the `groupBy` param.
    * @returns {Promise<WeaviateReturn<T, V>>} - The result of the search within the fetched collection.
    */
-  nearVector(vector: NearVectorInputType, opts?: BaseNearOptions<T, V>): Promise<WeaviateReturn<T, V>>;
+  nearVector<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    vector: NearVectorInputType,
+    opts?: BaseNearOptions<T, V, I>
+  ): Promise<WeaviateReturn<T, RV>>;
   /**
    * Search for objects by vector in this collection using a vector-based similarity search.
    *
@@ -503,7 +565,10 @@ interface NearVector<T, V> {
    * @param {GroupByNearOptions<T, V>} opts - The available options for the search including the `groupBy` param.
    * @returns {Promise<GroupByReturn<T, V>>} - The group by result of the search within the fetched collection.
    */
-  nearVector(vector: NearVectorInputType, opts: GroupByNearOptions<T, V>): Promise<GroupByReturn<T, V>>;
+  nearVector<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    vector: NearVectorInputType,
+    opts: GroupByNearOptions<T, V, I>
+  ): Promise<GroupByReturn<T, RV>>;
   /**
    * Search for objects by vector in this collection using a vector-based similarity search.
    *
@@ -515,7 +580,10 @@ interface NearVector<T, V> {
    * @param {NearOptions<T, V>} [opts] - The available options for the search.
    * @returns {QueryReturn<T, V>} - The result of the search within the fetched collection.
    */
-  nearVector(vector: NearVectorInputType, opts?: NearOptions<T, V>): QueryReturn<T, V>;
+  nearVector<I extends IncludeVector<V>, RV extends ReturnVectors<V, I>>(
+    vector: NearVectorInputType,
+    opts?: NearOptions<T, V, I>
+  ): QueryReturn<T, RV>;
 }
 
 /** All the available methods on the `.query` namespace. */
@@ -534,7 +602,10 @@ export interface Query<T, V>
    * @param {FetchObjectByIdOptions} [opts] - The available options for fetching the object.
    * @returns {Promise<WeaviateObject<T, V> | null>} - The object with the given UUID, or null if it does not exist.
    */
-  fetchObjectById: (id: string, opts?: FetchObjectByIdOptions<T, V>) => Promise<WeaviateObject<T, V> | null>;
+  fetchObjectById: <I extends IncludeVector<V>>(
+    id: string,
+    opts?: FetchObjectByIdOptions<T, I>
+  ) => Promise<WeaviateObject<T, ReturnVectors<V, I>> | null>;
 
   /**
    * Retrieve objects from the server without searching.
@@ -542,13 +613,18 @@ export interface Query<T, V>
    * @param {FetchObjectsOptions} [opts] - The available options for fetching the objects.
    * @returns {Promise<WeaviateReturn<T, V>>} - The objects within the fetched collection.
    */
-  fetchObjects: (opts?: FetchObjectsOptions<T, V>) => Promise<WeaviateReturn<T, V>>;
+  fetchObjects: <I extends IncludeVector<V>>(
+    opts?: FetchObjectsOptions<T, I>
+  ) => Promise<WeaviateReturn<T, ReturnVectors<V, I>>>;
 }
 /** Options available in the `query.nearImage`, `query.nearMedia`, `query.nearObject`, and `query.nearVector` methods */
-export type NearOptions<T, V> = BaseNearOptions<T, V> | GroupByNearOptions<T, V> | undefined;
+export type NearOptions<T, V, I> = BaseNearOptions<T, V, I> | GroupByNearOptions<T, V, I> | undefined;
 
 /** Options available in the `query.nearText` method */
-export type NearTextOptions<T, V> = BaseNearTextOptions<T, V> | GroupByNearTextOptions<T, V> | undefined;
+export type NearTextOptions<T, V, I> =
+  | BaseNearTextOptions<T, V, I>
+  | GroupByNearTextOptions<T, V, I>
+  | undefined;
 
 /** The return type of the `query` methods. It is a union of a standard query and a group by query due to function overloading. */
 export type QueryReturn<T, V> = Promise<WeaviateReturn<T, V>> | Promise<GroupByReturn<T, V>>;
diff --git a/src/collections/serialize/index.ts b/src/collections/serialize/index.ts
index ec56f0c9..e4efd225 100644
--- a/src/collections/serialize/index.ts
+++ b/src/collections/serialize/index.ts
@@ -556,10 +556,7 @@ class Search {
     };
   };
 
-  private static metadata = (
-    includeVector?: boolean | string[],
-    metadata?: QueryMetadata
-  ): MetadataRequest => {
+  private static metadata = <I>(includeVector?: I, metadata?: QueryMetadata): MetadataRequest => {
     const out: any = {
       uuid: true,
       vector: typeof includeVector === 'boolean' ? includeVector : false,
@@ -620,7 +617,7 @@ class Search {
     return args.groupBy !== undefined;
   };
 
-  private static common = <T, V>(args?: SearchOptions<T, V>): BaseSearchArgs => {
+  private static common = <T, V, I>(args?: SearchOptions<T, I>): BaseSearchArgs => {
     const out: BaseSearchArgs = {
       autocut: args?.autoLimit,
       limit: args?.limit,
@@ -666,7 +663,7 @@ class Search {
     });
   };
 
-  public static hybrid = async <T, V>(
+  public static hybrid = async <T, V, I>(
     args: {
       query: string;
       supportsTargets: boolean;
@@ -674,113 +671,115 @@ class Search {
       supportsWeightsForTargets: boolean;
       supportsVectors: boolean;
     },
-    opts?: HybridOptions<T, V>
+    opts?: HybridOptions<T, V, I>
   ): Promise<SearchHybridArgs> => {
     return {
-      ...Search.common<T, V>(opts),
+      ...Search.common<T, V, I>(opts),
       hybridSearch: await Serialize.hybridSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByHybridOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByHybridOptions<T, V, I>>(opts)
+        ? Search.groupBy(opts.groupBy)
+        : undefined,
     };
   };
 
-  public static nearAudio = <T, V>(
+  public static nearAudio = <T, V, I>(
     args: {
       audio: string;
       supportsTargets: boolean;
       supportsWeightsForTargets: boolean;
     },
-    opts?: NearOptions<T, V>
+    opts?: NearOptions<T, V, I>
   ): SearchNearAudioArgs => {
     return {
       ...Search.common(opts),
       nearAudio: Serialize.nearAudioSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByNearOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByNearOptions<T, V, I>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
     };
   };
 
-  public static nearDepth = <T, V>(
+  public static nearDepth = <T, V, I>(
     args: {
       depth: string;
       supportsTargets: boolean;
       supportsWeightsForTargets: boolean;
     },
-    opts?: NearOptions<T, V>
+    opts?: NearOptions<T, V, I>
   ): SearchNearDepthArgs => {
     return {
       ...Search.common(opts),
       nearDepth: Serialize.nearDepthSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByNearOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByNearOptions<T, V, I>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
     };
   };
 
-  public static nearImage = <T, V>(
+  public static nearImage = <T, V, I>(
     args: {
       image: string;
       supportsTargets: boolean;
       supportsWeightsForTargets: boolean;
     },
-    opts?: NearOptions<T, V>
+    opts?: NearOptions<T, V, I>
   ): SearchNearImageArgs => {
     return {
       ...Search.common(opts),
       nearImage: Serialize.nearImageSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByNearOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByNearOptions<T, V, I>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
     };
   };
 
-  public static nearIMU = <T, V>(
+  public static nearIMU = <T, V, I>(
     args: {
       imu: string;
       supportsTargets: boolean;
       supportsWeightsForTargets: boolean;
     },
-    opts?: NearOptions<T, V>
+    opts?: NearOptions<T, V, I>
   ): SearchNearIMUArgs => {
     return {
       ...Search.common(opts),
       nearIMU: Serialize.nearIMUSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByNearOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByNearOptions<T, V, I>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
     };
   };
 
-  public static nearObject = <T, V>(
+  public static nearObject = <T, V, I>(
     args: { id: string; supportsTargets: boolean; supportsWeightsForTargets: boolean },
-    opts?: NearOptions<T, V>
+    opts?: NearOptions<T, V, I>
   ): SearchNearObjectArgs => {
     return {
       ...Search.common(opts),
       nearObject: Serialize.nearObjectSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByNearOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByNearOptions<T, V, I>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
     };
   };
 
-  public static nearText = <T, V>(
+  public static nearText = <T, V, I>(
     args: {
       query: string | string[];
       supportsTargets: boolean;
       supportsWeightsForTargets: boolean;
     },
-    opts?: NearTextOptions<T, V>
+    opts?: NearTextOptions<T, V, I>
   ): SearchNearTextArgs => {
     return {
       ...Search.common(opts),
       nearText: Serialize.nearTextSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByNearOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByNearOptions<T, V, I>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
     };
   };
 
-  public static nearThermal = <T, V>(
+  public static nearThermal = <T, V, I>(
     args: { thermal: string; supportsTargets: boolean; supportsWeightsForTargets: boolean },
-    opts?: NearOptions<T, V>
+    opts?: NearOptions<T, V, I>
   ): SearchNearThermalArgs => {
     return {
       ...Search.common(opts),
       nearThermal: Serialize.nearThermalSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByNearOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByNearOptions<T, V, I>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
     };
   };
 
-  public static nearVector = async <T, V>(
+  public static nearVector = async <T, V, I>(
     args: {
       vector: NearVectorInputType;
       supportsTargets: boolean;
@@ -788,22 +787,22 @@ class Search {
       supportsWeightsForTargets: boolean;
       supportsVectors: boolean;
     },
-    opts?: NearOptions<T, V>
+    opts?: NearOptions<T, V, I>
   ): Promise<SearchNearVectorArgs> => {
     return {
       ...Search.common(opts),
       nearVector: await Serialize.nearVectorSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByNearOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByNearOptions<T, V, I>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
     };
   };
-  public static nearVideo = <T, V>(
+  public static nearVideo = <T, V, I>(
     args: { video: string; supportsTargets: boolean; supportsWeightsForTargets: boolean },
-    opts?: NearOptions<T, V>
+    opts?: NearOptions<T, V, I>
   ): SearchNearVideoArgs => {
     return {
       ...Search.common(opts),
       nearVideo: Serialize.nearVideoSearch({ ...args, ...opts }),
-      groupBy: Search.isGroupBy<GroupByNearOptions<T, V>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
+      groupBy: Search.isGroupBy<GroupByNearOptions<T, V, I>>(opts) ? Search.groupBy(opts.groupBy) : undefined,
     };
   };
 }
@@ -812,15 +811,15 @@ export class Serialize {
   static aggregate = Aggregate;
   static search = Search;
 
-  public static isNamedVectors = <T, V>(opts?: BaseNearOptions<T, V>): boolean => {
+  public static isNamedVectors = <T, V, I>(opts?: BaseNearOptions<T, V, I>): boolean => {
     return Array.isArray(opts?.includeVector) || opts?.targetVector !== undefined;
   };
 
-  public static isMultiTarget = <T, V>(opts?: BaseNearOptions<T, V>): boolean => {
+  public static isMultiTarget = <T, V, I>(opts?: BaseNearOptions<T, V, I>): boolean => {
     return opts?.targetVector !== undefined && !TargetVectorInputGuards.isSingle(opts.targetVector);
   };
 
-  public static isMultiWeightPerTarget = <T, V>(opts?: BaseNearOptions<T, V>): boolean => {
+  public static isMultiWeightPerTarget = <T, V, I>(opts?: BaseNearOptions<T, V, I>): boolean => {
     return (
       opts?.targetVector !== undefined &&
       TargetVectorInputGuards.isMultiJoin(opts.targetVector) &&
@@ -980,8 +979,8 @@ export class Serialize {
     });
   };
 
-  public static isHybridVectorSearch = <T, V>(
-    vector: BaseHybridOptions<T, V>['vector']
+  public static isHybridVectorSearch = <T, V, I>(
+    vector: BaseHybridOptions<T, V, I>['vector']
   ): vector is
     | PrimitiveVectorType
     | Record<
@@ -995,24 +994,24 @@ export class Serialize {
     );
   };
 
-  public static isHybridNearTextSearch = <T, V>(
-    vector: BaseHybridOptions<T, V>['vector']
+  public static isHybridNearTextSearch = <T, V, I>(
+    vector: BaseHybridOptions<T, V, I>['vector']
   ): vector is HybridNearTextSubSearch => {
     return (vector as HybridNearTextSubSearch)?.query !== undefined;
   };
 
-  public static isHybridNearVectorSearch = <T, V>(
-    vector: BaseHybridOptions<T, V>['vector']
+  public static isHybridNearVectorSearch = <T, V, I>(
+    vector: BaseHybridOptions<T, V, I>['vector']
   ): vector is HybridNearVectorSubSearch => {
     return (vector as HybridNearVectorSubSearch)?.vector !== undefined;
   };
 
-  private static hybridVector = async <T, V>(args: {
+  private static hybridVector = async <T, V, I>(args: {
     supportsTargets: boolean;
     supportsVectorsForTargets: boolean;
     supportsWeightsForTargets: boolean;
     supportsVectors: boolean;
-    vector?: BaseHybridOptions<T, V>['vector'];
+    vector?: BaseHybridOptions<T, V, I>['vector'];
   }) => {
     const vector = args.vector;
     if (Serialize.isHybridVectorSearch(vector)) {
@@ -1110,8 +1109,12 @@ export class Serialize {
     });
   };
 
-  public static nearAudioSearch = <T, V>(
-    args: { audio: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<T, V>
+  public static nearAudioSearch = <T, V, I>(
+    args: { audio: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<
+      T,
+      V,
+      I
+    >
   ): NearAudioSearch => {
     const { targets, targetVectors } = Serialize.targetVector(args);
     return NearAudioSearch.fromPartial({
@@ -1123,8 +1126,12 @@ export class Serialize {
     });
   };
 
-  public static nearDepthSearch = <T, V>(
-    args: { depth: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<T, V>
+  public static nearDepthSearch = <T, V, I>(
+    args: { depth: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<
+      T,
+      V,
+      I
+    >
   ): NearDepthSearch => {
     const { targets, targetVectors } = Serialize.targetVector(args);
     return NearDepthSearch.fromPartial({
@@ -1136,8 +1143,12 @@ export class Serialize {
     });
   };
 
-  public static nearImageSearch = <T, V>(
-    args: { image: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<T, V>
+  public static nearImageSearch = <T, V, I>(
+    args: { image: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<
+      T,
+      V,
+      I
+    >
   ): NearImageSearch => {
     const { targets, targetVectors } = Serialize.targetVector(args);
     return NearImageSearch.fromPartial({
@@ -1149,8 +1160,8 @@ export class Serialize {
     });
   };
 
-  public static nearIMUSearch = <T, V>(
-    args: { imu: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<T, V>
+  public static nearIMUSearch = <T, V, I>(
+    args: { imu: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<T, V, I>
   ): NearIMUSearch => {
     const { targets, targetVectors } = Serialize.targetVector(args);
     return NearIMUSearch.fromPartial({
@@ -1162,8 +1173,8 @@ export class Serialize {
     });
   };
 
-  public static nearObjectSearch = <T, V>(
-    args: { id: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<T, V>
+  public static nearObjectSearch = <T, V, I>(
+    args: { id: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<T, V, I>
   ): NearObject => {
     const { targets, targetVectors } = Serialize.targetVector(args);
     return NearObject.fromPartial({
@@ -1209,10 +1220,11 @@ export class Serialize {
     });
   };
 
-  public static nearThermalSearch = <T, V>(
+  public static nearThermalSearch = <T, V, I>(
     args: { thermal: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<
       T,
-      V
+      V,
+      I
     >
   ): NearThermalSearch => {
     const { targets, targetVectors } = Serialize.targetVector(args);
@@ -1558,8 +1570,12 @@ export class Serialize {
     }
   };
 
-  public static nearVideoSearch = <T, V>(
-    args: { video: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<T, V>
+  public static nearVideoSearch = <T, V, I>(
+    args: { video: string; supportsTargets: boolean; supportsWeightsForTargets: boolean } & NearOptions<
+      T,
+      V,
+      I
+    >
   ): NearVideoSearch => {
     const { targets, targetVectors } = Serialize.targetVector(args);
     return NearVideoSearch.fromPartial({
diff --git a/src/collections/types/query.ts b/src/collections/types/query.ts
index 52def317..8587baa3 100644
--- a/src/collections/types/query.ts
+++ b/src/collections/types/query.ts
@@ -61,7 +61,9 @@ export interface Vectors {
   [k: string]: PrimitiveVectorType;
 }
 
-export type ReturnVectors<V, I> = I extends true
+export type ReturnVectors<V, I> = V extends undefined
+  ? undefined
+  : I extends true
   ? V
   : I extends Array<infer U>
   ? Pick<
diff --git a/src/collections/vectors/journey.test.ts b/src/collections/vectors/journey.test.ts
index 2b0cd08f..de2ab644 100644
--- a/src/collections/vectors/journey.test.ts
+++ b/src/collections/vectors/journey.test.ts
@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-non-null-asserted-optional-chain */
 import weaviate, {
   VectorIndexConfigHNSW,
   WeaviateClient,
@@ -81,7 +83,7 @@ only('Testing of the collection.query methods with a collection with multvectors
     });
   });
 
-  it('should be able to get the inserted object with its vectors', async () => {
+  it('should be able to get the inserted object with its vectors stated implicitly', async () => {
     const obj = await collection.query.fetchObjectById(id1, { includeVector: true });
     const assert = (obj: any): obj is WeaviateGenericObject<Record<string, WeaviateField>, MyVectors> => {
       expect(obj).not.toBeNull();
@@ -100,6 +102,34 @@ only('Testing of the collection.query methods with a collection with multvectors
     }
   });
 
+  it('should be able to get the inserted object with its vectors stated explicitly', async () => {
+    const obj = await collection.query.fetchObjectById(id1, { includeVector: ['regular', 'colbert'] });
+    const assert = (obj: any): obj is WeaviateGenericObject<Record<string, WeaviateField>, MyVectors> => {
+      expect(obj).not.toBeNull();
+      return true;
+    };
+    if (assert(obj)) {
+      singleVector = obj.vectors.regular;
+      multiVector = obj.vectors.colbert;
+      expect(obj.uuid).toBe(id1);
+      expect(obj.vectors).toBeDefined();
+      expect(obj.vectors.regular).toEqual([1, 2, 3, 4]);
+      expect(obj.vectors.colbert).toEqual([
+        [1, 2],
+        [3, 4],
+      ]);
+    }
+  });
+
+  it('should be able to get the inserted object with one of its vectors', async () => {
+    const obj = await collection.query.fetchObjectById(id1, { includeVector: ['regular'] });
+    singleVector = obj?.vectors.regular!;
+    expect(obj?.uuid).toBe(id1);
+    expect(obj?.vectors).toBeDefined();
+    expect(obj?.vectors.regular).toEqual([1, 2, 3, 4]);
+    expect((obj?.vectors as MyVectors).colbert).toBeUndefined();
+  });
+
   it('should be able to query with hybrid for the inserted object over the single vector space', async () => {
     const result = await collection.query.hybrid('', {
       alpha: 1,