@pyxmate/memory 0.0.4-beta → 0.1.0-beta

package/README.md

@@ -2,7 +2,7 @@
 
 SDK for **pyx-memory** — Memory as a Service for AI agents.
 
-Provides an HTTP client, shared types, and optional dashboard + React hooks for interacting with a pyx-memory server.
+Provides an HTTP client, shared types, and optional dashboard + React hooks for interacting with the pyx-memory managed cloud.
 
 ## Install
 
@@ -16,7 +16,7 @@ npm install @pyxmate/memory
 import { MemoryClient } from '@pyxmate/memory';
 import type { MemoryEntry } from '@pyxmate/memory';
 
-const client = new MemoryClient('http://localhost:7822');
+const client = new MemoryClient('https://your-pyx-memory-endpoint');
 await client.initialize();
 
 // Store a memory
@@ -25,7 +25,7 @@ await client.store({
   agentId: 'my-agent',
 });
 
-// Search memories
+// Search memories — smart retrieval picks the best strategy
 const results = await client.search({ query: 'deadline', limit: 5 });
 ```
 
@@ -37,12 +37,9 @@ const results = await client.search({ query: 'deadline', limit: 5 });
 | `@pyxmate/memory/dashboard` | Headless dashboard utilities — `DashboardClient`, aggregations, graph transforms (no React) |
 | `@pyxmate/memory/react` | React hooks — `useMemoryStats`, `useMemoryHealth`, `useKnowledgeGraph`, etc. (requires React >= 18) |
 
-## Running the Server
+## Managed Cloud
 
-```bash
-docker pull ghcr.io/fysoul17/pyx-memory:latest
-docker run -p 7822:7822 ghcr.io/fysoul17/pyx-memory:latest
-```
+pyx-memory is deployed exclusively as a managed cloud service at **[memory.pyxmate.com](https://memory.pyxmate.com)**.
 
 ## Requirements
 

package/dist/{chunk-EDIYGMT2.mjs → chunk-ACMIMR43.mjs}

@@ -1,6 +1,6 @@
 import {
   MemoryClient
-} from "./chunk-Q4QIILKH.mjs";
+} from "./chunk-VJGRAIVX.mjs";
 
 // ../dashboard/src/aggregations/consolidation-analytics.ts
 function analyzeConsolidationLog(entries) {

package/dist/{chunk-Q4QIILKH.mjs → chunk-VJGRAIVX.mjs}

@@ -29,13 +29,7 @@ var MemoryClient = class {
   async store(entry) {
     return this.fetchApi("/api/memory/ingest", {
       method: "POST",
-      body: JSON.stringify({
-        content: entry.content,
-        type: entry.type,
-        metadata: entry.metadata,
-        agentId: entry.agentId,
-        sessionId: entry.sessionId
-      })
+      body: JSON.stringify(entry)
     });
   }
   async search(params) {
@@ -44,6 +38,11 @@ var MemoryClient = class {
     if (params.type) searchParams.set("type", params.type);
     if (params.agentId) searchParams.set("agentId", params.agentId);
     if (params.strategy) searchParams.set("strategy", params.strategy);
+    if (params.eventTimeRange) {
+      searchParams.set("eventTimeStart", params.eventTimeRange[0]);
+      searchParams.set("eventTimeEnd", params.eventTimeRange[1]);
+    }
+    if (params.asOf) searchParams.set("asOf", params.asOf);
     return this.fetchApi(`/api/memory/search?${searchParams}`);
   }
   async get(id) {
@@ -168,6 +167,28 @@ var MemoryClient = class {
     );
     return result.deleted;
   }
+  async queryAsOf(asOfDate, filters = {}) {
+    const params = new URLSearchParams({ asOf: asOfDate });
+    if (filters.type) params.set("type", filters.type);
+    if (filters.agentId) params.set("agentId", filters.agentId);
+    if (filters.source) params.set("source", filters.source);
+    if (filters.limit) params.set("limit", String(filters.limit));
+    const result = await this.fetchApi(
+      `/api/memory/query-as-of?${params}`
+    );
+    return result.entries;
+  }
+  async queryByEventTime(startTime, endTime, filters = {}) {
+    const params = new URLSearchParams({ startTime, endTime });
+    if (filters.type) params.set("type", filters.type);
+    if (filters.agentId) params.set("agentId", filters.agentId);
+    if (filters.source) params.set("source", filters.source);
+    if (filters.limit) params.set("limit", String(filters.limit));
+    const result = await this.fetchApi(
+      `/api/memory/query-by-event-time?${params}`
+    );
+    return result.entries;
+  }
   async fetchApi(path, options) {
     const res = await fetch(`${this.baseUrl}${path}`, {
       ...options,

package/dist/dashboard.mjs

@@ -11,8 +11,8 @@ import {
   toGraphologyFormat,
   transformGraphData,
   unreachableHealth
-} from "./chunk-EDIYGMT2.mjs";
-import "./chunk-Q4QIILKH.mjs";
+} from "./chunk-ACMIMR43.mjs";
+import "./chunk-VJGRAIVX.mjs";
 export {
   DashboardClient,
   Poller,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { MemoryEntry as MemoryEntry$1, MemorySearchParams as MemorySearchParams$1, MemorySearchResult as MemorySearchResult$1, MemoryType as MemoryType$1, MemoryStats as MemoryStats$1, GraphNode as GraphNode$1, GraphTraversalResult as GraphTraversalResult$1 } from '@pyx-memory/shared';
+import { StoreInput as StoreInput$1, MemoryEntry as MemoryEntry$1, MemorySearchParams as MemorySearchParams$1, MemorySearchResult as MemorySearchResult$1, MemoryType as MemoryType$1, MemoryStats as MemoryStats$1, GraphNode as GraphNode$1, GraphTraversalResult as GraphTraversalResult$1 } from '@pyx-memory/shared';
 
 /** Parameters for paginated entry listing. */
 interface MemoryListParams {
@@ -18,13 +18,17 @@ interface MemoryListResult {
     page: number;
     limit: number;
 }
+/** Filters for temporal queries (queryAsOf, queryByEventTime). */
+interface TemporalQueryFilters {
+    type?: MemoryType$1;
+    agentId?: string;
+    source?: string;
+    limit?: number;
+}
 /** Abstract interface for memory systems (local or remote). */
 interface MemoryInterface {
     initialize(): Promise<void>;
-    store(entry: Omit<MemoryEntry$1, 'id' | 'createdAt'> & {
-        id?: string;
-        createdAt?: string;
-    }): Promise<MemoryEntry$1>;
+    store(entry: StoreInput$1): Promise<MemoryEntry$1>;
     search(params: MemorySearchParams$1): Promise<MemorySearchResult$1>;
     /** List entries with SQL LIMIT/OFFSET pagination. */
     list(params?: MemoryListParams): Promise<MemoryListResult>;
@@ -32,6 +36,10 @@ interface MemoryInterface {
     delete(id: string): Promise<boolean>;
     clearSession(sessionId: string): Promise<number>;
     stats(): Promise<MemoryStats$1>;
+    /** Query entries as they existed at a point in time (by ingest time). */
+    queryAsOf(asOfDate: string, filters?: TemporalQueryFilters): Promise<MemoryEntry$1[]>;
+    /** Query entries by event time range (when things actually happened). */
+    queryByEventTime(startTime: string, endTime: string, filters?: TemporalQueryFilters): Promise<MemoryEntry$1[]>;
     shutdown(): Promise<void>;
 }
 /** Consolidation run result. */
@@ -59,7 +67,9 @@ interface ExtendedMemoryInterface extends MemoryInterface {
 
 interface IngestionResult {
     filename: string;
+    fileType: string;
     chunks: number;
+    entryIds: string[];
     totalCharacters: number;
 }
 
@@ -76,10 +86,7 @@ declare class MemoryClient implements ExtendedMemoryInterface {
     /** Encode a path segment to prevent URL injection */
     private encodePathSegment;
     initialize(): Promise<void>;
-    store(entry: Omit<MemoryEntry$1, 'id' | 'createdAt'> & {
-        id?: string;
-        createdAt?: string;
-    }): Promise<MemoryEntry$1>;
+    store(entry: StoreInput$1): Promise<MemoryEntry$1>;
     search(params: MemorySearchParams$1): Promise<MemorySearchResult$1>;
     get(id: string): Promise<MemoryEntry$1 | null>;
     delete(id: string): Promise<boolean>;
@@ -110,13 +117,14 @@ declare class MemoryClient implements ExtendedMemoryInterface {
     runDecay(): Promise<number>;
     reindex(): Promise<void>;
     deleteBySource(source: string): Promise<number>;
+    queryAsOf(asOfDate: string, filters?: TemporalQueryFilters): Promise<MemoryEntry$1[]>;
+    queryByEventTime(startTime: string, endTime: string, filters?: TemporalQueryFilters): Promise<MemoryEntry$1[]>;
     protected fetchApi<T>(path: string, options?: RequestInit): Promise<T>;
 }
 
 declare const DEFAULTS: {
     readonly DATA_DIR: "./data";
     readonly VECTOR_PROVIDER: "lancedb";
-    readonly EMBEDDING_PROVIDER: "stub";
     readonly MEMORY_SERVER_PORT: 7822;
 };
 
@@ -148,12 +156,13 @@ declare const RAGStrategy: {
 type RAGStrategy = (typeof RAGStrategy)[keyof typeof RAGStrategy];
 declare const VectorProvider: {
     readonly LANCEDB: "lancedb";
-    readonly QDRANT: "qdrant";
 };
 type VectorProvider = (typeof VectorProvider)[keyof typeof VectorProvider];
 declare const EmbeddingProviderName: {
     readonly STUB: "stub";
+    /** @deprecated Vestigial — pyx-memory uses internal BGE-M3 embeddings. */
     readonly ANTHROPIC: "anthropic";
+    /** @deprecated Vestigial — pyx-memory uses internal BGE-M3 embeddings. */
     readonly OPENAI: "openai";
     readonly LOCAL: "local";
 };
@@ -165,6 +174,7 @@ interface MemoryEntry {
     agentId?: AgentId;
     sessionId?: string;
     metadata: Record<string, unknown>;
+    /** @deprecated Vestigial — embeddings are managed internally by the vector store. */
     embedding?: number[];
     createdAt: Timestamp;
     /** SHA-256 hash of content for deduplication. */
@@ -184,30 +194,16 @@ interface MemoryEntry {
     /** When this entry was ingested into the system. */
     ingestTime?: string;
 }
-interface SearchFilters {
-    /** Filter by source identifier. */
-    source?: string;
-    /** Minimum importance score. */
-    importanceMin?: number;
-    /** Event time range [start, end] as ISO timestamps. */
-    eventTimeRange?: [string, string];
-    /** Filter by parent entry ID. */
-    parentId?: string;
-    /** Filter by content type in metadata. */
-    contentType?: string;
-}
 interface MemorySearchParams {
     query: string;
     type?: MemoryType;
     agentId?: AgentId;
     limit?: number;
     strategy?: RAGStrategy;
-    /** Extended filters for Phase 1+ features. */
-    filters?: SearchFilters;
-    /** Enable Hypothetical Document Embedding for query expansion. */
-    enableHyDE?: boolean;
-    /** Enable reranking of results. */
-    enableRerank?: boolean;
+    /** Filter results to entries whose eventTime falls within [start, end] (ISO 8601). */
+    eventTimeRange?: [string, string];
+    /** Filter results to entries ingested before this cutoff (ISO 8601). Falls back to createdAt when ingestTime is null. */
+    asOf?: string;
 }
 interface MemorySearchResult {
     entries: MemoryEntry[];
@@ -219,11 +215,67 @@ interface MemorySearchResult {
         score: number;
     }>;
 }
+declare const StoreTarget: {
+    readonly SQLITE: "sqlite";
+    readonly VECTOR: "vector";
+    readonly GRAPH: "graph";
+};
+type StoreTarget = (typeof StoreTarget)[keyof typeof StoreTarget];
+/** Agent-provided entity for graph storage. */
+interface IngestEntity {
+    /** Entity name (e.g., "Alice", "TypeScript"). */
+    name: string;
+    /** Entity type — freeform, agent decides (e.g., "PERSON", "TOOL"). */
+    type: string;
+    /** Optional properties to attach to the graph node. */
+    properties?: Record<string, unknown>;
+}
+/** Agent-provided relationship for graph storage. */
+interface IngestRelationship {
+    /** Source entity name (must match an entity in the entities array). */
+    source: string;
+    /** Target entity name (must match an entity in the entities array). */
+    target: string;
+    /** Relationship type — freeform, agent decides (e.g., "WORKS_AT", "USES"). */
+    type: string;
+    /** Optional properties to attach to the graph edge. */
+    properties?: Record<string, unknown>;
+}
+/** Store input: what the agent sends to Memory.store(). */
+type StoreInput = Omit<MemoryEntry, 'id' | 'createdAt'> & {
+    id?: string;
+    createdAt?: string;
+    /** Storage targets. Default: ["sqlite", "vector"]. */
+    targets?: StoreTarget[];
+    /** Agent-provided entities for graph storage. Required when targets includes "graph". */
+    entities?: IngestEntity[];
+    /** Agent-provided relationships for graph storage. */
+    relationships?: IngestRelationship[];
+};
 interface MemoryIngestRequest {
     content?: string;
     type?: MemoryType;
-    fileType?: 'pdf' | 'csv' | 'txt';
     metadata?: Record<string, unknown>;
+    agentId?: string;
+    sessionId?: string;
+    /** Storage targets. Default: ["sqlite", "vector"]. */
+    targets?: StoreTarget[];
+    /** Agent-provided entities for graph storage. Required when targets includes "graph". */
+    entities?: IngestEntity[];
+    /** Agent-provided relationships for graph storage. */
+    relationships?: IngestRelationship[];
+    /** Importance score (1-10). */
+    importance?: number;
+    /** Source identifier (e.g., filename, URL). */
+    source?: string;
+    /** When the event occurred (ISO timestamp). */
+    eventTime?: string;
+    /** Optional deterministic ID for the entry (agent-provided). */
+    id?: string;
+    /** Parent entry ID for hierarchical storage (e.g., doc → section → chunk). */
+    parentId?: string;
+    /** When this entry was ingested (ISO timestamp). Default: now. */
+    ingestTime?: string;
 }
 interface MemoryStats {
     totalEntries: number;
@@ -235,14 +287,6 @@ interface MemoryStats {
     /** Whether the memory service is connected. False when using DisabledMemory. */
     connected?: boolean;
 }
-interface GraphEdge {
-    id: string;
-    sourceEntity: string;
-    targetEntity: string;
-    relation: string;
-    weight: number;
-    memoryEntryId: string;
-}
 interface GraphNode {
     id: string;
     name: string;
@@ -267,4 +311,4 @@ interface GraphTraversalResult {
     }>;
 }
 
-export { type AgentId, type ApiResponse, type ConsolidationRunResult, DEFAULTS, EmbeddingProviderName, type ExtendedMemoryInterface, type GraphEdge, type GraphNode, type GraphRelationship, type GraphTraversalResult, type IngestionResult, MemoryClient, type MemoryEntry, type MemoryIngestRequest, type MemoryInterface, type MemoryListParams, type MemoryListResult, type MemorySearchParams, type MemorySearchResult, MemoryServerError, type MemoryStats, MemoryType, RAGStrategy, type SearchFilters, type Timestamp, VectorProvider };
+export { type AgentId, type ApiResponse, type ConsolidationRunResult, DEFAULTS, EmbeddingProviderName, type ExtendedMemoryInterface, type GraphNode, type GraphRelationship, type GraphTraversalResult, type IngestEntity, type IngestRelationship, type IngestionResult, MemoryClient, type MemoryEntry, type MemoryIngestRequest, type MemoryInterface, type MemoryListParams, type MemoryListResult, type MemorySearchParams, type MemorySearchResult, MemoryServerError, type MemoryStats, MemoryType, RAGStrategy, type StoreInput, StoreTarget, type TemporalQueryFilters, type Timestamp, VectorProvider };

package/dist/index.mjs

@@ -1,13 +1,12 @@
 import {
   MemoryClient,
   MemoryServerError
-} from "./chunk-Q4QIILKH.mjs";
+} from "./chunk-VJGRAIVX.mjs";
 
 // ../shared/src/constants/defaults.ts
 var DEFAULTS = {
   DATA_DIR: "./data",
   VECTOR_PROVIDER: "lancedb",
-  EMBEDDING_PROVIDER: "stub",
   MEMORY_SERVER_PORT: 7822
 };
 
@@ -26,15 +25,21 @@ var RAGStrategy = {
   HYBRID: "hybrid"
 };
 var VectorProvider = {
-  LANCEDB: "lancedb",
-  QDRANT: "qdrant"
+  LANCEDB: "lancedb"
 };
 var EmbeddingProviderName = {
   STUB: "stub",
+  /** @deprecated Vestigial — pyx-memory uses internal BGE-M3 embeddings. */
   ANTHROPIC: "anthropic",
+  /** @deprecated Vestigial — pyx-memory uses internal BGE-M3 embeddings. */
   OPENAI: "openai",
   LOCAL: "local"
 };
+var StoreTarget = {
+  SQLITE: "sqlite",
+  VECTOR: "vector",
+  GRAPH: "graph"
+};
 export {
   DEFAULTS,
   EmbeddingProviderName,
@@ -42,5 +47,6 @@ export {
   MemoryServerError,
   MemoryType,
   RAGStrategy,
+  StoreTarget,
   VectorProvider
 };

package/dist/react.mjs

@@ -11,8 +11,8 @@ import {
   toGraphologyFormat,
   transformGraphData,
   unreachableHealth
-} from "./chunk-EDIYGMT2.mjs";
-import "./chunk-Q4QIILKH.mjs";
+} from "./chunk-ACMIMR43.mjs";
+import "./chunk-VJGRAIVX.mjs";
 
 // ../dashboard/src/hooks/use-consolidation-log.ts
 import { useCallback as useCallback2, useMemo } from "react";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyxmate/memory",
-  "version": "0.0.4-beta",
+  "version": "0.1.0-beta",
   "type": "module",
   "description": "SDK for pyx-memory — Memory as a Service for AI agents",
   "license": "MIT",