@mastra/weaviate 0.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,806 @@
+import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
+import { createVectorErrorId } from "@mastra/core/storage";
+import { MastraVector, validateTopK, validateUpsertInput, validateVectorValues } from "@mastra/core/vector";
+import weaviate, { Filters, generateUuid5 } from "weaviate-client";
+import { BaseFilterTranslator } from "@mastra/core/vector/filter";
+//#region src/vector/encoding.ts
+/**
+* Weaviate reserves certain property names (e.g. `id`, `vector`). Metadata keys
+* that collide are stored under a stable prefix and restored on read. This
+* module is the single source of truth shared by the adapter and the filter
+* translator — they must encode keys identically or filters will silently miss.
+*/
+/** Internal property used to round-trip the caller's original id. */
+const MASTRA_ID_PROPERTY = "mastraId";
+const META_KEY_PREFIX = "mastraMeta_";
+const RESERVED_META_KEYS = /* @__PURE__ */ new Set([
+	"id",
+	"vector",
+	"_additional",
+	MASTRA_ID_PROPERTY
+]);
+function encodeMetaKey(key) {
+	return RESERVED_META_KEYS.has(key) || key.startsWith("mastraMeta_") ? `${META_KEY_PREFIX}${key}` : key;
+}
+function decodeMetaKey(key) {
+	return key.startsWith("mastraMeta_") ? key.slice(11) : key;
+}
+function encodeMetaProperties(metadata) {
+	if (!metadata) return {};
+	const out = {};
+	for (const [key, value] of Object.entries(metadata)) out[encodeMetaKey(key)] = value;
+	return out;
+}
+//#endregion
+//#region src/vector/filter.ts
+/**
+* Translates MongoDB-style filters into Weaviate `FilterValue` objects.
+*
+* Weaviate filters are built from the collection's `filter` API (which produces
+* protobuf-backed targets), so `translate` requires the collection filter API to
+* be supplied alongside the filter.
+*/
+var WeaviateFilterTranslator = class extends BaseFilterTranslator {
+	getSupportedOperators() {
+		return {
+			logical: [
+				"$and",
+				"$or",
+				"$not"
+			],
+			basic: ["$eq", "$ne"],
+			numeric: [
+				"$gt",
+				"$gte",
+				"$lt",
+				"$lte"
+			],
+			array: [
+				"$in",
+				"$nin",
+				"$all"
+			],
+			element: ["$exists"],
+			regex: [],
+			custom: []
+		};
+	}
+	isOperator(key) {
+		return super.isOperator(key) || key === "$not";
+	}
+	translate(filter, api) {
+		if (this.isEmpty(filter)) return void 0;
+		if (!api) throw new Error("WeaviateFilterTranslator.translate requires a collection filter API");
+		this.validateFilter(filter);
+		return this.translateNode(filter, api);
+	}
+	combine(parts) {
+		const filtered = parts.filter((p) => p !== void 0);
+		if (filtered.length === 0) return void 0;
+		if (filtered.length === 1) return filtered[0];
+		return Filters.and(...filtered);
+	}
+	translateNode(node, api) {
+		const parts = Object.entries(node).map(([key, value]) => {
+			if (key === "$and") return this.combineLogical("and", value, api);
+			if (key === "$or") return this.combineLogical("or", value, api);
+			if (key === "$not") return this.negateNode(value, api);
+			return this.translateField(key, value, api);
+		});
+		return this.combine(parts);
+	}
+	/** Combines parts with OR, dropping undefined entries. */
+	combineOr(parts) {
+		const filtered = parts.filter((p) => p !== void 0);
+		if (filtered.length === 0) return void 0;
+		if (filtered.length === 1) return filtered[0];
+		return Filters.or(...filtered);
+	}
+	/**
+	* Returns the negation of a node. A node's entries are AND-combined, so the
+	* negation is the OR of each entry's negation (De Morgan).
+	*/
+	negateNode(node, api) {
+		const parts = Object.entries(node).map(([key, value]) => {
+			if (key === "$and") return this.combineOr(value.map((v) => this.negateNode(v, api)));
+			if (key === "$or") return this.combine(value.map((v) => this.negateNode(v, api)));
+			if (key === "$not") return this.translateNode(value, api);
+			return this.negateField(key, value, api);
+		});
+		return this.combineOr(parts);
+	}
+	/** Returns the negation of a single field condition. */
+	negateField(field, value, api) {
+		const prop = api.byProperty(encodeMetaKey(field));
+		if (value === null) return prop.isNull(false);
+		if (this.isPrimitive(value)) return prop.notEqual(this.normalizeComparisonValue(value));
+		if (Array.isArray(value)) return this.combine(this.normalizeArrayValues(value).map((v) => prop.notEqual(v)));
+		const parts = Object.entries(value).map(([op, opValue]) => this.negateSingleOp(field, op, opValue, api));
+		return this.combineOr(parts);
+	}
+	negateSingleOp(field, op, value, api) {
+		const prop = api.byProperty(encodeMetaKey(field));
+		switch (op) {
+			case "$eq": return value === null ? prop.isNull(false) : prop.notEqual(this.normalizeComparisonValue(value));
+			case "$ne": return value === null ? prop.isNull(true) : prop.equal(this.normalizeComparisonValue(value));
+			case "$gt": return prop.lessOrEqual(this.normalizeComparisonValue(value));
+			case "$gte": return prop.lessThan(this.normalizeComparisonValue(value));
+			case "$lt": return prop.greaterOrEqual(this.normalizeComparisonValue(value));
+			case "$lte": return prop.greaterThan(this.normalizeComparisonValue(value));
+			case "$in": return this.combine(this.normalizeArrayValues(value).map((v) => prop.notEqual(v)));
+			case "$nin": return prop.containsAny(this.normalizeArrayValues(value));
+			case "$exists": return prop.isNull(!!value);
+			case "$not": return this.translateField(field, value, api);
+			default: throw unsupportedOperatorError(op, field);
+		}
+	}
+	combineLogical(op, values, api) {
+		const translated = values.map((v) => this.translateNode(v, api)).filter((p) => p !== void 0);
+		if (translated.length === 0) return void 0;
+		if (translated.length === 1) return translated[0];
+		return op === "and" ? Filters.and(...translated) : Filters.or(...translated);
+	}
+	translateField(field, value, api) {
+		const prop = api.byProperty(encodeMetaKey(field));
+		if (value === null) return prop.isNull(true);
+		if (this.isPrimitive(value)) return prop.equal(this.normalizeComparisonValue(value));
+		if (Array.isArray(value)) return prop.containsAny(this.normalizeArrayValues(value));
+		const parts = Object.entries(value).map(([op, opValue]) => this.translateOperator(field, op, opValue, api));
+		return this.combine(parts);
+	}
+	translateOperator(field, op, value, api) {
+		const prop = api.byProperty(encodeMetaKey(field));
+		switch (op) {
+			case "$eq": return value === null ? prop.isNull(true) : prop.equal(this.normalizeComparisonValue(value));
+			case "$ne": return value === null ? prop.isNull(false) : prop.notEqual(this.normalizeComparisonValue(value));
+			case "$gt": return prop.greaterThan(this.normalizeComparisonValue(value));
+			case "$gte": return prop.greaterOrEqual(this.normalizeComparisonValue(value));
+			case "$lt": return prop.lessThan(this.normalizeComparisonValue(value));
+			case "$lte": return prop.lessOrEqual(this.normalizeComparisonValue(value));
+			case "$in": return prop.containsAny(this.normalizeArrayValues(value));
+			case "$nin": return this.combine(this.normalizeArrayValues(value).map((v) => prop.notEqual(v)));
+			case "$all": return prop.containsAll(this.normalizeArrayValues(value));
+			case "$exists": return prop.isNull(!value);
+			case "$not": return this.negateField(field, value, api);
+			default: throw unsupportedOperatorError(op, field);
+		}
+	}
+};
+/** Builds a user-facing error for an operator Weaviate cannot translate. */
+function unsupportedOperatorError(op, field) {
+	return new MastraError({
+		id: "STORAGE_WEAVIATE_FILTER_UNSUPPORTED_OPERATOR",
+		text: `Unsupported filter operator "${op}" on field "${field}"`,
+		domain: ErrorDomain.STORAGE,
+		category: ErrorCategory.USER,
+		details: {
+			operator: op,
+			field
+		}
+	});
+}
+//#endregion
+//#region src/vector/index.ts
+/**
+* Weaviate distance metrics mapped from Mastra metric names.
+* @see https://weaviate.io/developers/weaviate/config-refs/distances
+*/
+const DISTANCE_MAPPING = {
+	cosine: "cosine",
+	euclidean: "l2-squared",
+	dotproduct: "dot"
+};
+const REVERSE_DISTANCE_MAPPING = {
+	cosine: "cosine",
+	"l2-squared": "euclidean",
+	dot: "dotproduct"
+};
+/**
+* A Mastra vector store backed by Weaviate.
+*
+* Vectors are stored in `vectorizer: none` collections (Mastra supplies the
+* embeddings). Because Weaviate requires UUID object ids and capitalised
+* collection names, this adapter maps arbitrary Mastra ids to deterministic
+* UUIDv5 values (preserving the original id in a reserved property) and
+* preserves the original index name in the collection description.
+*/
+var WeaviateVector = class extends MastraVector {
+	clientPromise = null;
+	connectOptions;
+	/** Cache of property names known to exist in a collection's schema. */
+	knownProperties = /* @__PURE__ */ new Map();
+	/** Serializes schema mutations per collection to avoid concurrent addProperty races. */
+	schemaLocks = /* @__PURE__ */ new Map();
+	constructor(params) {
+		super({ id: params.id });
+		this.connectOptions = params;
+	}
+	getClient() {
+		if (!this.clientPromise) {
+			const { httpHost, httpPort, httpSecure, grpcHost, grpcPort, grpcSecure, apiKey, headers } = this.connectOptions;
+			this.clientPromise = weaviate.connectToCustom({
+				httpHost: httpHost ?? "localhost",
+				httpPort: httpPort ?? 8080,
+				httpSecure: httpSecure ?? false,
+				grpcHost: grpcHost ?? httpHost ?? "localhost",
+				grpcPort: grpcPort ?? 50051,
+				grpcSecure: grpcSecure ?? false,
+				...apiKey ? { authCredentials: new weaviate.ApiKey(apiKey) } : {},
+				...headers ? { headers } : {}
+			});
+		}
+		return this.clientPromise;
+	}
+	/** Closes the underlying Weaviate connection. */
+	async disconnect() {
+		if (this.clientPromise) {
+			await (await this.clientPromise).close();
+			this.clientPromise = null;
+		}
+	}
+	/** Weaviate collection names must start with an uppercase letter. */
+	toCollectionName(indexName) {
+		return indexName.charAt(0).toUpperCase() + indexName.slice(1);
+	}
+	async getCollection(indexName) {
+		return (await this.getClient()).collections.get(this.toCollectionName(indexName));
+	}
+	parseMeta(description) {
+		if (!description) return null;
+		try {
+			const parsed = JSON.parse(description);
+			if (parsed && typeof parsed === "object" && typeof parsed.name === "string") return parsed;
+		} catch {}
+		return null;
+	}
+	inferDataType(value) {
+		if (typeof value === "string") return "text";
+		if (typeof value === "number") return "number";
+		if (typeof value === "boolean") return "boolean";
+		if (Array.isArray(value)) {
+			const first = value.find((v) => v !== null && v !== void 0);
+			if (typeof first === "string") return "text[]";
+			if (typeof first === "number") return "number[]";
+			if (typeof first === "boolean") return "boolean[]";
+			return null;
+		}
+		return null;
+	}
+	/**
+	* Ensures every metadata key across the batch exists as a collection property.
+	* Weaviate's auto-schema would create text properties with `word` tokenization
+	* (breaking exact-match filtering), so properties are created explicitly with
+	* `field` tokenization for text values.
+	*/
+	async ensureProperties(collection, collectionName, metadata) {
+		if (!metadata?.length) return;
+		const next = (this.schemaLocks.get(collectionName) ?? Promise.resolve()).catch(() => void 0).then(() => this.ensurePropertiesLocked(collection, collectionName, metadata));
+		this.schemaLocks.set(collectionName, next);
+		await next;
+	}
+	async ensurePropertiesLocked(collection, collectionName, metadata) {
+		let known = this.knownProperties.get(collectionName);
+		if (!known) {
+			const config = await collection.config.get();
+			known = new Set(config.properties.map((p) => p.name));
+			this.knownProperties.set(collectionName, known);
+		}
+		const seen = /* @__PURE__ */ new Map();
+		for (const row of metadata) {
+			if (!row) continue;
+			for (const [rawKey, value] of Object.entries(row)) {
+				const key = encodeMetaKey(rawKey);
+				if (known.has(key) || seen.has(key) || value === null || value === void 0) continue;
+				const dataType = this.inferDataType(value);
+				if (dataType) seen.set(key, dataType);
+			}
+		}
+		for (const [name, dataType] of seen) {
+			try {
+				await collection.config.addProperty({
+					name,
+					dataType,
+					...dataType === "text" || dataType === "text[]" ? { tokenization: "field" } : {}
+				});
+			} catch (error) {
+				if (!/already/i.test(error?.message ?? "")) throw error;
+			}
+			known.add(name);
+		}
+	}
+	async createIndex({ indexName, dimension, metric = "cosine" }) {
+		try {
+			if (!Number.isInteger(dimension) || dimension <= 0) throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "CREATE_INDEX", "INVALID_ARGS"),
+				text: "Dimension must be a positive integer",
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: {
+					indexName,
+					dimension
+				}
+			});
+			const distance = DISTANCE_MAPPING[metric];
+			if (!distance) throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "CREATE_INDEX", "INVALID_ARGS"),
+				text: `Invalid metric: ${metric}. Must be one of: cosine, euclidean, dotproduct`,
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: {
+					indexName,
+					metric
+				}
+			});
+			const client = await this.getClient();
+			const collectionName = this.toCollectionName(indexName);
+			if (await client.collections.exists(collectionName)) {
+				const existingConfig = await client.collections.get(collectionName).config.get();
+				const existingMeta = this.parseMeta(existingConfig.description);
+				if (existingMeta && existingMeta.name !== indexName) throw new MastraError({
+					id: createVectorErrorId("WEAVIATE", "CREATE_INDEX", "NAME_COLLISION"),
+					text: `Index name "${indexName}" collides with existing index "${existingMeta.name}" (Weaviate collection "${collectionName}"). Weaviate capitalises the first letter of collection names, so these names cannot coexist.`,
+					domain: ErrorDomain.STORAGE,
+					category: ErrorCategory.USER,
+					details: {
+						indexName,
+						existingName: existingMeta.name,
+						collectionName
+					}
+				});
+				await this.validateExistingIndex(indexName, dimension, metric);
+				return;
+			}
+			const meta = {
+				name: indexName,
+				dimension,
+				metric
+			};
+			await client.collections.create({
+				name: collectionName,
+				description: JSON.stringify(meta),
+				properties: [{
+					name: MASTRA_ID_PROPERTY,
+					dataType: "text",
+					tokenization: "field"
+				}],
+				invertedIndex: weaviate.configure.invertedIndex({ indexNullState: true }),
+				vectorizers: weaviate.configure.vectors.selfProvided({ vectorIndexConfig: weaviate.configure.vectorIndex.hnsw({ distanceMetric: distance }) })
+			});
+			this.knownProperties.set(collectionName, /* @__PURE__ */ new Set([MASTRA_ID_PROPERTY]));
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "CREATE_INDEX", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	/** Fetches a collection's stored metadata, throwing if the index does not exist. */
+	async requireMeta(indexName, operation) {
+		const client = await this.getClient();
+		const collectionName = this.toCollectionName(indexName);
+		if (!await client.collections.exists(collectionName)) throw new MastraError({
+			id: createVectorErrorId("WEAVIATE", operation, "INDEX_NOT_FOUND"),
+			text: `Index ${indexName} does not exist`,
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		const config = await client.collections.get(collectionName).config.get();
+		return this.parseMeta(config.description);
+	}
+	async upsert({ indexName, vectors, metadata, ids }) {
+		try {
+			validateUpsertInput("WEAVIATE", vectors, metadata, ids);
+			validateVectorValues("WEAVIATE", vectors);
+			const meta = await this.requireMeta(indexName, "UPSERT");
+			if (meta?.dimension) {
+				const mismatch = vectors.find((v) => v.length !== meta.dimension);
+				if (mismatch) throw new MastraError({
+					id: createVectorErrorId("WEAVIATE", "UPSERT", "DIMENSION_MISMATCH"),
+					text: `Vector dimension ${mismatch.length} does not match index dimension ${meta.dimension}`,
+					domain: ErrorDomain.STORAGE,
+					category: ErrorCategory.USER,
+					details: {
+						indexName,
+						expected: meta.dimension,
+						actual: mismatch.length
+					}
+				});
+			}
+			const collection = await this.getCollection(indexName);
+			await this.ensureProperties(collection, this.toCollectionName(indexName), metadata);
+			const originalIds = ids ?? vectors.map(() => crypto.randomUUID());
+			const objects = vectors.map((vector, i) => {
+				const originalId = originalIds[i];
+				return {
+					id: generateUuid5(originalId),
+					vectors: vector,
+					properties: {
+						...encodeMetaProperties(metadata?.[i]),
+						[MASTRA_ID_PROPERTY]: originalId
+					}
+				};
+			});
+			const result = await collection.data.insertMany(objects);
+			if (result.hasErrors) {
+				const firstError = Object.values(result.errors)[0];
+				throw new Error(firstError?.message ?? "Weaviate insertMany reported errors");
+			}
+			return originalIds;
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "UPSERT", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	transformFilter(collection, filter) {
+		return new WeaviateFilterTranslator().translate(filter, collection.filter);
+	}
+	toQueryResult(obj, includeVector) {
+		const raw = obj.properties ?? {};
+		const originalId = raw[MASTRA_ID_PROPERTY];
+		const properties = {};
+		for (const [key, value] of Object.entries(raw)) {
+			if (key === "mastraId" || value === void 0) continue;
+			properties[decodeMetaKey(key)] = value;
+		}
+		const distance = obj.metadata?.distance;
+		const score = typeof distance === "number" ? 1 - distance : obj.metadata?.certainty ?? 0;
+		const result = {
+			id: typeof originalId === "string" ? originalId : obj.uuid,
+			score,
+			metadata: properties
+		};
+		if (includeVector) {
+			const vectors = obj.vectors ?? {};
+			result.vector = vectors.default ?? Object.values(vectors)[0];
+		}
+		return result;
+	}
+	async query({ indexName, queryVector, topK = 10, filter, includeVector = false }) {
+		try {
+			validateTopK("WEAVIATE", topK);
+			const meta = await this.requireMeta(indexName, "QUERY");
+			if (queryVector && meta?.dimension && queryVector.length !== meta.dimension) throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "QUERY", "DIMENSION_MISMATCH"),
+				text: `Query vector dimension ${queryVector.length} does not match index dimension ${meta.dimension}`,
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: {
+					indexName,
+					expected: meta.dimension,
+					actual: queryVector.length
+				}
+			});
+			const collection = await this.getCollection(indexName);
+			const filters = this.transformFilter(collection, filter);
+			const returnMetadata = ["distance"];
+			if (queryVector) return (await collection.query.nearVector(queryVector, {
+				limit: topK,
+				includeVector,
+				returnMetadata,
+				...filters ? { filters } : {}
+			})).objects.map((obj) => this.toQueryResult(obj, includeVector));
+			return (await collection.query.fetchObjects({
+				limit: topK,
+				includeVector,
+				...filters ? { filters } : {}
+			})).objects.map((obj) => this.toQueryResult(obj, includeVector));
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "QUERY", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	async listIndexes() {
+		try {
+			return (await (await this.getClient()).collections.listAll()).map((config) => {
+				return this.parseMeta(config.description)?.name ?? config.name;
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "LIST_INDEXES", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	async describeIndex({ indexName }) {
+		try {
+			const client = await this.getClient();
+			const collectionName = this.toCollectionName(indexName);
+			if (!await client.collections.exists(collectionName)) throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "DESCRIBE_INDEX", "INDEX_NOT_FOUND"),
+				text: `Index ${indexName} does not exist`,
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: { indexName }
+			});
+			const collection = client.collections.get(collectionName);
+			const config = await collection.config.get();
+			const meta = this.parseMeta(config.description);
+			const count = await collection.length();
+			let dimension = meta?.dimension ?? 0;
+			if (!dimension) {
+				const vectors = (await collection.query.fetchObjects({
+					limit: 1,
+					includeVector: true
+				})).objects[0]?.vectors ?? {};
+				const vec = vectors.default ?? Object.values(vectors)[0];
+				if (Array.isArray(vec)) dimension = vec.length;
+			}
+			let metric = meta?.metric;
+			if (!metric) {
+				const distance = (config.vectorizers?.default ?? Object.values(config.vectorizers ?? {})[0])?.indexConfig?.distance;
+				metric = distance ? REVERSE_DISTANCE_MAPPING[distance] : void 0;
+			}
+			return {
+				dimension,
+				count,
+				metric
+			};
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "DESCRIBE_INDEX", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	async deleteIndex({ indexName }) {
+		try {
+			await (await this.getClient()).collections.delete(this.toCollectionName(indexName));
+		} catch (error) {
+			throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "DELETE_INDEX", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	async updateVector({ indexName, id, filter, update }) {
+		try {
+			if (id !== void 0 && filter !== void 0) throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "UPDATE_VECTOR", "INVALID_ARGS"),
+				text: "id and filter are mutually exclusive",
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: { indexName }
+			});
+			if (!update || !update.vector && !update.metadata) throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "UPDATE_VECTOR", "INVALID_ARGS"),
+				text: "Update data is required: no updates provided",
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: { indexName }
+			});
+			if (id === void 0 && filter === void 0) throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "UPDATE_VECTOR", "INVALID_ARGS"),
+				text: "Either id or filter must be provided",
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: { indexName }
+			});
+			if (id === void 0 && (typeof filter !== "object" || filter === null || Object.keys(filter).length === 0)) throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "UPDATE_VECTOR", "INVALID_ARGS"),
+				text: "A non-empty filter is required: empty filter not allowed",
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: { indexName }
+			});
+			const collection = await this.getCollection(indexName);
+			if (update.metadata) await this.ensureProperties(collection, this.toCollectionName(indexName), [update.metadata]);
+			const encodedProperties = update.metadata ? encodeMetaProperties(update.metadata) : void 0;
+			const applyUpdate = async (uuid) => {
+				await collection.data.update({
+					id: uuid,
+					...encodedProperties ? { properties: encodedProperties } : {},
+					...update.vector ? { vectors: update.vector } : {}
+				});
+			};
+			if (id !== void 0) {
+				await applyUpdate(generateUuid5(id));
+				return;
+			}
+			const filters = this.transformFilter(collection, filter);
+			const PAGE_SIZE = 1e3;
+			const MAX_FILTERED_UPDATE = 1e4;
+			const uuids = [];
+			for (let offset = 0;; offset += PAGE_SIZE) {
+				if (offset >= MAX_FILTERED_UPDATE) throw new MastraError({
+					id: createVectorErrorId("WEAVIATE", "UPDATE_VECTOR", "INVALID_ARGS"),
+					domain: ErrorDomain.STORAGE,
+					category: ErrorCategory.USER,
+					text: `Filtered updateVector matched more than ${MAX_FILTERED_UPDATE} vectors, which exceeds Weaviate's query result cap. Narrow the filter or update by id.`,
+					details: {
+						indexName,
+						limit: MAX_FILTERED_UPDATE
+					}
+				});
+				const page = await collection.query.fetchObjects({
+					limit: PAGE_SIZE,
+					offset,
+					...filters ? { filters } : {}
+				});
+				for (const obj of page.objects) uuids.push(obj.uuid);
+				if (page.objects.length < PAGE_SIZE) break;
+			}
+			for (const uuid of uuids) await applyUpdate(uuid);
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "UPDATE_VECTOR", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...id ? { id } : {}
+				}
+			}, error);
+		}
+	}
+	async deleteVector({ indexName, id }) {
+		try {
+			await (await this.getCollection(indexName)).data.deleteById(generateUuid5(id));
+		} catch (error) {
+			throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "DELETE_VECTOR", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					id
+				}
+			}, error);
+		}
+	}
+	async deleteVectors({ indexName, filter, ids }) {
+		if (ids && filter) throw new MastraError({
+			id: createVectorErrorId("WEAVIATE", "DELETE_VECTORS", "MUTUALLY_EXCLUSIVE"),
+			text: "Cannot specify both ids and filter - they are mutually exclusive",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (!ids && !filter) throw new MastraError({
+			id: createVectorErrorId("WEAVIATE", "DELETE_VECTORS", "NO_TARGET"),
+			text: "Either filter or ids must be provided",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (ids && ids.length === 0) throw new MastraError({
+			id: createVectorErrorId("WEAVIATE", "DELETE_VECTORS", "EMPTY_IDS"),
+			text: "Cannot delete with empty ids array",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (filter && typeof filter === "object" && Object.keys(filter).length === 0) throw new MastraError({
+			id: createVectorErrorId("WEAVIATE", "DELETE_VECTORS", "EMPTY_FILTER"),
+			text: "Cannot delete with empty filter object",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		try {
+			const collection = await this.getCollection(indexName);
+			if (ids) for (const id of ids) await collection.data.deleteById(generateUuid5(id));
+			else if (filter) {
+				const filters = this.transformFilter(collection, filter);
+				if (filters) await collection.data.deleteMany(filters);
+			}
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createVectorErrorId("WEAVIATE", "DELETE_VECTORS", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...filter && { filter: JSON.stringify(filter) },
+					...ids && { idsCount: ids.length }
+				}
+			}, error);
+		}
+	}
+};
+//#endregion
+//#region src/vector/prompt.ts
+/**
+* Vector store specific prompt that details supported operators and examples.
+* This prompt helps users construct valid filters for Weaviate Vector.
+*/
+const WEAVIATE_PROMPT = `When querying Weaviate, you can ONLY use the operators listed below. Any other operators will be rejected.
+Important: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.
+If a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.
+
+Basic Comparison Operators:
+- $eq: Exact match (default when using field: value)
+  Example: { "category": "electronics" }
+- $ne: Not equal
+  Example: { "category": { "$ne": "electronics" } }
+- $gt: Greater than
+  Example: { "price": { "$gt": 100 } }
+- $gte: Greater than or equal
+  Example: { "price": { "$gte": 100 } }
+- $lt: Less than
+  Example: { "price": { "$lt": 100 } }
+- $lte: Less than or equal
+  Example: { "price": { "$lte": 100 } }
+
+Array Operators:
+- $in: Match any value in array
+  Example: { "category": { "$in": ["electronics", "books"] } }
+- $nin: Does not match any value in array
+  Example: { "category": { "$nin": ["electronics", "books"] } }
+- $all: Match arrays containing all values
+  Example: { "tags": { "$all": ["sale", "new"] } }
+
+Logical Operators:
+- $and: Logical AND (can be implicit or explicit)
+  Implicit Example: { "price": { "$gt": 100 }, "category": "electronics" }
+  Explicit Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
+- $or: Logical OR
+  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
+- $not: Logical NOT
+  Example: { "$not": { "category": "electronics" } }
+
+Element Operators:
+- $exists: Check if field exists (is not null)
+  Example: { "rating": { "$exists": true } }
+
+Restrictions:
+- Regex patterns are not supported
+- Only $and, $or, and $not logical operators are supported at the top level
+- Empty arrays in $in/$nin will return no results
+- Multiple conditions on the same field are supported with both implicit and explicit $and
+- At least one key-value pair is required in filter object
+- Empty objects and undefined values are treated as no filter
+- Invalid types in comparison operators will throw errors
+- All non-logical operators must be used within a field condition
+  Valid: { "field": { "$gt": 100 } }
+  Valid: { "$and": [...] }
+  Invalid: { "$gt": 100 }
+- Logical operators must contain field conditions, not direct operators
+  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
+  Invalid: { "$and": [{ "$gt": 100 }] }
+- Logical operators ($and, $or, $not):
+  - Can only be used at top level or nested within other logical operators
+  - Can not be used on a field level, or be nested inside a field
+  - Can not be used inside an operator
+  - Valid: { "$and": [{ "field": { "$gt": 100 } }] }
+  - Valid: { "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }
+  - Invalid: { "field": { "$and": [{ "$gt": 100 }] } }
+
+Example Complex Query:
+{
+  "$and": [
+    { "category": { "$in": ["electronics", "computers"] } },
+    { "price": { "$gte": 100, "$lte": 1000 } },
+    { "rating": { "$exists": true, "$gt": 4 } },
+    { "$or": [
+      { "stock": { "$gt": 0 } },
+      { "preorder": { "$eq": true } }
+    ]},
+    { "$not": { "status": "discontinued" } }
+  ]
+}`;
+//#endregion
+export { WEAVIATE_PROMPT, WeaviateVector };
+
+//# sourceMappingURL=index.js.map