update postgres memory

Author: leomercier

core/src/actions/cashtags.ts

@@ -151,9 +151,9 @@ export const cashtags: Action = {
     similes: ["FIND_TOKEN", "SEARCH_TOKEN", "GET_TOKEN", "FIND_PAIR"],
     description:
         "Searches for the best matching token pair based on age, liquidity, volume, and transaction count",
-    // validate: async (runtime: IAgentRuntime, message: Memory, state: State) => {
-    //     return !!runtime.getSetting("DEXSCREENER_API_URL");
-    // },
+    validate: async (runtime: IAgentRuntime, message: Memory, state: State) => {
+        return true
+    },
     handler: async (
         runtime: IAgentRuntime,
         message: Memory,

core/src/adapters/postgres.ts

@@ -11,6 +11,8 @@ import {
     Participant,
 } from "../core/types.ts";
 import { DatabaseAdapter } from "../core/database.ts";
+import { zeroUuid } from "../test_resources/constants.ts";
+import { embeddingZeroVector } from "../core/memory.ts";
 const { Pool } = pg;
 
 export class PostgresDatabaseAdapter extends DatabaseAdapter {
@@ -265,6 +267,8 @@ export class PostgresDatabaseAdapter extends DatabaseAdapter {
                     }
                 );
                 isUnique = similarMemories.length === 0;
+            }else{
+                memory.embedding = embeddingZeroVector
             }
 
             await client.query(
@@ -287,16 +291,24 @@ export class PostgresDatabaseAdapter extends DatabaseAdapter {
             client.release();
         }
     }
-
+  
     async searchMemories(params: {
         tableName: string;
         roomId: UUID;
+        agentId?: UUID;
         embedding: number[];
         match_threshold: number;
         match_count: number;
         unique: boolean;
     }): Promise<Memory[]> {
         const client = await this.pool.connect();
+
+        const queryParams = [
+            new Float32Array(params.embedding), // Ensure embedding is Float32Array
+            params.tableName,
+            params.roomId,
+            params.match_count,
+        ];
         try {
             let sql = `
         SELECT *,
@@ -309,10 +321,17 @@ export class PostgresDatabaseAdapter extends DatabaseAdapter {
                 sql += ` AND "unique" = true`;
             }
 
+
+        if (params.agentId) {
+            sql += " AND agentId = ?";
+            queryParams.push(params.agentId);
+        }
+
             sql += ` AND 1 - (embedding <-> $3) >= $4
                ORDER BY embedding <-> $3
                LIMIT $5`;
 
+
             const { rows } = await client.query(sql, [
                 params.tableName,
                 params.roomId,
@@ -331,6 +350,7 @@ export class PostgresDatabaseAdapter extends DatabaseAdapter {
         }
     }
 
+
     async getMemories(params: {
         roomId: UUID;
         count?: number;
@@ -368,6 +388,7 @@ export class PostgresDatabaseAdapter extends DatabaseAdapter {
             if (params.agentId) {
                 sql += ` AND "agentId" = $3`;
                 values.push(params.agentId);
+                paramCount++;
             }
 
             sql += ' ORDER BY "createdAt" DESC';

core/src/adapters/sqlite.ts

@@ -242,41 +242,69 @@ export class SqliteDatabaseAdapter extends DatabaseAdapter {
         match_count: number;
         unique: boolean;
     }): Promise<Memory[]> {
-        const queryParams = [
-            new Float32Array(params.embedding), // Ensure embedding is Float32Array
-            params.tableName,
-            params.roomId,
-            params.match_count,
+        // Build the query parameters array
+        const queryParams: any[] = [
+            params.embedding, // $1: embedding vector
+            params.tableName, // $2: table name
+            params.roomId, // $3: room ID
+            params.match_count, // $4: limit count
         ];
 
+        console.log("searchMemories", params);
+
+        // Start building the SQL query
         let sql = `
-      SELECT *, vec_distance_L2(embedding, ?) AS similarity
-      FROM memories
-      WHERE type = ?`;
+        SELECT *,
+            embedding <-> $1 as similarity
+        FROM memories
+        WHERE type = $2
+        AND room_id = $3`;
+
+        let paramCount = 3; // Track the current parameter count
 
         if (params.unique) {
-            sql += " AND `unique` = 1";
+            paramCount++;
+            sql += ` AND unique = true`;
         }
 
         if (params.agentId) {
-            sql += " AND agentId = ?";
+            paramCount++;
+            sql += ` AND agent_id = $${paramCount}`;
             queryParams.push(params.agentId);
         }
 
-        sql += ` ORDER BY similarity ASC LIMIT ?`; // ASC for lower distance
-        // Updated queryParams order matches the placeholders
+        // Add similarity threshold if specified
+        if (params.match_threshold) {
+            paramCount++;
+            sql += ` AND embedding <-> $1 < $${paramCount}`;
+            queryParams.push(params.match_threshold);
+        }
 
-        const memories = this.db.prepare(sql).all(...queryParams) as (Memory & {
-            similarity: number;
-        })[];
-        return memories.map((memory) => ({
-            ...memory,
-            createdAt:
-                typeof memory.createdAt === "string"
-                    ? Date.parse(memory.createdAt as string)
-                    : memory.createdAt,
-            content: JSON.parse(memory.content as unknown as string),
-        }));
+        // Order by similarity and limit results
+        sql += `
+        ORDER BY similarity ASC
+        LIMIT $4`;
+
+        try {
+            // Use the pg pool or client to execute the query
+            const result = await this.db.query(sql, queryParams);
+
+            // Process and return the results
+            return result.rows.map((row) => ({
+                ...row,
+                createdAt:
+                    typeof row.created_at === "string"
+                        ? Date.parse(row.created_at)
+                        : row.created_at,
+                content:
+                    typeof row.content === "string"
+                        ? JSON.parse(row.content)
+                        : row.content,
+            }));
+        } catch (error) {
+            console.error("Error executing vector similarity search:", error);
+            throw error;
+        }
     }
 
     async searchMemoriesByEmbedding(