@mastra/pinecone 0.11.4 → 0.11.7-alpha.0

package/src/vector/index.ts

@@ -1,364 +0,0 @@
-import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
-import { MastraVector } from '@mastra/core/vector';
-import type {
-  QueryResult,
-  IndexStats,
-  CreateIndexParams,
-  UpsertVectorParams,
-  QueryVectorParams,
-  DescribeIndexParams,
-  DeleteIndexParams,
-  DeleteVectorParams,
-  UpdateVectorParams,
-} from '@mastra/core/vector';
-import { Pinecone } from '@pinecone-database/pinecone';
-import type {
-  IndexStatsDescription,
-  QueryOptions,
-  RecordSparseValues,
-  UpdateOptions,
-} from '@pinecone-database/pinecone';
-
-import { PineconeFilterTranslator } from './filter';
-import type { PineconeVectorFilter } from './filter';
-
-interface PineconeIndexStats extends IndexStats {
-  namespaces?: IndexStatsDescription['namespaces'];
-}
-
-interface PineconeQueryVectorParams extends QueryVectorParams<PineconeVectorFilter> {
-  namespace?: string;
-  sparseVector?: RecordSparseValues;
-}
-
-interface PineconeUpsertVectorParams extends UpsertVectorParams {
-  namespace?: string;
-  sparseVectors?: RecordSparseValues[];
-}
-
-interface PineconeUpdateVectorParams extends UpdateVectorParams {
-  namespace?: string;
-}
-
-interface PineconeDeleteVectorParams extends DeleteVectorParams {
-  namespace?: string;
-}
-
-export class PineconeVector extends MastraVector<PineconeVectorFilter> {
-  private client: Pinecone;
-
-  /**
-   * Creates a new PineconeVector client.
-   * @param apiKey - The API key for Pinecone.
-   * @param environment - The environment for Pinecone.
-   */
-  constructor({ apiKey, environment }: { apiKey: string; environment?: string }) {
-    super();
-    const opts: { apiKey: string; controllerHostUrl?: string } = { apiKey };
-    if (environment) {
-      opts['controllerHostUrl'] = environment;
-    }
-    const baseClient = new Pinecone(opts);
-    const telemetry = this.__getTelemetry();
-    this.client =
-      telemetry?.traceClass(baseClient, {
-        spanNamePrefix: 'pinecone-vector',
-        attributes: {
-          'vector.type': 'pinecone',
-        },
-      }) ?? baseClient;
-  }
-
-  get indexSeparator(): string {
-    return '-';
-  }
-
-  async createIndex({ indexName, dimension, metric = 'cosine' }: CreateIndexParams): Promise<void> {
-    try {
-      if (!Number.isInteger(dimension) || dimension <= 0) {
-        throw new Error('Dimension must be a positive integer');
-      }
-      if (metric && !['cosine', 'euclidean', 'dotproduct'].includes(metric)) {
-        throw new Error('Metric must be one of: cosine, euclidean, dotproduct');
-      }
-    } catch (validationError) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_PINECONE_VECTOR_CREATE_INDEX_INVALID_ARGS',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER,
-          details: { indexName, dimension, metric },
-        },
-        validationError,
-      );
-    }
-
-    try {
-      await this.client.createIndex({
-        name: indexName,
-        dimension: dimension,
-        metric: metric,
-        spec: {
-          serverless: {
-            cloud: 'aws',
-            region: 'us-east-1',
-          },
-        },
-      });
-    } catch (error: any) {
-      // Check for 'already exists' error
-      const message = error?.errors?.[0]?.message || error?.message;
-      if (
-        error.status === 409 ||
-        (typeof message === 'string' &&
-          (message.toLowerCase().includes('already exists') || message.toLowerCase().includes('duplicate')))
-      ) {
-        // Fetch index info and check dimensions
-        await this.validateExistingIndex(indexName, dimension, metric);
-        return;
-      }
-      // For any other errors, wrap in MastraError
-      throw new MastraError(
-        {
-          id: 'STORAGE_PINECONE_VECTOR_CREATE_INDEX_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, dimension, metric },
-        },
-        error,
-      );
-    }
-  }
-
-  async upsert({
-    indexName,
-    vectors,
-    metadata,
-    ids,
-    namespace,
-    sparseVectors,
-  }: PineconeUpsertVectorParams): Promise<string[]> {
-    const index = this.client.Index(indexName).namespace(namespace || '');
-
-    // Generate IDs if not provided
-    const vectorIds = ids || vectors.map(() => crypto.randomUUID());
-
-    const records = vectors.map((vector, i) => ({
-      id: vectorIds[i]!,
-      values: vector,
-      ...(sparseVectors?.[i] && { sparseValues: sparseVectors?.[i] }),
-      metadata: metadata?.[i] || {},
-    }));
-
-    // Pinecone has a limit of 100 vectors per upsert request
-    const batchSize = 100;
-    try {
-      for (let i = 0; i < records.length; i += batchSize) {
-        const batch = records.slice(i, i + batchSize);
-        await index.upsert(batch);
-      }
-
-      return vectorIds;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_PINECONE_VECTOR_UPSERT_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, vectorCount: vectors.length },
-        },
-        error,
-      );
-    }
-  }
-
-  transformFilter(filter?: PineconeVectorFilter) {
-    const translator = new PineconeFilterTranslator();
-    return translator.translate(filter);
-  }
-
-  async query({
-    indexName,
-    queryVector,
-    topK = 10,
-    filter,
-    includeVector = false,
-    namespace,
-    sparseVector,
-  }: PineconeQueryVectorParams): Promise<QueryResult[]> {
-    const index = this.client.Index(indexName).namespace(namespace || '');
-
-    const translatedFilter = this.transformFilter(filter) ?? undefined;
-
-    const queryParams: QueryOptions = {
-      vector: queryVector,
-      topK,
-      includeMetadata: true,
-      includeValues: includeVector,
-      filter: translatedFilter,
-    };
-
-    // If sparse vector is provided, use hybrid search
-    if (sparseVector) {
-      queryParams.sparseVector = sparseVector;
-    }
-
-    try {
-      const results = await index.query(queryParams);
-
-      return results.matches.map(match => ({
-        id: match.id,
-        score: match.score || 0,
-        metadata: match.metadata as Record<string, any>,
-        ...(includeVector && { vector: match.values || [] }),
-      }));
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_PINECONE_VECTOR_QUERY_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, topK },
-        },
-        error,
-      );
-    }
-  }
-
-  async listIndexes(): Promise<string[]> {
-    try {
-      const indexesResult = await this.client.listIndexes();
-      return indexesResult?.indexes?.map(index => index.name) || [];
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_PINECONE_VECTOR_LIST_INDEXES_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-        },
-        error,
-      );
-    }
-  }
-
-  /**
-   * Retrieves statistics about a vector index.
-   *
-   * @param {string} indexName - The name of the index to describe
-   * @returns A promise that resolves to the index statistics including dimension, count and metric
-   */
-  async describeIndex({ indexName }: DescribeIndexParams): Promise<PineconeIndexStats> {
-    try {
-      const index = this.client.Index(indexName);
-      const stats = await index.describeIndexStats();
-      const description = await this.client.describeIndex(indexName);
-
-      return {
-        dimension: description.dimension,
-        count: stats.totalRecordCount || 0,
-        metric: description.metric as 'cosine' | 'euclidean' | 'dotproduct',
-        namespaces: stats.namespaces,
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_PINECONE_VECTOR_DESCRIBE_INDEX_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName },
-        },
-        error,
-      );
-    }
-  }
-
-  async deleteIndex({ indexName }: DeleteIndexParams): Promise<void> {
-    try {
-      await this.client.deleteIndex(indexName);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_PINECONE_VECTOR_DELETE_INDEX_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName },
-        },
-        error,
-      );
-    }
-  }
-
-  /**
-   * Updates a vector by its ID with the provided vector and/or metadata.
-   * @param indexName - The name of the index containing the vector.
-   * @param id - The ID of the vector to update.
-   * @param update - An object containing the vector and/or metadata to update.
-   * @param update.vector - An optional array of numbers representing the new vector.
-   * @param update.metadata - An optional record containing the new metadata.
-   * @param namespace - The namespace of the index (optional).
-   * @returns A promise that resolves when the update is complete.
-   * @throws Will throw an error if no updates are provided or if the update operation fails.
-   */
-  async updateVector({ indexName, id, update, namespace }: PineconeUpdateVectorParams): Promise<void> {
-    if (!update.vector && !update.metadata) {
-      throw new MastraError({
-        id: 'STORAGE_PINECONE_VECTOR_UPDATE_VECTOR_INVALID_ARGS',
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        text: 'No updates provided',
-        details: { indexName, id },
-      });
-    }
-
-    try {
-      const index = this.client.Index(indexName).namespace(namespace || '');
-
-      const updateObj: UpdateOptions = { id };
-
-      if (update.vector) {
-        updateObj.values = update.vector;
-      }
-
-      if (update.metadata) {
-        updateObj.metadata = update.metadata;
-      }
-
-      await index.update(updateObj);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_PINECONE_VECTOR_UPDATE_VECTOR_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, id },
-        },
-        error,
-      );
-    }
-  }
-
-  /**
-   * Deletes a vector by its ID.
-   * @param indexName - The name of the index containing the vector.
-   * @param id - The ID of the vector to delete.
-   * @param namespace - The namespace of the index (optional).
-   * @returns A promise that resolves when the deletion is complete.
-   * @throws Will throw an error if the deletion operation fails.
-   */
-  async deleteVector({ indexName, id, namespace }: PineconeDeleteVectorParams): Promise<void> {
-    try {
-      const index = this.client.Index(indexName).namespace(namespace || '');
-      await index.deleteOne(id);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_PINECONE_VECTOR_DELETE_VECTOR_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, id },
-        },
-        error,
-      );
-    }
-  }
-}

package/src/vector/prompt.ts

@@ -1,81 +0,0 @@
-/**
- * Vector store specific prompt that details supported operators and examples.
- * This prompt helps users construct valid filters for Pinecone Vector.
- */
-export const PINECONE_PROMPT = `When querying Pinecone, 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 all values in array
-  Example: { "tags": { "$all": ["premium", "sale"] } }
-
-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" }] }
-
-Element Operators:
-- $exists: Check if field exists
-  Example: { "rating": { "$exists": true } }
-
-Restrictions:
-- Regex patterns are not supported
-- Only $and and $or logical operators are supported at the top level
-- Empty arrays in $in/$nin will return no results
-- A non-empty array is required for $all operator
-- Nested fields are supported using dot notation
-- 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):
-  - 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 }] } }
-  - Invalid: { "field": { "$or": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$gt": { "$and": [{...}] } } }
-
-Example Complex Query:
-{
-  "$and": [
-    { "category": { "$in": ["electronics", "computers"] } },
-    { "price": { "$gte": 100, "$lte": 1000 } },
-    { "tags": { "$all": ["premium", "sale"] } },
-    { "rating": { "$exists": true, "$gt": 4 } },
-    { "$or": [
-      { "stock": { "$gt": 0 } },
-      { "preorder": true }
-    ]}
-  ]
-}`;

package/tsconfig.build.json

@@ -1,9 +0,0 @@
-{
-  "extends": ["./tsconfig.json", "../../tsconfig.build.json"],
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.test.ts", "src/**/*.mock.ts"]
-}

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*", "tsup.config.ts"],
-  "exclude": ["node_modules", "**/*.test.ts"]
-}

package/tsup.config.ts

@@ -1,17 +0,0 @@
-import { generateTypes } from '@internal/types-builder';
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['esm', 'cjs'],
-  clean: true,
-  dts: false,
-  splitting: true,
-  treeshake: {
-    preset: 'smallest',
-  },
-  sourcemap: true,
-  onSuccess: async () => {
-    await generateTypes(process.cwd());
-  },
-});

package/vitest.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-    coverage: {
-      reporter: ['text', 'json', 'html'],
-    },
-  },
-});