@props-labs/mesh-os 0.1.8 → 0.1.10

package/README.md

@@ -143,15 +143,8 @@ flowchart LR
 
 ## Getting Started
 
-### Install & Create a New Instance
-```bash
-# Install the CLI tool
-npm install -g @props-labs/mesh-os
+> **Important Note**: The JavaScript client can only connect to an existing MeshOS instance. To launch a new MeshOS system, please use the [Python version](https://github.com/Props-Labs/mesh-os) which includes deployment capabilities.
 
-# Create and start a new project
-mesh-os init my-project && cd my-project
-mesh-os up
-```
 
 ## Usage
 ```typescript
@@ -161,7 +154,7 @@ import dotenv from 'dotenv';
 // Load environment variables
 dotenv.config();
 
-// Initialize MeshOS
+// Connect To MeshOS
 const client = new MeshOS({
   url: process.env.HASURA_URL || 'http://localhost:8080',
   apiKey: process.env.HASURA_ADMIN_SECRET || 'meshos',

package/dist/core/client.d.ts

@@ -1,4 +1,4 @@
-import { EdgeType, type AgentStatus, type EdgeMetadata, type MemoryMetadata } from './taxonomy';
+import { EdgeType, type AgentStatus, type EdgeMetadata, type MemoryMetadata, type TimestampFilter } from './taxonomy';
 /**
  * An agent in the system.
  */
@@ -21,6 +21,7 @@ export interface Memory {
     embedding: number[];
     createdAt: string;
     updatedAt: string;
+    expiresAt?: string;
     similarity?: number;
 }
 /**
@@ -91,7 +92,7 @@ export declare class MeshOS {
     /**
      * Store a new memory.
      */
-    remember(content: string, agentId: string, metadata?: Partial<MemoryMetadata>): Promise<Memory>;
+    remember(content: string, agentId: string, metadata?: Partial<MemoryMetadata>, expiresAt?: string): Promise<Memory | Memory[]>;
     /**
      * Delete a specific memory.
      */
@@ -107,7 +108,7 @@ export declare class MeshOS {
     /**
      * Update a memory and optionally create a version edge to the previous version.
      */
-    updateMemory(memoryId: string, content: string, metadata?: Partial<MemoryMetadata>, createVersionEdge?: boolean): Promise<Memory>;
+    updateMemory(memoryId: string, content: string, metadata?: Partial<MemoryMetadata>, createVersionEdge?: boolean): Promise<Memory | Memory[]>;
     /**
      * Get memories connected to the given memory.
      */
@@ -134,6 +135,8 @@ export declare class MeshOS {
         adaptiveThreshold?: boolean;
         useSemanticExpansion?: boolean;
         filters?: Record<string, unknown>;
+        createdAtFilter?: TimestampFilter;
+        expiresAtFilter?: TimestampFilter;
     }): Promise<Memory[]>;
     /**
      * Internal method to perform recall with a specific threshold.

package/dist/core/client.js

@@ -12,7 +12,6 @@ const chalk_1 = __importDefault(require("chalk"));
 const boxen_1 = __importDefault(require("boxen"));
 const taxonomy_1 = require("./taxonomy");
 // Constants
-const MIN_THRESHOLD = 0.3;
 const SLUG_PATTERN = /^[a-z][a-z0-9_-]*[a-z0-9]$/;
 /**
  * GraphQL error class.
@@ -200,7 +199,7 @@ class MeshOS {
     /**
      * Store a new memory.
      */
-    async remember(content, agentId, metadata) {
+    async remember(content, agentId, metadata, expiresAt) {
         // Create default metadata if none provided
         const fullMetadata = taxonomy_1.memoryMetadataSchema.parse({
             type: taxonomy_1.DataType.KNOWLEDGE,
@@ -211,41 +210,128 @@ class MeshOS {
             additional: {},
             ...metadata
         });
-        // Create embedding
-        const embedding = await this.createEmbedding(content);
-        const embeddingStr = `[${embedding.join(',')}]`;
-        const query = `
-      mutation Remember($content: String!, $agentId: uuid!, $metadata: jsonb!, $embedding: vector!) {
-        insert_memories_one(object: {
-          content: $content,
-          agent_id: $agentId,
-          metadata: $metadata,
-          embedding: $embedding
-        }) {
-          id
-          agent_id
-          content
-          metadata
-          embedding
-          created_at
-          updated_at
+        // Check if content needs chunking (8192 tokens is approximately 32K characters)
+        const CHUNK_SIZE = 32000;
+        if (content.length <= CHUNK_SIZE) {
+            // Create embedding for single chunk
+            const embedding = await this.createEmbedding(content);
+            const embeddingStr = `[${embedding.join(',')}]`;
+            const query = `
+        mutation Remember($content: String!, $agentId: uuid!, $metadata: jsonb!, $embedding: vector!, $expiresAt: timestamptz) {
+          insert_memories_one(object: {
+            content: $content,
+            agent_id: $agentId,
+            metadata: $metadata,
+            embedding: $embedding,
+            expires_at: $expiresAt
+          }) {
+            id
+            agent_id
+            content
+            metadata
+            embedding
+            created_at
+            updated_at
+            expires_at
+          }
         }
-      }
-    `;
-        const result = await this.executeQuery(query, {
-            content,
-            agentId,
-            metadata: fullMetadata,
-            embedding: embeddingStr
-        });
-        // Convert snake_case to camelCase
-        const { agent_id, created_at, updated_at, ...rest } = result.insert_memories_one;
-        return {
-            ...rest,
-            agentId: agent_id,
-            createdAt: created_at,
-            updatedAt: updated_at,
-        };
+      `;
+            const result = await this.executeQuery(query, {
+                content,
+                agentId,
+                metadata: fullMetadata,
+                embedding: embeddingStr,
+                expiresAt
+            });
+            // Convert snake_case to camelCase
+            const { agent_id, created_at, updated_at, expires_at, ...rest } = result.insert_memories_one;
+            return {
+                ...rest,
+                agentId: agent_id,
+                createdAt: created_at,
+                updatedAt: updated_at,
+                expiresAt: expires_at,
+            };
+        }
+        // Split content into chunks
+        const chunks = [];
+        for (let i = 0; i < content.length; i += CHUNK_SIZE) {
+            chunks.push(content.slice(i, i + CHUNK_SIZE));
+        }
+        // Store each chunk and create links
+        const memories = [];
+        let previousChunkId = null;
+        for (let i = 0; i < chunks.length; i++) {
+            const chunkMetadata = {
+                ...fullMetadata,
+                additional: {
+                    ...fullMetadata.additional,
+                    chunk_info: {
+                        chunk_index: i,
+                        total_chunks: chunks.length,
+                        is_chunk: true
+                    }
+                }
+            };
+            // Create embedding for chunk
+            const embedding = await this.createEmbedding(chunks[i]);
+            const embeddingStr = `[${embedding.join(',')}]`;
+            const query = `
+        mutation Remember($content: String!, $agentId: uuid!, $metadata: jsonb!, $embedding: vector!, $expiresAt: timestamptz) {
+          insert_memories_one(object: {
+            content: $content,
+            agent_id: $agentId,
+            metadata: $metadata,
+            embedding: $embedding,
+            expires_at: $expiresAt
+          }) {
+            id
+            agent_id
+            content
+            metadata
+            embedding
+            created_at
+            updated_at
+            expires_at
+          }
+        }
+      `;
+            const result = await this.executeQuery(query, {
+                content: chunks[i],
+                agentId,
+                metadata: chunkMetadata,
+                embedding: embeddingStr,
+                expiresAt
+            });
+            // Convert snake_case to camelCase
+            const { agent_id, created_at, updated_at, expires_at, ...rest } = result.insert_memories_one;
+            const memory = {
+                ...rest,
+                agentId: agent_id,
+                createdAt: created_at,
+                updatedAt: updated_at,
+                expiresAt: expires_at,
+            };
+            memories.push(memory);
+            // Link chunks sequentially
+            if (previousChunkId) {
+                await this.linkMemories(previousChunkId, memory.id, taxonomy_1.EdgeType.FOLLOWS_UP, 1.0, {
+                    relationship: taxonomy_1.EdgeType.FOLLOWS_UP,
+                    weight: 1.0,
+                    bidirectional: false,
+                    additional: { is_chunk_link: true }
+                });
+                // Also add PART_OF relationship to show these are parts of the same content
+                await this.linkMemories(memory.id, previousChunkId, taxonomy_1.EdgeType.PART_OF, 1.0, {
+                    relationship: taxonomy_1.EdgeType.PART_OF,
+                    weight: 1.0,
+                    bidirectional: true,
+                    additional: { is_chunk_link: true }
+                });
+            }
+            previousChunkId = memory.id;
+        }
+        return memories;
     }
     /**
      * Delete a specific memory.
@@ -364,7 +450,7 @@ class MeshOS {
             throw new Error(`Memory ${memoryId} not found`);
         }
         // Create new memory with updated content and metadata
-        const newMemory = await this.remember(content, oldMemory.agent_id, {
+        const newMemories = await this.remember(content, oldMemory.agent_id, {
             ...oldMemory.metadata,
             version: oldMemory.metadata.version + 1,
             previousVersion: oldMemory.id,
@@ -372,14 +458,16 @@ class MeshOS {
         });
         // Create version edge if requested
         if (createVersionEdge) {
-            await this.linkMemories(oldMemory.id, newMemory.id, taxonomy_1.EdgeType.VERSION_OF, 1.0, {
+            // If we got multiple memories (chunks), link the first one
+            const firstNewMemory = Array.isArray(newMemories) ? newMemories[0] : newMemories;
+            await this.linkMemories(oldMemory.id, firstNewMemory.id, taxonomy_1.EdgeType.VERSION_OF, 1.0, {
                 relationship: taxonomy_1.EdgeType.VERSION_OF,
                 weight: 1.0,
                 bidirectional: false,
                 additional: { version_increment: 1 }
             });
         }
-        return newMemory;
+        return newMemories;
     }
     /**
      * Get memories connected to the given memory.
@@ -445,73 +533,86 @@ class MeshOS {
      * Search memories by semantic similarity.
      */
     async recall(options) {
-        const { query, agentId, limit = 5, threshold = 0.7, minResults = 1, adaptiveThreshold = true, useSemanticExpansion = true, filters } = options;
+        const { query, agentId, limit = 5, threshold = 0.7, minResults = 1, adaptiveThreshold = true, useSemanticExpansion = true, filters, createdAtFilter, expiresAtFilter } = options;
         // First try: Direct search with initial threshold
         let results = await this.recallWithThreshold({
             query,
             threshold,
             agentId,
             limit,
-            filters
+            filters,
+            createdAtFilter,
+            expiresAtFilter
         });
         if (results.length >= minResults) {
             return results.slice(0, limit);
         }
-        // Second try: Adaptive threshold
+        // Second try: If adaptive threshold is enabled, try lowering the threshold
         if (adaptiveThreshold) {
             let currentThreshold = threshold - 0.05;
-            while (currentThreshold >= MIN_THRESHOLD && results.length < minResults) {
+            const minThreshold = 0.3; // Don't go below this to avoid irrelevant matches
+            while (currentThreshold >= minThreshold && results.length < minResults) {
                 const newResults = await this.recallWithThreshold({
                     query,
                     threshold: currentThreshold,
                     agentId,
                     limit,
-                    filters
+                    filters,
+                    createdAtFilter,
+                    expiresAtFilter
                 });
-                // Add new unique results
+                // Add new results that aren't already in the list
                 for (const result of newResults) {
                     if (!results.some(r => r.id === result.id)) {
                         results.push(result);
                     }
                 }
-                if (results.length >= minResults)
+                if (results.length >= minResults) {
                     break;
+                }
                 currentThreshold -= 0.05;
             }
         }
-        // Third try: Semantic expansion
+        // Third try: If we still don't have ANY results and semantic expansion is enabled
         if (results.length === 0 && useSemanticExpansion) {
             const variations = await this.expandQuery(query);
             const seenIds = new Map();
-            // Try each variation with original threshold
-            for (const variation of variations.slice(1)) {
+            const minThreshold = 0.3; // Don't go below this to avoid irrelevant matches
+            // Try each variation with the original threshold first
+            for (const variation of variations.slice(1)) { // Skip original query as we already tried it
                 const variationResults = await this.recallWithThreshold({
                     query: variation,
                     threshold,
                     agentId,
                     limit,
-                    filters
+                    filters,
+                    createdAtFilter,
+                    expiresAtFilter
                 });
+                // Add new results or update if better similarity
                 for (const memory of variationResults) {
                     const existingMemory = seenIds.get(memory.id);
                     if (!existingMemory || (memory.similarity || 0) > (existingMemory.similarity || 0)) {
                         seenIds.set(memory.id, memory);
                     }
                 }
-                if (seenIds.size >= minResults)
+                if (seenIds.size >= minResults) {
                     break;
+                }
             }
             // If still no results, try variations with adaptive threshold
             if (seenIds.size === 0 && adaptiveThreshold) {
                 let currentThreshold = threshold - 0.05;
-                while (currentThreshold >= MIN_THRESHOLD && seenIds.size === 0) {
+                while (currentThreshold >= minThreshold && seenIds.size === 0) {
                     for (const variation of variations.slice(1)) {
                         const variationResults = await this.recallWithThreshold({
                             query: variation,
                             threshold: currentThreshold,
                             agentId,
                             limit,
-                            filters
+                            filters,
+                            createdAtFilter,
+                            expiresAtFilter
                         });
                         for (const memory of variationResults) {
                             const existingMemory = seenIds.get(memory.id);
@@ -519,19 +620,22 @@ class MeshOS {
                                 seenIds.set(memory.id, memory);
                             }
                         }
-                        if (seenIds.size > 0)
+                        if (seenIds.size > 0) {
                             break;
+                        }
                     }
-                    if (seenIds.size > 0)
+                    if (seenIds.size > 0) {
                         break;
+                    }
                     currentThreshold -= 0.05;
                 }
             }
+            // Update results with any found memories
             if (seenIds.size > 0) {
                 results = Array.from(seenIds.values());
             }
         }
-        // Sort by similarity and return
+        // Sort by similarity and return top results
         results.sort((a, b) => (b.similarity || 0) - (a.similarity || 0));
         return results.slice(0, limit);
     }
@@ -539,7 +643,7 @@ class MeshOS {
      * Internal method to perform recall with a specific threshold.
      */
     async recallWithThreshold(options) {
-        const { query, threshold, agentId, limit = 10, filters } = options;
+        const { query, threshold, agentId, limit = 10, filters, createdAtFilter, expiresAtFilter } = options;
         // Create embedding for the query
         const embedding = await this.createEmbedding(query);
         const embeddingStr = `[${embedding.join(',')}]`;
@@ -550,20 +654,48 @@ class MeshOS {
           agent_id
           content
           metadata
-          embedding
           similarity
           created_at
           updated_at
+          expires_at
         }
       }
     `;
+        // Process metadata filters
+        let metadataFilter;
+        if (filters) {
+            // Extract metadata filters
+            const { type, subtype, tags, relevance, version, _contains, ...additionalFilters } = filters;
+            metadataFilter = {};
+            // Add basic metadata filters
+            if (type)
+                metadataFilter.type = type;
+            if (subtype)
+                metadataFilter.subtype = subtype;
+            if (tags)
+                metadataFilter.tags = tags;
+            if (relevance)
+                metadataFilter.relevance = relevance;
+            if (version)
+                metadataFilter.version = version;
+            // Add array containment operations
+            if (_contains) {
+                metadataFilter._contains = _contains;
+            }
+            // Add any additional filters to the metadata.additional object
+            if (Object.keys(additionalFilters).length > 0) {
+                metadataFilter.additional = additionalFilters;
+            }
+        }
         const result = await this.executeQuery(gqlQuery, {
             args: {
                 query_embedding: embeddingStr,
                 match_threshold: threshold,
                 match_count: limit,
                 filter_agent_id: agentId,
-                ...filters
+                metadata_filter: metadataFilter,
+                created_at_filter: createdAtFilter,
+                expires_at_filter: expiresAtFilter
             }
         });
         return result.search_memories.map(memory => ({
@@ -574,7 +706,8 @@ class MeshOS {
             embedding: memory.embedding,
             similarity: memory.similarity,
             createdAt: memory.created_at,
-            updatedAt: memory.updated_at
+            updatedAt: memory.updated_at,
+            expiresAt: memory.expires_at
         }));
     }
     /**

package/dist/core/taxonomy.d.ts

@@ -63,7 +63,8 @@ export declare enum EdgeType {
     CONTRADICTS = "contradicts",// Conflicting information
     DEPENDS_ON = "depends_on",// Prerequisite relationship
     SUMMARIZES = "summarizes",// Condensed version
-    INFLUENCES = "influences"
+    INFLUENCES = "influences",// Impact relationship
+    PART_OF = "part_of"
 }
 /**
  * Relevance classification tags.
@@ -228,3 +229,13 @@ export declare const edgeMetadataSchema: z.ZodObject<{
     bidirectional?: boolean | undefined;
 }>;
 export type EdgeMetadata = z.infer<typeof edgeMetadataSchema>;
+/**
+ * Timestamp filter operators
+ */
+export interface TimestampFilter {
+    _gt?: string;
+    _gte?: string;
+    _lt?: string;
+    _lte?: string;
+    _eq?: string;
+}

package/dist/core/taxonomy.js

@@ -73,6 +73,7 @@ var EdgeType;
     EdgeType["DEPENDS_ON"] = "depends_on";
     EdgeType["SUMMARIZES"] = "summarizes";
     EdgeType["INFLUENCES"] = "influences";
+    EdgeType["PART_OF"] = "part_of";
 })(EdgeType || (exports.EdgeType = EdgeType = {}));
 /**
  * Relevance classification tags.

package/dist/index.d.ts

@@ -2,5 +2,5 @@
  * MeshOS - A lightweight multi-agent memory system with semantic search.
  */
 export { Agent, Memory, MemoryEdge, MeshOS, GraphQLError, InvalidSlugError, type MeshOSConfig } from './core/client';
-export { DataType, ActivitySubtype, KnowledgeSubtype, DecisionSubtype, MediaSubtype, EdgeType, RelevanceTag, type VersionInfo, type MemoryMetadata, type EdgeMetadata, } from './core/taxonomy';
-export declare const VERSION = "0.1.6";
+export { DataType, ActivitySubtype, KnowledgeSubtype, DecisionSubtype, MediaSubtype, EdgeType, RelevanceTag, CoreAgentStatus, type AgentStatus, type VersionInfo, type MemoryMetadata, type EdgeMetadata, } from './core/taxonomy';
+export declare const VERSION = "0.1.9";

package/dist/index.js

@@ -3,7 +3,7 @@
  * MeshOS - A lightweight multi-agent memory system with semantic search.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = exports.RelevanceTag = exports.EdgeType = exports.MediaSubtype = exports.DecisionSubtype = exports.KnowledgeSubtype = exports.ActivitySubtype = exports.DataType = exports.InvalidSlugError = exports.GraphQLError = exports.MeshOS = void 0;
+exports.VERSION = exports.CoreAgentStatus = exports.RelevanceTag = exports.EdgeType = exports.MediaSubtype = exports.DecisionSubtype = exports.KnowledgeSubtype = exports.ActivitySubtype = exports.DataType = exports.InvalidSlugError = exports.GraphQLError = exports.MeshOS = void 0;
 var client_1 = require("./core/client");
 Object.defineProperty(exports, "MeshOS", { enumerable: true, get: function () { return client_1.MeshOS; } });
 Object.defineProperty(exports, "GraphQLError", { enumerable: true, get: function () { return client_1.GraphQLError; } });
@@ -17,4 +17,6 @@ Object.defineProperty(exports, "DecisionSubtype", { enumerable: true, get: funct
 Object.defineProperty(exports, "MediaSubtype", { enumerable: true, get: function () { return taxonomy_1.MediaSubtype; } });
 Object.defineProperty(exports, "EdgeType", { enumerable: true, get: function () { return taxonomy_1.EdgeType; } });
 Object.defineProperty(exports, "RelevanceTag", { enumerable: true, get: function () { return taxonomy_1.RelevanceTag; } });
-exports.VERSION = '0.1.6';
+// Agent status types
+Object.defineProperty(exports, "CoreAgentStatus", { enumerable: true, get: function () { return taxonomy_1.CoreAgentStatus; } });
+exports.VERSION = '0.1.9';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@props-labs/mesh-os",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "MeshOS - A memory system for AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/templates/hasura/metadata/databases/default/tables/public_memories.yaml

@@ -14,4 +14,10 @@ computed_fields:
       function:
         name: search_memories
         schema: public
+        arguments:
+          query_embedding: $query_embedding
+          match_threshold: $match_threshold
+          match_count: $match_count
+          filter_agent_id: $filter_agent_id
+          metadata_filter: $metadata_filter
     comment: Computes similarity score for vector search 

package/src/templates/hasura/migrations/default/1_init/down.sql

@@ -1,13 +1,26 @@
--- Drop functions
-DROP FUNCTION IF EXISTS search_memories;
+-- Drop all versions of search_memories function
+DROP FUNCTION IF EXISTS public.search_memories(vector(1536), float8, integer, uuid, jsonb);
+DROP FUNCTION IF EXISTS public.search_memories(vector(1536), float8, integer, uuid);
+DROP FUNCTION IF EXISTS public.search_memories;
+
+-- Drop other functions
 DROP FUNCTION IF EXISTS get_connected_memories;
+
+-- Drop triggers first
+DROP TRIGGER IF EXISTS update_agents_updated_at ON public.agents;
+DROP TRIGGER IF EXISTS update_memories_updated_at ON public.memories;
+
+-- Now we can safely drop the trigger function
 DROP FUNCTION IF EXISTS update_updated_at_column;
 
+-- Drop views first
+DROP VIEW IF EXISTS public.memories_with_similarity;
+
 -- Drop tables
 DROP TABLE IF EXISTS public.memory_edges;
 DROP TABLE IF EXISTS public.memories;
 DROP TABLE IF EXISTS public.agents;
 
--- Drop extensions
-DROP EXTENSION IF EXISTS vector;
+-- Drop extensions (with CASCADE for vector since it has dependent objects)
+DROP EXTENSION IF EXISTS vector CASCADE;
 DROP EXTENSION IF EXISTS "uuid-ossp"; 

package/src/templates/hasura/migrations/default/2_metadata_filtering/down.sql

@@ -0,0 +1,4 @@
+-- Drop the updated search_memories function with metadata filtering
+DROP FUNCTION public.search_memories(vector(1536), float8, integer, uuid, jsonb);
+
+-- Note: The original search_memories function from 1_init will be restored when that migration is reapplied 

package/src/templates/hasura/migrations/default/2_metadata_filtering/up.sql

@@ -0,0 +1,44 @@
+-- Drop the existing search_memories function
+DROP FUNCTION IF EXISTS public.search_memories;
+
+-- Create the updated search_memories function with metadata filtering
+CREATE OR REPLACE FUNCTION public.search_memories(
+    query_embedding vector(1536),
+    match_threshold float8,
+    match_count integer,
+    filter_agent_id uuid DEFAULT NULL,
+    metadata_filter jsonb DEFAULT NULL
+)
+RETURNS SETOF public.memories_with_similarity
+LANGUAGE sql
+STABLE
+AS $$
+    WITH normalized_query AS (
+        SELECT l2_normalize(query_embedding) AS normalized_vector
+    )
+    SELECT 
+        m.id,
+        m.agent_id,
+        m.content,
+        m.metadata,
+        m.embedding,
+        m.created_at,
+        m.updated_at,
+        -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) as similarity
+    FROM memories m
+    WHERE
+        CASE 
+            WHEN filter_agent_id IS NOT NULL THEN m.agent_id = filter_agent_id
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN metadata_filter IS NOT NULL THEN m.metadata @> metadata_filter
+            ELSE TRUE
+        END
+        AND -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) >= match_threshold
+    ORDER BY -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) DESC
+    LIMIT match_count;
+$$;
+
+-- Track the function in Hasura
+COMMENT ON FUNCTION public.search_memories IS E'@graphql({"type": "Query"})'; 

package/src/templates/hasura/migrations/default/3_memory_expiry/down.sql

@@ -0,0 +1,55 @@
+-- Drop the updated search_memories function
+DROP FUNCTION IF EXISTS public.search_memories(vector(1536), float8, integer, uuid, jsonb, jsonb, jsonb);
+
+-- Remove expires_at column
+ALTER TABLE public.memories DROP COLUMN expires_at;
+
+-- Drop and recreate the view without expires_at
+DROP VIEW IF EXISTS public.memories_with_similarity;
+CREATE OR REPLACE VIEW public.memories_with_similarity AS
+SELECT 
+    m.*,
+    0::float8 as similarity
+FROM memories m;
+
+-- Restore the previous version of search_memories from 2_metadata_filtering
+CREATE OR REPLACE FUNCTION public.search_memories(
+    query_embedding vector(1536),
+    match_threshold float8,
+    match_count integer,
+    filter_agent_id uuid DEFAULT NULL,
+    metadata_filter jsonb DEFAULT NULL
+)
+RETURNS SETOF public.memories_with_similarity
+LANGUAGE sql
+STABLE
+AS $$
+    WITH normalized_query AS (
+        SELECT l2_normalize(query_embedding) AS normalized_vector
+    )
+    SELECT 
+        m.id,
+        m.agent_id,
+        m.content,
+        m.metadata,
+        m.embedding,
+        m.created_at,
+        m.updated_at,
+        -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) as similarity
+    FROM memories m
+    WHERE
+        CASE 
+            WHEN filter_agent_id IS NOT NULL THEN m.agent_id = filter_agent_id
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN metadata_filter IS NOT NULL THEN m.metadata @> metadata_filter
+            ELSE TRUE
+        END
+        AND -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) >= match_threshold
+    ORDER BY -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) DESC
+    LIMIT match_count;
+$$;
+
+-- Track the function in Hasura
+COMMENT ON FUNCTION public.search_memories IS E'@graphql({"type": "Query"})'; 

package/src/templates/hasura/migrations/default/3_memory_expiry/up.sql

@@ -0,0 +1,108 @@
+-- Add expires_at column to memories table
+ALTER TABLE public.memories ADD COLUMN expires_at TIMESTAMPTZ;
+
+-- Create a view for memories with similarity that includes all fields
+DROP VIEW IF EXISTS public.memories_with_similarity;
+CREATE OR REPLACE VIEW public.memories_with_similarity AS
+SELECT 
+    m.*,
+    0::float8 as similarity  -- Default similarity, will be replaced in search
+FROM memories m;
+
+-- Drop the existing search_memories function
+DROP FUNCTION IF EXISTS public.search_memories;
+
+-- Create the updated search_memories function with standard Hasura filtering
+CREATE OR REPLACE FUNCTION public.search_memories(
+    query_embedding vector(1536),
+    match_threshold float8,
+    match_count integer,
+    filter_agent_id uuid DEFAULT NULL,
+    metadata_filter jsonb DEFAULT NULL,
+    created_at_filter jsonb DEFAULT NULL,
+    expires_at_filter jsonb DEFAULT NULL
+)
+RETURNS SETOF public.memories_with_similarity
+LANGUAGE sql
+STABLE
+AS $$
+    WITH normalized_query AS (
+        SELECT l2_normalize(query_embedding) AS normalized_vector
+    )
+    SELECT 
+        m.id,
+        m.agent_id,
+        m.content,
+        m.metadata,
+        m.embedding,
+        m.created_at,
+        m.updated_at,
+        m.expires_at,
+        -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) as similarity
+    FROM memories m
+    WHERE
+        CASE 
+            WHEN filter_agent_id IS NOT NULL THEN m.agent_id = filter_agent_id
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN metadata_filter IS NOT NULL THEN m.metadata @> metadata_filter
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN created_at_filter IS NOT NULL THEN (
+                CASE
+                    WHEN created_at_filter ? '_gt' THEN m.created_at > (created_at_filter->>'_gt')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_gte' THEN m.created_at >= (created_at_filter->>'_gte')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_lt' THEN m.created_at < (created_at_filter->>'_lt')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_lte' THEN m.created_at <= (created_at_filter->>'_lte')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN created_at_filter ? '_eq' THEN m.created_at = (created_at_filter->>'_eq')::timestamptz
+                    ELSE TRUE
+                END
+            )
+            ELSE TRUE
+        END
+        AND CASE
+            WHEN expires_at_filter IS NOT NULL THEN (
+                CASE
+                    WHEN expires_at_filter ? '_gt' THEN m.expires_at > (expires_at_filter->>'_gt')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN expires_at_filter ? '_gte' THEN m.expires_at >= (expires_at_filter->>'_gte')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN expires_at_filter ? '_lt' THEN m.expires_at < (expires_at_filter->>'_lt')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN expires_at_filter ? '_lte' THEN m.expires_at <= (expires_at_filter->>'_lte')::timestamptz
+                    ELSE TRUE
+                END
+                AND CASE
+                    WHEN expires_at_filter ? '_eq' THEN m.expires_at = (expires_at_filter->>'_eq')::timestamptz
+                    ELSE TRUE
+                END
+            )
+            ELSE TRUE
+        END
+        AND -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) >= match_threshold
+    ORDER BY -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) DESC
+    LIMIT match_count;
+$$;
+
+-- Track the function in Hasura
+COMMENT ON FUNCTION public.search_memories IS E'@graphql({"type": "Query"})';