@memorylayerai/sdk 0.3.1 → 0.5.0

package/README.md

@@ -28,30 +28,30 @@ yarn add @memorylayerai/sdk
 
 ## Quick Start
 
-### Option 1: Transparent Router (Zero Code Changes) ⚡
+### Option 1: Transparent Router (Beta) - Drop-in OpenAI Proxy ⚡
 
-The easiest way to add memory - just change your OpenAI baseURL:
+Change your baseURL to add automatic memory injection:
 
 ```typescript
 import OpenAI from 'openai';
 
 const openai = new OpenAI({
-  baseURL: 'https://api.memorylayer.ai/v1',  // ← Just change this
+  baseURL: 'https://api.memorylayer.ai/v1',  // ← Point to MemoryLayer
   apiKey: 'ml_your_memorylayer_key'          // ← Use your MemoryLayer key
 });
 
-// That's it! Memory is automatically injected
+// Memory is automatically retrieved and injected
 const response = await openai.chat.completions.create({
   model: 'gpt-4',
   messages: [{ role: 'user', content: 'What are my preferences?' }]
 });
 ```
 
-**Benefits:**
-- ✅ Zero code changes to your application
-- ✅ Automatic memory injection
-- ✅ Works with existing OpenAI SDK code
-- ✅ Configurable via headers
+**Current Status:**
+- ✅ Works with `/v1/chat/completions` (non-streaming)
+- ✅ OpenAI-compatible responses
+- ✅ Configurable via headers (use `fetch`/`axios` for guaranteed header support)
+- ⏳ Streaming support coming soon
 
 See [Transparent Router Guide](#transparent-router) for details.
 
@@ -115,7 +115,12 @@ results.forEach(result => {
 
 ## Transparent Router
 
-The transparent router is an OpenAI-compatible proxy that automatically injects memory context into your requests. It's the easiest way to add memory to your application.
+The transparent router is an OpenAI-compatible proxy that automatically injects memory context into your requests.
+
+**Current Status:**
+- ✅ Works with `/v1/chat/completions` (non-streaming)
+- ✅ OpenAI-compatible responses
+- ⏳ Streaming support coming soon
 
 ### Basic Usage
 
@@ -135,67 +140,52 @@ const response = await openai.chat.completions.create({
 
 ### Configuration Headers
 
-Control memory injection with optional headers:
+Control memory injection with optional headers. **Note:** For guaranteed header support, use `fetch` or `axios` directly:
 
 ```typescript
-const response = await openai.chat.completions.create({
-  model: 'gpt-4',
-  messages: [{ role: 'user', content: 'Hello!' }],
+// Using fetch for guaranteed header support
+const response = await fetch('https://api.memorylayer.ai/v1/chat/completions', {
+  method: 'POST',
   headers: {
-    'x-memory-user-id': 'user_123',              // User scope
-    'x-memory-session-id': 'sess_abc',           // Session scope
-    'x-memory-limit': '10',                      // Max memories
-    'x-memory-injection-mode': 'balanced',       // safe|balanced|full
-    'x-memory-injection-strategy': 'system_append', // Injection strategy
-    'x-memory-disabled': 'false'                 // Enable/disable
-  }
+    'Authorization': `Bearer ${process.env.MEMORYLAYER_API_KEY}`,
+    'Content-Type': 'application/json',
+    'x-memory-user-id': 'user_123',              // User scope (required for multi-user apps)
+    'x-memory-session-id': 'sess_abc',           // Session scope (persist from response)
+    'x-memory-limit': '10',                      // Max memories to inject
+    'x-memory-injection-mode': 'safe',           // safe|full (balanced coming soon)
+    'x-memory-disabled': 'false'                 // Enable/disable memory
+  },
+  body: JSON.stringify({
+    model: 'gpt-4',
+    messages: [{ role: 'user', content: 'Hello!' }]
+  })
 });
 ```
 
 ### Injection Modes
 
-- **safe**: Only fact + preference (minimal risk)
-- **balanced** (default): fact + preference + trusted summaries
-- **full**: All memory types including snippets
+- **safe** (default): Only fact + preference types (minimal risk, structured data)
+- **full**: All memory types including snippets (maximum context, higher token usage)
+- **balanced**: Trusted summaries + facts + preferences (coming soon)
 
 ### Diagnostic Headers
 
-Every response includes diagnostic headers:
+Every response includes diagnostic headers showing what happened:
 
 ```typescript
-const response = await openai.chat.completions.create({ ... });
-
-console.log('Memories retrieved:', response.headers?.['x-memory-hit-count']);
-console.log('Tokens injected:', response.headers?.['x-memory-injected-tokens']);
-console.log('Max score:', response.headers?.['x-memory-max-score']);
-console.log('Query rewriting:', response.headers?.['x-memory-rewrite']);
-console.log('Memory status:', response.headers?.['x-memory-status']);
-console.log('Session ID:', response.headers?.['x-memory-session-id']);
-```
-
-### Streaming Support
+const response = await fetch('https://api.memorylayer.ai/v1/chat/completions', { ... });
 
-Streaming works seamlessly:
-
-```typescript
-const stream = await openai.chat.completions.create({
-  model: 'gpt-4',
-  messages: [{ role: 'user', content: 'Tell me about myself' }],
-  stream: true,
-  headers: {
-    'x-memory-user-id': 'user_123'
-  }
-});
-
-for await (const chunk of stream) {
-  const content = chunk.choices[0]?.delta?.content || '';
-  process.stdout.write(content);
-}
+console.log('Memories retrieved:', response.headers.get('x-memory-hit-count'));
+console.log('Tokens injected:', response.headers.get('x-memory-injected-tokens'));
+console.log('Max score:', response.headers.get('x-memory-max-score'));
+console.log('Query rewriting:', response.headers.get('x-memory-rewrite'));
+console.log('Memory status:', response.headers.get('x-memory-status'));
+console.log('Session ID:', response.headers.get('x-memory-session-id'));  // Persist this!
 ```
 
 ### Session Management
 
-If you don't provide `x-memory-user-id` or `x-memory-session-id`, the router generates a session ID. Persist it for conversation continuity:
+For chat applications, persist `x-memory-session-id` from response headers and pass it in subsequent requests:
 
 ```typescript
 const response = await openai.chat.completions.create({ ... });

package/dist/index.cjs

@@ -221,9 +221,18 @@ var init_search = __esm({
         this.httpClient = httpClient;
       }
       /**
-       * Search memories
+       * Search memories using the unified /v1/search endpoint with hybrid retrieval.
+       *
+       * This uses the app's full retrieval pipeline with:
+       * - Vector similarity search
+       * - BM25 keyword search
+       * - Recency scoring
+       * - Graph connectivity (optional)
+       * - Entity expansion (optional)
+       * - LLM/Cross-encoder reranking (optional)
+       *
        * @param request - Search request
-       * @returns Search results
+       * @returns Search results with memory pack structure
        */
       async search(request) {
         if (!request.query || request.query.trim().length === 0) {
@@ -238,24 +247,36 @@ var init_search = __esm({
             [{ field: "projectId", message: "Project ID is required" }]
           );
         }
-        const query = {
-          q: request.query,
-          projectId: request.projectId
+        const body = {
+          query: request.query,
+          project_id: request.projectId,
+          include_text_format: true
         };
         if (request.limit !== void 0) {
-          query.limit = request.limit.toString();
-        }
-        if (request.threshold !== void 0) {
-          query.threshold = request.threshold.toString();
-        }
-        if (request.filter) {
-          query.filter = JSON.stringify(request.filter);
+          body.limit = request.limit;
         }
-        return this.httpClient.request({
-          method: "GET",
+        body.rerank_strategy = request.rerankingStrategy || "cross-encoder";
+        const response = await this.httpClient.request({
+          method: "POST",
           path: "/v1/search",
-          query
+          body
         });
+        const memoryPack = response.memory_pack || {};
+        const results = [];
+        for (const memoryType of ["facts", "preferences", "entities", "sources"]) {
+          const items = memoryPack[memoryType] || [];
+          for (const item of items) {
+            results.push({
+              memory: item,
+              score: item.score || 1,
+              highlights: item.highlights || []
+            });
+          }
+        }
+        return {
+          results,
+          total: results.length
+        };
       }
     };
   }
@@ -293,18 +314,15 @@ var init_ingest = __esm({
             [{ field: "projectId", message: "Project ID is required" }]
           );
         }
-        const body = {
-          projectId: request.projectId,
-          metadata: request.metadata,
-          chunkSize: request.chunkSize,
-          chunkOverlap: request.chunkOverlap,
-          // In a real implementation, you'd convert the file to base64 or use FormData
-          file: request.file
-        };
         return this.httpClient.request({
           method: "POST",
-          path: "/v1/ingest/file",
-          body
+          path: "/v1/ingest",
+          body: {
+            type: "pdf",
+            projectId: request.projectId,
+            metadata: request.metadata || {},
+            file: request.file
+          }
         });
       }
       /**
@@ -327,9 +345,71 @@ var init_ingest = __esm({
         }
         return this.httpClient.request({
           method: "POST",
-          path: "/v1/ingest/text",
-          body: request
+          path: "/v1/ingest",
+          body: {
+            type: "text",
+            content: request.text,
+            projectId: request.projectId,
+            metadata: request.metadata || {}
+          }
+        });
+      }
+      /**
+       * Ingest content from a URL
+       * @param url - URL to ingest from
+       * @param projectId - Project ID
+       * @param metadata - Optional metadata
+       * @returns Ingestion response with job details
+       */
+      async url(url, projectId, metadata) {
+        if (!url || url.trim().length === 0) {
+          throw new ValidationError(
+            "URL cannot be empty",
+            [{ field: "url", message: "URL is required and cannot be empty" }]
+          );
+        }
+        if (!projectId || projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        return this.httpClient.request({
+          method: "POST",
+          path: "/v1/ingest",
+          body: {
+            type: "url",
+            url,
+            projectId,
+            metadata: metadata || {}
+          }
+        });
+      }
+      /**
+       * Get the status of an ingestion job
+       * @param jobId - Job ID returned from ingest
+       * @param projectId - Project ID
+       * @returns Job status information
+       */
+      async getJob(jobId, projectId) {
+        if (!jobId || jobId.trim().length === 0) {
+          throw new ValidationError(
+            "Job ID is required",
+            [{ field: "jobId", message: "Job ID is required" }]
+          );
+        }
+        if (!projectId || projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        const response = await this.httpClient.request({
+          method: "GET",
+          path: `/v1/jobs/${jobId}`,
+          query: { projectId }
         });
+        return response.data || response;
       }
     };
   }

package/dist/index.d.cts

@@ -163,12 +163,30 @@ interface SearchRequest {
     query: string;
     /** Project ID to search in */
     projectId: string;
-    /** Maximum number of results to return (default: 10) */
+    /** Maximum number of results to return (default: 10 - supermemory production default) */
     limit?: number;
     /** Filter criteria for search */
     filter?: Record<string, any>;
-    /** Minimum relevance score threshold (0-1) */
+    /** Minimum relevance score threshold (0-1, default: 0.6 - supermemory production default for broad recall) */
     threshold?: number;
+    /** Enable query rewriting (default: false - adds ~400ms latency) */
+    enableQueryRewriting?: boolean;
+    /** Enable entity expansion search (default: false) */
+    enableEntityExpansion?: boolean;
+    /** Enable graph connectivity search (default: false) */
+    enableGraphConnectivity?: boolean;
+    /** Enable semantic deduplication (default: false) */
+    enableSemanticDedup?: boolean;
+    /** Reranking strategy: 'none', 'cross-encoder', 'llm' (default: 'none' - adds latency) */
+    rerankingStrategy?: 'none' | 'cross-encoder' | 'llm';
+    /** Custom fusion weights for multi-method retrieval */
+    fusionWeights?: {
+        vector?: number;
+        bm25?: number;
+        recency?: number;
+        entity?: number;
+        graph?: number;
+    };
 }
 /**
  * Search result
@@ -180,6 +198,20 @@ interface SearchResult {
     score: number;
     /** Highlighted text snippets */
     highlights?: string[];
+    /** Score breakdown by retrieval method */
+    scoreBreakdown?: {
+        vectorScore?: number;
+        bm25Score?: number;
+        recencyScore?: number;
+        entityScore?: number;
+        graphScore?: number;
+    };
+    /** Connected memories (if graph enhancement enabled) */
+    connections?: Array<{
+        memoryId: string;
+        connectionType: 'updates' | 'extends' | 'derives' | 'similarity';
+        connectionStrength: number;
+    }>;
 }
 /**
  * Search response
@@ -200,9 +232,9 @@ interface IngestFileRequest {
     projectId: string;
     /** Optional metadata to associate with ingested memories */
     metadata?: Record<string, any>;
-    /** Chunk size for splitting the file (default: 1000) */
+    /** Chunk size for splitting the file (default: 512 tokens - supermemory production default) */
     chunkSize?: number;
-    /** Overlap between chunks (default: 200) */
+    /** Overlap between chunks (default: 10% - supermemory production default) */
     chunkOverlap?: number;
 }
 /**
@@ -215,9 +247,9 @@ interface IngestTextRequest {
     projectId: string;
     /** Optional metadata to associate with ingested memories */
     metadata?: Record<string, any>;
-    /** Chunk size for splitting the text (default: 1000) */
+    /** Chunk size for splitting the text (default: 512 tokens - supermemory production default) */
     chunkSize?: number;
-    /** Overlap between chunks (default: 200) */
+    /** Overlap between chunks (default: 10% - supermemory production default) */
     chunkOverlap?: number;
 }
 /**
@@ -246,11 +278,11 @@ interface RouterRequest {
     messages: Message[];
     /** Project ID for memory context */
     projectId: string;
-    /** Model to use (optional) */
+    /** Model to use (default: 'gpt-4o-mini' - supermemory production default) */
     model?: string;
-    /** Temperature for generation (0-2, default: 1) */
+    /** Temperature for generation (0-2, default: 0.7 - supermemory production default) */
     temperature?: number;
-    /** Maximum tokens to generate */
+    /** Maximum tokens to generate (default: 2000 - supermemory production default) */
     maxTokens?: number;
     /** Whether to stream the response */
     stream?: boolean;
@@ -612,9 +644,18 @@ declare class SearchResource {
     private httpClient;
     constructor(httpClient: HTTPClient);
     /**
-     * Search memories
+     * Search memories using the unified /v1/search endpoint with hybrid retrieval.
+     *
+     * This uses the app's full retrieval pipeline with:
+     * - Vector similarity search
+     * - BM25 keyword search
+     * - Recency scoring
+     * - Graph connectivity (optional)
+     * - Entity expansion (optional)
+     * - LLM/Cross-encoder reranking (optional)
+     *
      * @param request - Search request
-     * @returns Search results
+     * @returns Search results with memory pack structure
      */
     search(request: SearchRequest): Promise<SearchResponse>;
 }
@@ -637,6 +678,21 @@ declare class IngestResource {
      * @returns Ingestion response with created memory IDs
      */
     text(request: IngestTextRequest): Promise<IngestResponse>;
+    /**
+     * Ingest content from a URL
+     * @param url - URL to ingest from
+     * @param projectId - Project ID
+     * @param metadata - Optional metadata
+     * @returns Ingestion response with job details
+     */
+    url(url: string, projectId: string, metadata?: Record<string, any>): Promise<IngestResponse>;
+    /**
+     * Get the status of an ingestion job
+     * @param jobId - Job ID returned from ingest
+     * @param projectId - Project ID
+     * @returns Job status information
+     */
+    getJob(jobId: string, projectId: string): Promise<any>;
 }
 
 /**

package/dist/index.d.ts

@@ -163,12 +163,30 @@ interface SearchRequest {
     query: string;
     /** Project ID to search in */
     projectId: string;
-    /** Maximum number of results to return (default: 10) */
+    /** Maximum number of results to return (default: 10 - supermemory production default) */
     limit?: number;
     /** Filter criteria for search */
     filter?: Record<string, any>;
-    /** Minimum relevance score threshold (0-1) */
+    /** Minimum relevance score threshold (0-1, default: 0.6 - supermemory production default for broad recall) */
     threshold?: number;
+    /** Enable query rewriting (default: false - adds ~400ms latency) */
+    enableQueryRewriting?: boolean;
+    /** Enable entity expansion search (default: false) */
+    enableEntityExpansion?: boolean;
+    /** Enable graph connectivity search (default: false) */
+    enableGraphConnectivity?: boolean;
+    /** Enable semantic deduplication (default: false) */
+    enableSemanticDedup?: boolean;
+    /** Reranking strategy: 'none', 'cross-encoder', 'llm' (default: 'none' - adds latency) */
+    rerankingStrategy?: 'none' | 'cross-encoder' | 'llm';
+    /** Custom fusion weights for multi-method retrieval */
+    fusionWeights?: {
+        vector?: number;
+        bm25?: number;
+        recency?: number;
+        entity?: number;
+        graph?: number;
+    };
 }
 /**
  * Search result
@@ -180,6 +198,20 @@ interface SearchResult {
     score: number;
     /** Highlighted text snippets */
     highlights?: string[];
+    /** Score breakdown by retrieval method */
+    scoreBreakdown?: {
+        vectorScore?: number;
+        bm25Score?: number;
+        recencyScore?: number;
+        entityScore?: number;
+        graphScore?: number;
+    };
+    /** Connected memories (if graph enhancement enabled) */
+    connections?: Array<{
+        memoryId: string;
+        connectionType: 'updates' | 'extends' | 'derives' | 'similarity';
+        connectionStrength: number;
+    }>;
 }
 /**
  * Search response
@@ -200,9 +232,9 @@ interface IngestFileRequest {
     projectId: string;
     /** Optional metadata to associate with ingested memories */
     metadata?: Record<string, any>;
-    /** Chunk size for splitting the file (default: 1000) */
+    /** Chunk size for splitting the file (default: 512 tokens - supermemory production default) */
     chunkSize?: number;
-    /** Overlap between chunks (default: 200) */
+    /** Overlap between chunks (default: 10% - supermemory production default) */
     chunkOverlap?: number;
 }
 /**
@@ -215,9 +247,9 @@ interface IngestTextRequest {
     projectId: string;
     /** Optional metadata to associate with ingested memories */
     metadata?: Record<string, any>;
-    /** Chunk size for splitting the text (default: 1000) */
+    /** Chunk size for splitting the text (default: 512 tokens - supermemory production default) */
     chunkSize?: number;
-    /** Overlap between chunks (default: 200) */
+    /** Overlap between chunks (default: 10% - supermemory production default) */
     chunkOverlap?: number;
 }
 /**
@@ -246,11 +278,11 @@ interface RouterRequest {
     messages: Message[];
     /** Project ID for memory context */
     projectId: string;
-    /** Model to use (optional) */
+    /** Model to use (default: 'gpt-4o-mini' - supermemory production default) */
     model?: string;
-    /** Temperature for generation (0-2, default: 1) */
+    /** Temperature for generation (0-2, default: 0.7 - supermemory production default) */
     temperature?: number;
-    /** Maximum tokens to generate */
+    /** Maximum tokens to generate (default: 2000 - supermemory production default) */
     maxTokens?: number;
     /** Whether to stream the response */
     stream?: boolean;
@@ -612,9 +644,18 @@ declare class SearchResource {
     private httpClient;
     constructor(httpClient: HTTPClient);
     /**
-     * Search memories
+     * Search memories using the unified /v1/search endpoint with hybrid retrieval.
+     *
+     * This uses the app's full retrieval pipeline with:
+     * - Vector similarity search
+     * - BM25 keyword search
+     * - Recency scoring
+     * - Graph connectivity (optional)
+     * - Entity expansion (optional)
+     * - LLM/Cross-encoder reranking (optional)
+     *
      * @param request - Search request
-     * @returns Search results
+     * @returns Search results with memory pack structure
      */
     search(request: SearchRequest): Promise<SearchResponse>;
 }
@@ -637,6 +678,21 @@ declare class IngestResource {
      * @returns Ingestion response with created memory IDs
      */
     text(request: IngestTextRequest): Promise<IngestResponse>;
+    /**
+     * Ingest content from a URL
+     * @param url - URL to ingest from
+     * @param projectId - Project ID
+     * @param metadata - Optional metadata
+     * @returns Ingestion response with job details
+     */
+    url(url: string, projectId: string, metadata?: Record<string, any>): Promise<IngestResponse>;
+    /**
+     * Get the status of an ingestion job
+     * @param jobId - Job ID returned from ingest
+     * @param projectId - Project ID
+     * @returns Job status information
+     */
+    getJob(jobId: string, projectId: string): Promise<any>;
 }
 
 /**

package/dist/index.js

@@ -220,9 +220,18 @@ var init_search = __esm({
         this.httpClient = httpClient;
       }
       /**
-       * Search memories
+       * Search memories using the unified /v1/search endpoint with hybrid retrieval.
+       *
+       * This uses the app's full retrieval pipeline with:
+       * - Vector similarity search
+       * - BM25 keyword search
+       * - Recency scoring
+       * - Graph connectivity (optional)
+       * - Entity expansion (optional)
+       * - LLM/Cross-encoder reranking (optional)
+       *
        * @param request - Search request
-       * @returns Search results
+       * @returns Search results with memory pack structure
        */
       async search(request) {
         if (!request.query || request.query.trim().length === 0) {
@@ -237,24 +246,36 @@ var init_search = __esm({
             [{ field: "projectId", message: "Project ID is required" }]
           );
         }
-        const query = {
-          q: request.query,
-          projectId: request.projectId
+        const body = {
+          query: request.query,
+          project_id: request.projectId,
+          include_text_format: true
         };
         if (request.limit !== void 0) {
-          query.limit = request.limit.toString();
-        }
-        if (request.threshold !== void 0) {
-          query.threshold = request.threshold.toString();
-        }
-        if (request.filter) {
-          query.filter = JSON.stringify(request.filter);
+          body.limit = request.limit;
         }
-        return this.httpClient.request({
-          method: "GET",
+        body.rerank_strategy = request.rerankingStrategy || "cross-encoder";
+        const response = await this.httpClient.request({
+          method: "POST",
           path: "/v1/search",
-          query
+          body
         });
+        const memoryPack = response.memory_pack || {};
+        const results = [];
+        for (const memoryType of ["facts", "preferences", "entities", "sources"]) {
+          const items = memoryPack[memoryType] || [];
+          for (const item of items) {
+            results.push({
+              memory: item,
+              score: item.score || 1,
+              highlights: item.highlights || []
+            });
+          }
+        }
+        return {
+          results,
+          total: results.length
+        };
       }
     };
   }
@@ -292,18 +313,15 @@ var init_ingest = __esm({
             [{ field: "projectId", message: "Project ID is required" }]
           );
         }
-        const body = {
-          projectId: request.projectId,
-          metadata: request.metadata,
-          chunkSize: request.chunkSize,
-          chunkOverlap: request.chunkOverlap,
-          // In a real implementation, you'd convert the file to base64 or use FormData
-          file: request.file
-        };
         return this.httpClient.request({
           method: "POST",
-          path: "/v1/ingest/file",
-          body
+          path: "/v1/ingest",
+          body: {
+            type: "pdf",
+            projectId: request.projectId,
+            metadata: request.metadata || {},
+            file: request.file
+          }
         });
       }
       /**
@@ -326,9 +344,71 @@ var init_ingest = __esm({
         }
         return this.httpClient.request({
           method: "POST",
-          path: "/v1/ingest/text",
-          body: request
+          path: "/v1/ingest",
+          body: {
+            type: "text",
+            content: request.text,
+            projectId: request.projectId,
+            metadata: request.metadata || {}
+          }
+        });
+      }
+      /**
+       * Ingest content from a URL
+       * @param url - URL to ingest from
+       * @param projectId - Project ID
+       * @param metadata - Optional metadata
+       * @returns Ingestion response with job details
+       */
+      async url(url, projectId, metadata) {
+        if (!url || url.trim().length === 0) {
+          throw new ValidationError(
+            "URL cannot be empty",
+            [{ field: "url", message: "URL is required and cannot be empty" }]
+          );
+        }
+        if (!projectId || projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        return this.httpClient.request({
+          method: "POST",
+          path: "/v1/ingest",
+          body: {
+            type: "url",
+            url,
+            projectId,
+            metadata: metadata || {}
+          }
+        });
+      }
+      /**
+       * Get the status of an ingestion job
+       * @param jobId - Job ID returned from ingest
+       * @param projectId - Project ID
+       * @returns Job status information
+       */
+      async getJob(jobId, projectId) {
+        if (!jobId || jobId.trim().length === 0) {
+          throw new ValidationError(
+            "Job ID is required",
+            [{ field: "jobId", message: "Job ID is required" }]
+          );
+        }
+        if (!projectId || projectId.trim().length === 0) {
+          throw new ValidationError(
+            "Project ID is required",
+            [{ field: "projectId", message: "Project ID is required" }]
+          );
+        }
+        const response = await this.httpClient.request({
+          method: "GET",
+          path: `/v1/jobs/${jobId}`,
+          query: { projectId }
         });
+        return response.data || response;
       }
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorylayerai/sdk",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "private": false,
   "description": "Official Node.js/TypeScript SDK for MemoryLayer",
   "main": "dist/index.js",

package/src/resources/ingest.ts

@@ -29,21 +29,16 @@ export class IngestResource {
       );
     }
 
-    // For file uploads, we need to use FormData
-    // This is a simplified implementation - in production, you'd handle multipart/form-data properly
-    const body = {
-      projectId: request.projectId,
-      metadata: request.metadata,
-      chunkSize: request.chunkSize,
-      chunkOverlap: request.chunkOverlap,
-      // In a real implementation, you'd convert the file to base64 or use FormData
-      file: request.file,
-    };
-
+    // Use unified /v1/ingest endpoint matching the app
     return this.httpClient.request<IngestResponse>({
       method: 'POST',
-      path: '/v1/ingest/file',
-      body,
+      path: '/v1/ingest',
+      body: {
+        type: 'pdf',
+        projectId: request.projectId,
+        metadata: request.metadata || {},
+        file: request.file,
+      },
     });
   }
 
@@ -68,10 +63,82 @@ export class IngestResource {
       );
     }
 
+    // Use unified /v1/ingest endpoint matching the app
     return this.httpClient.request<IngestResponse>({
       method: 'POST',
-      path: '/v1/ingest/text',
-      body: request,
+      path: '/v1/ingest',
+      body: {
+        type: 'text',
+        content: request.text,
+        projectId: request.projectId,
+        metadata: request.metadata || {},
+      },
     });
   }
+
+  /**
+   * Ingest content from a URL
+   * @param url - URL to ingest from
+   * @param projectId - Project ID
+   * @param metadata - Optional metadata
+   * @returns Ingestion response with job details
+   */
+  async url(url: string, projectId: string, metadata?: Record<string, any>): Promise<IngestResponse> {
+    // Validate request
+    if (!url || url.trim().length === 0) {
+      throw new ValidationError(
+        'URL cannot be empty',
+        [{ field: 'url', message: 'URL is required and cannot be empty' }]
+      );
+    }
+
+    if (!projectId || projectId.trim().length === 0) {
+      throw new ValidationError(
+        'Project ID is required',
+        [{ field: 'projectId', message: 'Project ID is required' }]
+      );
+    }
+
+    // Use unified /v1/ingest endpoint matching the app
+    return this.httpClient.request<IngestResponse>({
+      method: 'POST',
+      path: '/v1/ingest',
+      body: {
+        type: 'url',
+        url,
+        projectId,
+        metadata: metadata || {},
+      },
+    });
+  }
+
+  /**
+   * Get the status of an ingestion job
+   * @param jobId - Job ID returned from ingest
+   * @param projectId - Project ID
+   * @returns Job status information
+   */
+  async getJob(jobId: string, projectId: string): Promise<any> {
+    if (!jobId || jobId.trim().length === 0) {
+      throw new ValidationError(
+        'Job ID is required',
+        [{ field: 'jobId', message: 'Job ID is required' }]
+      );
+    }
+
+    if (!projectId || projectId.trim().length === 0) {
+      throw new ValidationError(
+        'Project ID is required',
+        [{ field: 'projectId', message: 'Project ID is required' }]
+      );
+    }
+
+    const response = await this.httpClient.request<any>({
+      method: 'GET',
+      path: `/v1/jobs/${jobId}`,
+      query: { projectId },
+    });
+
+    return response.data || response;
+  }
 }

package/src/resources/search.ts

@@ -9,9 +9,18 @@ export class SearchResource {
   constructor(private httpClient: HTTPClient) {}
 
   /**
-   * Search memories
+   * Search memories using the unified /v1/search endpoint with hybrid retrieval.
+   *
+   * This uses the app's full retrieval pipeline with:
+   * - Vector similarity search
+   * - BM25 keyword search
+   * - Recency scoring
+   * - Graph connectivity (optional)
+   * - Entity expansion (optional)
+   * - LLM/Cross-encoder reranking (optional)
+   *
    * @param request - Search request
-   * @returns Search results
+   * @returns Search results with memory pack structure
    */
   async search(request: SearchRequest): Promise<SearchResponse> {
     // Validate request
@@ -29,27 +38,46 @@ export class SearchResource {
       );
     }
 
-    const query: Record<string, string> = {
-      q: request.query,
-      projectId: request.projectId,
+    // Build request body matching the app's POST /v1/search endpoint
+    const body: any = {
+      query: request.query,
+      project_id: request.projectId,
+      include_text_format: true,
     };
 
     if (request.limit !== undefined) {
-      query.limit = request.limit.toString();
+      body.limit = request.limit;
     }
 
-    if (request.threshold !== undefined) {
-      query.threshold = request.threshold.toString();
-    }
-
-    if (request.filter) {
-      query.filter = JSON.stringify(request.filter);
-    }
+    // Use rerank_strategy to match app's parameter name
+    body.rerank_strategy = request.rerankingStrategy || 'cross-encoder';
 
-    return this.httpClient.request<SearchResponse>({
-      method: 'GET',
+    // Use POST method to match the app's endpoint
+    const response = await this.httpClient.request<any>({
+      method: 'POST',
       path: '/v1/search',
-      query,
+      body,
     });
+
+    // Parse response from memory_pack format
+    const memoryPack = response.memory_pack || {};
+    const results = [];
+
+    // Extract memories from memory pack structure
+    for (const memoryType of ['facts', 'preferences', 'entities', 'sources']) {
+      const items = memoryPack[memoryType] || [];
+      for (const item of items) {
+        results.push({
+          memory: item,
+          score: item.score || 1.0,
+          highlights: item.highlights || [],
+        });
+      }
+    }
+
+    return {
+      results,
+      total: results.length,
+    };
   }
 }

package/src/types.ts

@@ -60,12 +60,30 @@ export interface SearchRequest {
   query: string;
   /** Project ID to search in */
   projectId: string;
-  /** Maximum number of results to return (default: 10) */
+  /** Maximum number of results to return (default: 10 - supermemory production default) */
   limit?: number;
   /** Filter criteria for search */
   filter?: Record<string, any>;
-  /** Minimum relevance score threshold (0-1) */
+  /** Minimum relevance score threshold (0-1, default: 0.6 - supermemory production default for broad recall) */
   threshold?: number;
+  /** Enable query rewriting (default: false - adds ~400ms latency) */
+  enableQueryRewriting?: boolean;
+  /** Enable entity expansion search (default: false) */
+  enableEntityExpansion?: boolean;
+  /** Enable graph connectivity search (default: false) */
+  enableGraphConnectivity?: boolean;
+  /** Enable semantic deduplication (default: false) */
+  enableSemanticDedup?: boolean;
+  /** Reranking strategy: 'none', 'cross-encoder', 'llm' (default: 'none' - adds latency) */
+  rerankingStrategy?: 'none' | 'cross-encoder' | 'llm';
+  /** Custom fusion weights for multi-method retrieval */
+  fusionWeights?: {
+    vector?: number;
+    bm25?: number;
+    recency?: number;
+    entity?: number;
+    graph?: number;
+  };
 }
 
 /**
@@ -78,6 +96,20 @@ export interface SearchResult {
   score: number;
   /** Highlighted text snippets */
   highlights?: string[];
+  /** Score breakdown by retrieval method */
+  scoreBreakdown?: {
+    vectorScore?: number;
+    bm25Score?: number;
+    recencyScore?: number;
+    entityScore?: number;
+    graphScore?: number;
+  };
+  /** Connected memories (if graph enhancement enabled) */
+  connections?: Array<{
+    memoryId: string;
+    connectionType: 'updates' | 'extends' | 'derives' | 'similarity';
+    connectionStrength: number;
+  }>;
 }
 
 /**
@@ -100,9 +132,9 @@ export interface IngestFileRequest {
   projectId: string;
   /** Optional metadata to associate with ingested memories */
   metadata?: Record<string, any>;
-  /** Chunk size for splitting the file (default: 1000) */
+  /** Chunk size for splitting the file (default: 512 tokens - supermemory production default) */
   chunkSize?: number;
-  /** Overlap between chunks (default: 200) */
+  /** Overlap between chunks (default: 10% - supermemory production default) */
   chunkOverlap?: number;
 }
 
@@ -116,9 +148,9 @@ export interface IngestTextRequest {
   projectId: string;
   /** Optional metadata to associate with ingested memories */
   metadata?: Record<string, any>;
-  /** Chunk size for splitting the text (default: 1000) */
+  /** Chunk size for splitting the text (default: 512 tokens - supermemory production default) */
   chunkSize?: number;
-  /** Overlap between chunks (default: 200) */
+  /** Overlap between chunks (default: 10% - supermemory production default) */
   chunkOverlap?: number;
 }
 
@@ -150,11 +182,11 @@ export interface RouterRequest {
   messages: Message[];
   /** Project ID for memory context */
   projectId: string;
-  /** Model to use (optional) */
+  /** Model to use (default: 'gpt-4o-mini' - supermemory production default) */
   model?: string;
-  /** Temperature for generation (0-2, default: 1) */
+  /** Temperature for generation (0-2, default: 0.7 - supermemory production default) */
   temperature?: number;
-  /** Maximum tokens to generate */
+  /** Maximum tokens to generate (default: 2000 - supermemory production default) */
   maxTokens?: number;
   /** Whether to stream the response */
   stream?: boolean;