@mastra/pg 0.2.7-alpha.4 → 0.2.7-alpha.6

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.2.7-alpha.4 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.2.7-alpha.6 build /home/runner/work/mastra/mastra/stores/pg
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.4.0
 TSC Build start
-TSC ⚡️ Build success in 11374ms
+TSC ⚡️ Build success in 10263ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/pg/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/pg/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 11499ms
+DTS ⚡️ Build success in 11464ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 40.67 KB
-CJS ⚡️ Build success in 1559ms
-ESM dist/index.js 40.32 KB
-ESM ⚡️ Build success in 1569ms
+CJS dist/index.cjs 40.86 KB
+CJS ⚡️ Build success in 1298ms
+ESM dist/index.js 40.44 KB
+ESM ⚡️ Build success in 1321ms

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @mastra/pg
 
+## 0.2.7-alpha.6
+
+### Patch Changes
+
+- a3f0e90: Update storage initialization to ensure tables are present
+- Updated dependencies [a3f0e90]
+  - @mastra/core@0.8.0-alpha.6
+
+## 0.2.7-alpha.5
+
+### Patch Changes
+
+- 93875ed: Improved the performance of Memory semantic recall by 2 to 3 times when using pg by making tweaks to @mastra/memory @mastra/core and @mastra/pg
+- Updated dependencies [93875ed]
+  - @mastra/core@0.8.0-alpha.5
+
 ## 0.2.7-alpha.4
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -200,12 +200,18 @@ declare interface PgQueryVectorParams extends QueryVectorParams {
 
 declare class PgVector extends MastraVector {
     private pool;
-    private indexCache;
+    private describeIndexCache;
+    private createdIndexes;
+    private mutexesByName;
     constructor(connectionString: string);
+    private getMutexByName;
     transformFilter(filter?: VectorFilter): VectorFilter;
     getIndexInfo(indexName: string): Promise<PGIndexStats>;
     query(...args: ParamsToArgs<PgQueryVectorParams> | PgQueryVectorArgs): Promise<QueryResult[]>;
     upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    private hasher;
+    private getIndexCacheKey;
+    private cachedIndexExists;
     createIndex(...args: ParamsToArgs<PgCreateIndexParams> | PgCreateIndexArgs): Promise<void>;
     /**
      * @deprecated This function is deprecated. Use buildIndex instead

package/dist/_tsup-dts-rollup.d.ts

@@ -200,12 +200,18 @@ declare interface PgQueryVectorParams extends QueryVectorParams {
 
 declare class PgVector extends MastraVector {
     private pool;
-    private indexCache;
+    private describeIndexCache;
+    private createdIndexes;
+    private mutexesByName;
     constructor(connectionString: string);
+    private getMutexByName;
     transformFilter(filter?: VectorFilter): VectorFilter;
     getIndexInfo(indexName: string): Promise<PGIndexStats>;
     query(...args: ParamsToArgs<PgQueryVectorParams> | PgQueryVectorArgs): Promise<QueryResult[]>;
     upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    private hasher;
+    private getIndexCacheKey;
+    private cachedIndexExists;
     createIndex(...args: ParamsToArgs<PgCreateIndexParams> | PgCreateIndexArgs): Promise<void>;
     /**
      * @deprecated This function is deprecated. Use buildIndex instead

package/dist/index.cjs

@@ -1,8 +1,9 @@
 'use strict';
 
-var crypto$1 = require('crypto');
 var vector = require('@mastra/core/vector');
+var asyncMutex = require('async-mutex');
 var pg = require('pg');
+var xxhash = require('xxhash-wasm');
 var filter = require('@mastra/core/vector/filter');
 var storage = require('@mastra/core/storage');
 var pgPromise = require('pg-promise');
@@ -10,6 +11,7 @@ var pgPromise = require('pg-promise');
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var pg__default = /*#__PURE__*/_interopDefault(pg);
+var xxhash__default = /*#__PURE__*/_interopDefault(xxhash);
 var pgPromise__default = /*#__PURE__*/_interopDefault(pgPromise);
 
 // src/vector/index.ts
@@ -294,7 +296,9 @@ function buildFilterQuery(filter, minScore) {
 // src/vector/index.ts
 var PgVector = class extends vector.MastraVector {
   pool;
-  indexCache = /* @__PURE__ */ new Map();
+  describeIndexCache = /* @__PURE__ */ new Map();
+  createdIndexes = /* @__PURE__ */ new Map();
+  mutexesByName = /* @__PURE__ */ new Map();
   constructor(connectionString) {
     super();
     const basePool = new pg__default.default.Pool({
@@ -313,16 +317,33 @@ var PgVector = class extends vector.MastraVector {
         "vector.type": "postgres"
       }
     }) ?? basePool;
+    void (async () => {
+      const existingIndexes = await this.listIndexes();
+      void existingIndexes.map(async (indexName) => {
+        const info = await this.getIndexInfo(indexName);
+        const key = await this.getIndexCacheKey({
+          indexName,
+          metric: info.metric,
+          dimension: info.dimension,
+          type: info.type
+        });
+        this.createdIndexes.set(indexName, key);
+      });
+    })();
+  }
+  getMutexByName(indexName) {
+    if (!this.mutexesByName.has(indexName)) this.mutexesByName.set(indexName, new asyncMutex.Mutex());
+    return this.mutexesByName.get(indexName);
   }
   transformFilter(filter) {
     const translator = new PGFilterTranslator();
     return translator.translate(filter);
   }
   async getIndexInfo(indexName) {
-    if (!this.indexCache.has(indexName)) {
-      this.indexCache.set(indexName, await this.describeIndex(indexName));
+    if (!this.describeIndexCache.has(indexName)) {
+      this.describeIndexCache.set(indexName, await this.describeIndex(indexName));
     }
-    return this.indexCache.get(indexName);
+    return this.describeIndexCache.get(indexName);
   }
   async query(...args) {
     const params = this.normalizeArgs("query", args, [
@@ -408,69 +429,77 @@ var PgVector = class extends vector.MastraVector {
       client.release();
     }
   }
+  hasher = xxhash__default.default();
+  async getIndexCacheKey(params) {
+    const input = params.indexName + params.dimension + params.metric + (params.type || "ivfflat");
+    return (await this.hasher).h32(input);
+  }
+  cachedIndexExists(indexName, newKey) {
+    const existingIndexCacheKey = this.createdIndexes.get(indexName);
+    return existingIndexCacheKey && existingIndexCacheKey === newKey;
+  }
   async createIndex(...args) {
     const params = this.normalizeArgs("createIndex", args, [
       "indexConfig",
       "buildIndex"
     ]);
     const { indexName, dimension, metric = "cosine", indexConfig = {}, buildIndex = true } = params;
-    const client = await this.pool.connect();
-    try {
-      if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
-        throw new Error("Invalid index name format");
-      }
-      if (!Number.isInteger(dimension) || dimension <= 0) {
-        throw new Error("Dimension must be a positive integer");
+    if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
+      throw new Error("Invalid index name format");
+    }
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+      throw new Error("Dimension must be a positive integer");
+    }
+    const indexCacheKey = await this.getIndexCacheKey({ indexName, dimension, type: indexConfig.type, metric });
+    if (this.cachedIndexExists(indexName, indexCacheKey)) {
+      return;
+    }
+    const mutex = this.getMutexByName(`create-${indexName}`);
+    await mutex.runExclusive(async () => {
+      if (this.cachedIndexExists(indexName, indexCacheKey)) {
+        return;
       }
-      const extensionCheck = await client.query(`
+      const client = await this.pool.connect();
+      try {
+        const extensionCheck = await client.query(`
         SELECT EXISTS (
           SELECT 1 FROM pg_available_extensions WHERE name = 'vector'
         );
       `);
-      if (!extensionCheck.rows[0].exists) {
-        throw new Error("PostgreSQL vector extension is not available. Please install it first.");
-      }
-      const hash = crypto$1.createHash("sha256").update(indexName).digest("hex");
-      const lockId = BigInt("0x" + hash.slice(0, 8)) % BigInt(2 ** 31);
-      const acquired = await client.query("SELECT pg_try_advisory_lock($1)", [lockId]);
-      if (!acquired.rows[0].pg_try_advisory_lock) {
-        const exists = await client.query(
-          `
-          SELECT 1 FROM pg_class c 
-          JOIN pg_namespace n ON n.oid = c.relnamespace
-          WHERE c.relname = $1 
-          AND n.nspname = 'public'
-        `,
-          [indexName]
-        );
-        if (exists.rows.length > 0) {
-          console.log(`Table ${indexName} already exists, skipping creation`);
-          return;
+        if (!extensionCheck.rows[0].exists) {
+          this.createdIndexes.delete(indexName);
+          throw new Error("PostgreSQL vector extension is not available. Please install it first.");
         }
-        await client.query("SELECT pg_advisory_lock($1)", [lockId]);
-      }
-      try {
-        await client.query("CREATE EXTENSION IF NOT EXISTS vector");
-        await client.query(`
-        CREATE TABLE IF NOT EXISTS ${indexName} (
-          id SERIAL PRIMARY KEY,
-          vector_id TEXT UNIQUE NOT NULL,
-          embedding vector(${dimension}),
-          metadata JSONB DEFAULT '{}'::jsonb
-        );
-      `);
+        try {
+          await client.query(`
+          DO $$ 
+          BEGIN
+            CREATE EXTENSION IF NOT EXISTS vector;
+            
+            CREATE TABLE IF NOT EXISTS ${indexName} (
+              id SERIAL PRIMARY KEY,
+              vector_id TEXT UNIQUE NOT NULL,
+              embedding vector(${dimension}),
+              metadata JSONB DEFAULT '{}'::jsonb
+            );
+          END $$;
+        `);
+          this.createdIndexes.set(indexName, indexCacheKey);
+        } catch (e) {
+          this.createdIndexes.delete(indexName);
+          throw e;
+        }
+        if (buildIndex) {
+          await this.setupIndex({ indexName, metric, indexConfig }, client);
+        }
+      } catch (error) {
+        this.createdIndexes.delete(indexName);
+        console.error("Failed to create vector table:", error);
+        throw error;
       } finally {
-        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
+        client.release();
       }
-      if (buildIndex) {
-        await this.setupIndex({ indexName, metric, indexConfig }, client);
-      }
-    } catch (error) {
-      console.error("Failed to create vector table:", error);
-      throw error;
-    } finally {
-      client.release();
-    }
+    });
   }
   /**
    * @deprecated This function is deprecated. Use buildIndex instead
@@ -492,30 +521,13 @@ var PgVector = class extends vector.MastraVector {
     }
   }
   async setupIndex({ indexName, metric, indexConfig }, client) {
-    const hash = crypto$1.createHash("sha256").update("build:" + indexName).digest("hex");
-    const lockId = BigInt("0x" + hash.slice(0, 8)) % BigInt(2 ** 31);
-    const acquired = await client.query("SELECT pg_try_advisory_lock($1)", [lockId]);
-    if (!acquired.rows[0].pg_try_advisory_lock) {
-      const exists = await client.query(
-        `
-            SELECT 1 FROM pg_class c 
-            JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relname = $1 
-            AND n.nspname = 'public'
-          `,
-        [`${indexName}_vector_idx`]
-      );
-      if (exists.rows.length > 0) {
-        console.log(`Index ${indexName}_vector_idx already exists, skipping creation`);
-        this.indexCache.delete(indexName);
-        return;
+    const mutex = this.getMutexByName(`build-${indexName}`);
+    await mutex.runExclusive(async () => {
+      if (this.createdIndexes.has(indexName)) {
+        await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
       }
-      await client.query("SELECT pg_advisory_lock($1)", [lockId]);
-    }
-    try {
-      await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
       if (indexConfig.type === "flat") {
-        this.indexCache.delete(indexName);
+        this.describeIndexCache.delete(indexName);
         return;
       }
       const metricOp = metric === "cosine" ? "vector_cosine_ops" : metric === "euclidean" ? "vector_l2_ops" : "vector_ip_ops";
@@ -548,10 +560,7 @@ var PgVector = class extends vector.MastraVector {
         `;
       }
       await client.query(indexSQL);
-      this.indexCache.delete(indexName);
-    } finally {
-      await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
-    }
+    });
   }
   async listIndexes() {
     const client = await this.pool.connect();
@@ -577,8 +586,7 @@ var PgVector = class extends vector.MastraVector {
                 WHERE attrelid = $1::regclass
                 AND attname = 'embedding';
             `;
-      const countQuery = `
-                SELECT COUNT(*) as count
+      const countQuery = `                SELECT COUNT(*) as count
                 FROM ${indexName};
             `;
       const indexQuery = `
@@ -631,6 +639,7 @@ var PgVector = class extends vector.MastraVector {
     const client = await this.pool.connect();
     try {
       await client.query(`DROP TABLE IF EXISTS ${indexName} CASCADE`);
+      this.createdIndexes.delete(indexName);
     } catch (error) {
       await client.query("ROLLBACK");
       throw new Error(`Failed to delete vector table: ${error.message}`);
@@ -713,15 +722,16 @@ var PostgresStore = class extends storage.MastraStorage {
       }
     );
   }
-  getEvalsByAgentName(agentName, type) {
+  async getEvalsByAgentName(agentName, type) {
     try {
       const baseQuery = `SELECT * FROM ${storage.TABLE_EVALS} WHERE agent_name = $1`;
       const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
       const query = `${baseQuery}${typeCondition} ORDER BY created_at DESC`;
-      return this.db.manyOrNone(query, [agentName]).then((rows) => rows?.map((row) => this.transformEvalRow(row)) ?? []);
+      const rows = await this.db.manyOrNone(query, [agentName]);
+      return rows?.map((row) => this.transformEvalRow(row)) ?? [];
     } catch (error) {
       if (error instanceof Error && error.message.includes("relation") && error.message.includes("does not exist")) {
-        return Promise.resolve([]);
+        return [];
       }
       console.error("Failed to get evals for the specified agent: " + error?.message);
       throw error;
@@ -808,11 +818,6 @@ var PostgresStore = class extends storage.MastraStorage {
         args.push(value);
       }
     }
-    console.log(
-      "QUERY",
-      `SELECT * FROM ${storage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
-      args
-    );
     const result = await this.db.manyOrNone(`SELECT * FROM ${storage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`, args);
     if (!result) {
       return [];

package/dist/index.js

@@ -1,6 +1,7 @@
-import { createHash } from 'crypto';
 import { MastraVector } from '@mastra/core/vector';
+import { Mutex } from 'async-mutex';
 import pg from 'pg';
+import xxhash from 'xxhash-wasm';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 import { MastraStorage, TABLE_EVALS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT, TABLE_THREADS, TABLE_MESSAGES } from '@mastra/core/storage';
 import pgPromise from 'pg-promise';
@@ -287,7 +288,9 @@ function buildFilterQuery(filter, minScore) {
 // src/vector/index.ts
 var PgVector = class extends MastraVector {
   pool;
-  indexCache = /* @__PURE__ */ new Map();
+  describeIndexCache = /* @__PURE__ */ new Map();
+  createdIndexes = /* @__PURE__ */ new Map();
+  mutexesByName = /* @__PURE__ */ new Map();
   constructor(connectionString) {
     super();
     const basePool = new pg.Pool({
@@ -306,16 +309,33 @@ var PgVector = class extends MastraVector {
         "vector.type": "postgres"
       }
     }) ?? basePool;
+    void (async () => {
+      const existingIndexes = await this.listIndexes();
+      void existingIndexes.map(async (indexName) => {
+        const info = await this.getIndexInfo(indexName);
+        const key = await this.getIndexCacheKey({
+          indexName,
+          metric: info.metric,
+          dimension: info.dimension,
+          type: info.type
+        });
+        this.createdIndexes.set(indexName, key);
+      });
+    })();
+  }
+  getMutexByName(indexName) {
+    if (!this.mutexesByName.has(indexName)) this.mutexesByName.set(indexName, new Mutex());
+    return this.mutexesByName.get(indexName);
   }
   transformFilter(filter) {
     const translator = new PGFilterTranslator();
     return translator.translate(filter);
   }
   async getIndexInfo(indexName) {
-    if (!this.indexCache.has(indexName)) {
-      this.indexCache.set(indexName, await this.describeIndex(indexName));
+    if (!this.describeIndexCache.has(indexName)) {
+      this.describeIndexCache.set(indexName, await this.describeIndex(indexName));
     }
-    return this.indexCache.get(indexName);
+    return this.describeIndexCache.get(indexName);
   }
   async query(...args) {
     const params = this.normalizeArgs("query", args, [
@@ -401,69 +421,77 @@ var PgVector = class extends MastraVector {
       client.release();
     }
   }
+  hasher = xxhash();
+  async getIndexCacheKey(params) {
+    const input = params.indexName + params.dimension + params.metric + (params.type || "ivfflat");
+    return (await this.hasher).h32(input);
+  }
+  cachedIndexExists(indexName, newKey) {
+    const existingIndexCacheKey = this.createdIndexes.get(indexName);
+    return existingIndexCacheKey && existingIndexCacheKey === newKey;
+  }
   async createIndex(...args) {
     const params = this.normalizeArgs("createIndex", args, [
       "indexConfig",
       "buildIndex"
     ]);
     const { indexName, dimension, metric = "cosine", indexConfig = {}, buildIndex = true } = params;
-    const client = await this.pool.connect();
-    try {
-      if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
-        throw new Error("Invalid index name format");
-      }
-      if (!Number.isInteger(dimension) || dimension <= 0) {
-        throw new Error("Dimension must be a positive integer");
+    if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
+      throw new Error("Invalid index name format");
+    }
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+      throw new Error("Dimension must be a positive integer");
+    }
+    const indexCacheKey = await this.getIndexCacheKey({ indexName, dimension, type: indexConfig.type, metric });
+    if (this.cachedIndexExists(indexName, indexCacheKey)) {
+      return;
+    }
+    const mutex = this.getMutexByName(`create-${indexName}`);
+    await mutex.runExclusive(async () => {
+      if (this.cachedIndexExists(indexName, indexCacheKey)) {
+        return;
       }
-      const extensionCheck = await client.query(`
+      const client = await this.pool.connect();
+      try {
+        const extensionCheck = await client.query(`
         SELECT EXISTS (
           SELECT 1 FROM pg_available_extensions WHERE name = 'vector'
         );
       `);
-      if (!extensionCheck.rows[0].exists) {
-        throw new Error("PostgreSQL vector extension is not available. Please install it first.");
-      }
-      const hash = createHash("sha256").update(indexName).digest("hex");
-      const lockId = BigInt("0x" + hash.slice(0, 8)) % BigInt(2 ** 31);
-      const acquired = await client.query("SELECT pg_try_advisory_lock($1)", [lockId]);
-      if (!acquired.rows[0].pg_try_advisory_lock) {
-        const exists = await client.query(
-          `
-          SELECT 1 FROM pg_class c 
-          JOIN pg_namespace n ON n.oid = c.relnamespace
-          WHERE c.relname = $1 
-          AND n.nspname = 'public'
-        `,
-          [indexName]
-        );
-        if (exists.rows.length > 0) {
-          console.log(`Table ${indexName} already exists, skipping creation`);
-          return;
+        if (!extensionCheck.rows[0].exists) {
+          this.createdIndexes.delete(indexName);
+          throw new Error("PostgreSQL vector extension is not available. Please install it first.");
         }
-        await client.query("SELECT pg_advisory_lock($1)", [lockId]);
-      }
-      try {
-        await client.query("CREATE EXTENSION IF NOT EXISTS vector");
-        await client.query(`
-        CREATE TABLE IF NOT EXISTS ${indexName} (
-          id SERIAL PRIMARY KEY,
-          vector_id TEXT UNIQUE NOT NULL,
-          embedding vector(${dimension}),
-          metadata JSONB DEFAULT '{}'::jsonb
-        );
-      `);
+        try {
+          await client.query(`
+          DO $$ 
+          BEGIN
+            CREATE EXTENSION IF NOT EXISTS vector;
+            
+            CREATE TABLE IF NOT EXISTS ${indexName} (
+              id SERIAL PRIMARY KEY,
+              vector_id TEXT UNIQUE NOT NULL,
+              embedding vector(${dimension}),
+              metadata JSONB DEFAULT '{}'::jsonb
+            );
+          END $$;
+        `);
+          this.createdIndexes.set(indexName, indexCacheKey);
+        } catch (e) {
+          this.createdIndexes.delete(indexName);
+          throw e;
+        }
+        if (buildIndex) {
+          await this.setupIndex({ indexName, metric, indexConfig }, client);
+        }
+      } catch (error) {
+        this.createdIndexes.delete(indexName);
+        console.error("Failed to create vector table:", error);
+        throw error;
       } finally {
-        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
+        client.release();
       }
-      if (buildIndex) {
-        await this.setupIndex({ indexName, metric, indexConfig }, client);
-      }
-    } catch (error) {
-      console.error("Failed to create vector table:", error);
-      throw error;
-    } finally {
-      client.release();
-    }
+    });
   }
   /**
    * @deprecated This function is deprecated. Use buildIndex instead
@@ -485,30 +513,13 @@ var PgVector = class extends MastraVector {
     }
   }
   async setupIndex({ indexName, metric, indexConfig }, client) {
-    const hash = createHash("sha256").update("build:" + indexName).digest("hex");
-    const lockId = BigInt("0x" + hash.slice(0, 8)) % BigInt(2 ** 31);
-    const acquired = await client.query("SELECT pg_try_advisory_lock($1)", [lockId]);
-    if (!acquired.rows[0].pg_try_advisory_lock) {
-      const exists = await client.query(
-        `
-            SELECT 1 FROM pg_class c 
-            JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relname = $1 
-            AND n.nspname = 'public'
-          `,
-        [`${indexName}_vector_idx`]
-      );
-      if (exists.rows.length > 0) {
-        console.log(`Index ${indexName}_vector_idx already exists, skipping creation`);
-        this.indexCache.delete(indexName);
-        return;
+    const mutex = this.getMutexByName(`build-${indexName}`);
+    await mutex.runExclusive(async () => {
+      if (this.createdIndexes.has(indexName)) {
+        await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
       }
-      await client.query("SELECT pg_advisory_lock($1)", [lockId]);
-    }
-    try {
-      await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
       if (indexConfig.type === "flat") {
-        this.indexCache.delete(indexName);
+        this.describeIndexCache.delete(indexName);
         return;
       }
       const metricOp = metric === "cosine" ? "vector_cosine_ops" : metric === "euclidean" ? "vector_l2_ops" : "vector_ip_ops";
@@ -541,10 +552,7 @@ var PgVector = class extends MastraVector {
         `;
       }
       await client.query(indexSQL);
-      this.indexCache.delete(indexName);
-    } finally {
-      await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
-    }
+    });
   }
   async listIndexes() {
     const client = await this.pool.connect();
@@ -570,8 +578,7 @@ var PgVector = class extends MastraVector {
                 WHERE attrelid = $1::regclass
                 AND attname = 'embedding';
             `;
-      const countQuery = `
-                SELECT COUNT(*) as count
+      const countQuery = `                SELECT COUNT(*) as count
                 FROM ${indexName};
             `;
       const indexQuery = `
@@ -624,6 +631,7 @@ var PgVector = class extends MastraVector {
     const client = await this.pool.connect();
     try {
       await client.query(`DROP TABLE IF EXISTS ${indexName} CASCADE`);
+      this.createdIndexes.delete(indexName);
     } catch (error) {
       await client.query("ROLLBACK");
       throw new Error(`Failed to delete vector table: ${error.message}`);
@@ -706,15 +714,16 @@ var PostgresStore = class extends MastraStorage {
       }
     );
   }
-  getEvalsByAgentName(agentName, type) {
+  async getEvalsByAgentName(agentName, type) {
     try {
       const baseQuery = `SELECT * FROM ${TABLE_EVALS} WHERE agent_name = $1`;
       const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
       const query = `${baseQuery}${typeCondition} ORDER BY created_at DESC`;
-      return this.db.manyOrNone(query, [agentName]).then((rows) => rows?.map((row) => this.transformEvalRow(row)) ?? []);
+      const rows = await this.db.manyOrNone(query, [agentName]);
+      return rows?.map((row) => this.transformEvalRow(row)) ?? [];
     } catch (error) {
       if (error instanceof Error && error.message.includes("relation") && error.message.includes("does not exist")) {
-        return Promise.resolve([]);
+        return [];
       }
       console.error("Failed to get evals for the specified agent: " + error?.message);
       throw error;
@@ -801,11 +810,6 @@ var PostgresStore = class extends MastraStorage {
         args.push(value);
       }
     }
-    console.log(
-      "QUERY",
-      `SELECT * FROM ${TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
-      args
-    );
     const result = await this.db.manyOrNone(`SELECT * FROM ${TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`, args);
     if (!result) {
       return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.2.7-alpha.4",
+  "version": "0.2.7-alpha.6",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -19,9 +19,11 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
+    "async-mutex": "^0.5.0",
     "pg": "^8.13.3",
     "pg-promise": "^11.11.0",
-    "@mastra/core": "^0.8.0-alpha.4"
+    "xxhash-wasm": "^1.1.0",
+    "@mastra/core": "^0.8.0-alpha.6"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",

package/src/storage/index.ts

@@ -47,7 +47,7 @@ export class PostgresStore extends MastraStorage {
     );
   }
 
-  getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
+  async getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
     try {
       const baseQuery = `SELECT * FROM ${TABLE_EVALS} WHERE agent_name = $1`;
       const typeCondition =
@@ -59,11 +59,12 @@ export class PostgresStore extends MastraStorage {
 
       const query = `${baseQuery}${typeCondition} ORDER BY created_at DESC`;
 
-      return this.db.manyOrNone(query, [agentName]).then(rows => rows?.map(row => this.transformEvalRow(row)) ?? []);
+      const rows = await this.db.manyOrNone(query, [agentName]);
+      return rows?.map(row => this.transformEvalRow(row)) ?? [];
     } catch (error) {
       // Handle case where table doesn't exist yet
       if (error instanceof Error && error.message.includes('relation') && error.message.includes('does not exist')) {
-        return Promise.resolve([]);
+        return [];
       }
       console.error('Failed to get evals for the specified agent: ' + (error as any)?.message);
       throw error;
@@ -170,12 +171,6 @@ export class PostgresStore extends MastraStorage {
       }
     }
 
-    console.log(
-      'QUERY',
-      `SELECT * FROM ${TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
-      args,
-    );
-
     const result = await this.db.manyOrNone<{
       id: string;
       parentSpanId: string;

package/src/vector/index.ts

@@ -1,4 +1,3 @@
-import { createHash } from 'crypto';
 import { MastraVector } from '@mastra/core/vector';
 import type {
   IndexStats,
@@ -11,7 +10,9 @@ import type {
   CreateIndexArgs,
 } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
+import { Mutex } from 'async-mutex';
 import pg from 'pg';
+import xxhash from 'xxhash-wasm';
 
 import { PGFilterTranslator } from './filter';
 import { buildFilterQuery } from './sql-builder';
@@ -60,7 +61,9 @@ type PgDefineIndexArgs = [string, 'cosine' | 'euclidean' | 'dotproduct', IndexCo
 
 export class PgVector extends MastraVector {
   private pool: pg.Pool;
-  private indexCache: Map<string, PGIndexStats> = new Map();
+  private describeIndexCache: Map<string, PGIndexStats> = new Map();
+  private createdIndexes = new Map<string, number>();
+  private mutexesByName = new Map<string, Mutex>();
 
   constructor(connectionString: string) {
     super();
@@ -81,6 +84,26 @@ export class PgVector extends MastraVector {
           'vector.type': 'postgres',
         },
       }) ?? basePool;
+
+    void (async () => {
+      // warm the created indexes cache so we don't need to check if indexes exist every time
+      const existingIndexes = await this.listIndexes();
+      void existingIndexes.map(async indexName => {
+        const info = await this.getIndexInfo(indexName);
+        const key = await this.getIndexCacheKey({
+          indexName,
+          metric: info.metric,
+          dimension: info.dimension,
+          type: info.type,
+        });
+        this.createdIndexes.set(indexName, key);
+      });
+    })();
+  }
+
+  private getMutexByName(indexName: string) {
+    if (!this.mutexesByName.has(indexName)) this.mutexesByName.set(indexName, new Mutex());
+    return this.mutexesByName.get(indexName)!;
   }
 
   transformFilter(filter?: VectorFilter) {
@@ -89,10 +112,10 @@ export class PgVector extends MastraVector {
   }
 
   async getIndexInfo(indexName: string): Promise<PGIndexStats> {
-    if (!this.indexCache.has(indexName)) {
-      this.indexCache.set(indexName, await this.describeIndex(indexName));
+    if (!this.describeIndexCache.has(indexName)) {
+      this.describeIndexCache.set(indexName, await this.describeIndex(indexName));
     }
-    return this.indexCache.get(indexName)!;
+    return this.describeIndexCache.get(indexName)!;
   }
 
   async query(...args: ParamsToArgs<PgQueryVectorParams> | PgQueryVectorArgs): Promise<QueryResult[]> {
@@ -197,6 +220,15 @@ export class PgVector extends MastraVector {
     }
   }
 
+  private hasher = xxhash();
+  private async getIndexCacheKey(params: CreateIndexParams & { type: IndexType | undefined }) {
+    const input = params.indexName + params.dimension + params.metric + (params.type || 'ivfflat'); // ivfflat is default
+    return (await this.hasher).h32(input);
+  }
+  private cachedIndexExists(indexName: string, newKey: number) {
+    const existingIndexCacheKey = this.createdIndexes.get(indexName);
+    return existingIndexCacheKey && existingIndexCacheKey === newKey;
+  }
   async createIndex(...args: ParamsToArgs<PgCreateIndexParams> | PgCreateIndexArgs): Promise<void> {
     const params = this.normalizeArgs<PgCreateIndexParams, PgCreateIndexArgs>('createIndex', args, [
       'indexConfig',
@@ -205,81 +237,74 @@ export class PgVector extends MastraVector {
 
     const { indexName, dimension, metric = 'cosine', indexConfig = {}, buildIndex = true } = params;
 
-    const client = await this.pool.connect();
-    try {
-      // Validate inputs
-      if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
-        throw new Error('Invalid index name format');
-      }
-      if (!Number.isInteger(dimension) || dimension <= 0) {
-        throw new Error('Dimension must be a positive integer');
+    // Validate inputs
+    if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
+      throw new Error('Invalid index name format');
+    }
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+      throw new Error('Dimension must be a positive integer');
+    }
+
+    const indexCacheKey = await this.getIndexCacheKey({ indexName, dimension, type: indexConfig.type, metric });
+    if (this.cachedIndexExists(indexName, indexCacheKey)) {
+      // we already saw this index get created since the process started, no need to recreate it
+      return;
+    }
+
+    const mutex = this.getMutexByName(`create-${indexName}`);
+    // Use async-mutex instead of advisory lock for perf (over 2x as fast)
+    await mutex.runExclusive(async () => {
+      if (this.cachedIndexExists(indexName, indexCacheKey)) {
+        // this may have been created while we were waiting to acquire a lock
+        return;
       }
 
-      // First check if vector extension is available
-      const extensionCheck = await client.query(`
+      const client = await this.pool.connect();
+      try {
+        // First check if vector extension is available
+        const extensionCheck = await client.query(`
         SELECT EXISTS (
           SELECT 1 FROM pg_available_extensions WHERE name = 'vector'
         );
       `);
 
-      if (!extensionCheck.rows[0].exists) {
-        throw new Error('PostgreSQL vector extension is not available. Please install it first.');
-      }
-
-      // Get advisory lock using hash of index name
-      const hash = createHash('sha256').update(indexName).digest('hex');
-      const lockId = BigInt('0x' + hash.slice(0, 8)) % BigInt(2 ** 31); // Take first 8 chars and convert to number
-      const acquired = await client.query('SELECT pg_try_advisory_lock($1)', [lockId]);
-
-      if (!acquired.rows[0].pg_try_advisory_lock) {
-        // Check if table already exists
-        const exists = await client.query(
-          `
-          SELECT 1 FROM pg_class c 
-          JOIN pg_namespace n ON n.oid = c.relnamespace
-          WHERE c.relname = $1 
-          AND n.nspname = 'public'
-        `,
-          [indexName],
-        );
-
-        if (exists.rows.length > 0) {
-          // Table exists so return early
-          console.log(`Table ${indexName} already exists, skipping creation`);
-          return;
+        if (!extensionCheck.rows[0].exists) {
+          this.createdIndexes.delete(indexName);
+          throw new Error('PostgreSQL vector extension is not available. Please install it first.');
         }
 
-        // Table doesn't exist, wait for lock
-        await client.query('SELECT pg_advisory_lock($1)', [lockId]);
-      }
-
-      try {
         // Try to create extension
-        await client.query('CREATE EXTENSION IF NOT EXISTS vector');
-
-        // Create the table with explicit schema
-        await client.query(`
-        CREATE TABLE IF NOT EXISTS ${indexName} (
-          id SERIAL PRIMARY KEY,
-          vector_id TEXT UNIQUE NOT NULL,
-          embedding vector(${dimension}),
-          metadata JSONB DEFAULT '{}'::jsonb
-        );
-      `);
-      } finally {
-        // Always release lock
-        await client.query('SELECT pg_advisory_unlock($1)', [lockId]);
-      }
+        try {
+          await client.query(`
+          DO $$ 
+          BEGIN
+            CREATE EXTENSION IF NOT EXISTS vector;
+            
+            CREATE TABLE IF NOT EXISTS ${indexName} (
+              id SERIAL PRIMARY KEY,
+              vector_id TEXT UNIQUE NOT NULL,
+              embedding vector(${dimension}),
+              metadata JSONB DEFAULT '{}'::jsonb
+            );
+          END $$;
+        `);
+          this.createdIndexes.set(indexName, indexCacheKey);
+        } catch (e) {
+          this.createdIndexes.delete(indexName);
+          throw e;
+        }
 
-      if (buildIndex) {
-        await this.setupIndex({ indexName, metric, indexConfig }, client);
+        if (buildIndex) {
+          await this.setupIndex({ indexName, metric, indexConfig }, client);
+        }
+      } catch (error: any) {
+        this.createdIndexes.delete(indexName);
+        console.error('Failed to create vector table:', error);
+        throw error;
+      } finally {
+        client.release();
       }
-    } catch (error: any) {
-      console.error('Failed to create vector table:', error);
-      throw error;
-    } finally {
-      client.release();
-    }
+    });
   }
 
   /**
@@ -310,40 +335,15 @@ export class PgVector extends MastraVector {
   }
 
   private async setupIndex({ indexName, metric, indexConfig }: PgDefineIndexParams, client: pg.PoolClient) {
-    // Use a different hash prefix for buildIndex locks to avoid conflicts with createIndex
-    const hash = createHash('sha256')
-      .update('build:' + indexName)
-      .digest('hex');
-    const lockId = BigInt('0x' + hash.slice(0, 8)) % BigInt(2 ** 31);
-    const acquired = await client.query('SELECT pg_try_advisory_lock($1)', [lockId]);
-
-    if (!acquired.rows[0].pg_try_advisory_lock) {
-      // Check if index already exists
-      const exists = await client.query(
-        `
-            SELECT 1 FROM pg_class c 
-            JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relname = $1 
-            AND n.nspname = 'public'
-          `,
-        [`${indexName}_vector_idx`],
-      );
-
-      if (exists.rows.length > 0) {
-        console.log(`Index ${indexName}_vector_idx already exists, skipping creation`);
-        this.indexCache.delete(indexName); // Still clear cache since we checked
-        return;
+    const mutex = this.getMutexByName(`build-${indexName}`);
+    // Use async-mutex instead of advisory lock for perf (over 2x as fast)
+    await mutex.runExclusive(async () => {
+      if (this.createdIndexes.has(indexName)) {
+        await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
       }
 
-      // Index doesn't exist, wait for lock
-      await client.query('SELECT pg_advisory_lock($1)', [lockId]);
-    }
-
-    try {
-      await client.query(`DROP INDEX IF EXISTS ${indexName}_vector_idx`);
-
       if (indexConfig.type === 'flat') {
-        this.indexCache.delete(indexName);
+        this.describeIndexCache.delete(indexName);
         return;
       }
 
@@ -381,10 +381,7 @@ export class PgVector extends MastraVector {
       }
 
       await client.query(indexSQL);
-      this.indexCache.delete(indexName);
-    } finally {
-      await client.query('SELECT pg_advisory_unlock($1)', [lockId]);
-    }
+    });
   }
 
   async listIndexes(): Promise<string[]> {
@@ -416,8 +413,7 @@ export class PgVector extends MastraVector {
             `;
 
       // Get row count
-      const countQuery = `
-                SELECT COUNT(*) as count
+      const countQuery = `                SELECT COUNT(*) as count
                 FROM ${indexName};
             `;
 
@@ -486,6 +482,7 @@ export class PgVector extends MastraVector {
     try {
       // Drop the table
       await client.query(`DROP TABLE IF EXISTS ${indexName} CASCADE`);
+      this.createdIndexes.delete(indexName);
     } catch (error: any) {
       await client.query('ROLLBACK');
       throw new Error(`Failed to delete vector table: ${error.message}`);