@memorylayerai/sdk 0.4.0 → 0.5.0

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,42 +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;
         }
-        if (request.enableQueryRewriting !== void 0) {
-          query.enableQueryRewriting = request.enableQueryRewriting.toString();
-        }
-        if (request.enableEntityExpansion !== void 0) {
-          query.enableEntityExpansion = request.enableEntityExpansion.toString();
-        }
-        if (request.enableGraphConnectivity !== void 0) {
-          query.enableGraphConnectivity = request.enableGraphConnectivity.toString();
-        }
-        if (request.enableSemanticDedup !== void 0) {
-          query.enableSemanticDedup = request.enableSemanticDedup.toString();
-        }
-        if (request.rerankingStrategy) {
-          query.rerankingStrategy = request.rerankingStrategy;
-        }
-        if (request.fusionWeights) {
-          query.fusionWeights = JSON.stringify(request.fusionWeights);
-        }
-        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
+        };
       }
     };
   }
@@ -311,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
+          }
         });
       }
       /**
@@ -345,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,13 +163,13 @@ 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: true) */
+    /** Enable query rewriting (default: false - adds ~400ms latency) */
     enableQueryRewriting?: boolean;
     /** Enable entity expansion search (default: false) */
     enableEntityExpansion?: boolean;
@@ -177,7 +177,7 @@ interface SearchRequest {
     enableGraphConnectivity?: boolean;
     /** Enable semantic deduplication (default: false) */
     enableSemanticDedup?: boolean;
-    /** Reranking strategy: 'none', 'cross-encoder', 'llm' (default: 'none') */
+    /** Reranking strategy: 'none', 'cross-encoder', 'llm' (default: 'none' - adds latency) */
     rerankingStrategy?: 'none' | 'cross-encoder' | 'llm';
     /** Custom fusion weights for multi-method retrieval */
     fusionWeights?: {
@@ -232,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;
 }
 /**
@@ -247,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;
 }
 /**
@@ -278,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;
@@ -644,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>;
 }
@@ -669,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,13 +163,13 @@ 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: true) */
+    /** Enable query rewriting (default: false - adds ~400ms latency) */
     enableQueryRewriting?: boolean;
     /** Enable entity expansion search (default: false) */
     enableEntityExpansion?: boolean;
@@ -177,7 +177,7 @@ interface SearchRequest {
     enableGraphConnectivity?: boolean;
     /** Enable semantic deduplication (default: false) */
     enableSemanticDedup?: boolean;
-    /** Reranking strategy: 'none', 'cross-encoder', 'llm' (default: 'none') */
+    /** Reranking strategy: 'none', 'cross-encoder', 'llm' (default: 'none' - adds latency) */
     rerankingStrategy?: 'none' | 'cross-encoder' | 'llm';
     /** Custom fusion weights for multi-method retrieval */
     fusionWeights?: {
@@ -232,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;
 }
 /**
@@ -247,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;
 }
 /**
@@ -278,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;
@@ -644,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>;
 }
@@ -669,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,42 +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;
         }
-        if (request.enableQueryRewriting !== void 0) {
-          query.enableQueryRewriting = request.enableQueryRewriting.toString();
-        }
-        if (request.enableEntityExpansion !== void 0) {
-          query.enableEntityExpansion = request.enableEntityExpansion.toString();
-        }
-        if (request.enableGraphConnectivity !== void 0) {
-          query.enableGraphConnectivity = request.enableGraphConnectivity.toString();
-        }
-        if (request.enableSemanticDedup !== void 0) {
-          query.enableSemanticDedup = request.enableSemanticDedup.toString();
-        }
-        if (request.rerankingStrategy) {
-          query.rerankingStrategy = request.rerankingStrategy;
-        }
-        if (request.fusionWeights) {
-          query.fusionWeights = JSON.stringify(request.fusionWeights);
-        }
-        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
+        };
       }
     };
   }
@@ -310,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
+          }
         });
       }
       /**
@@ -344,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.4.0",
+  "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,52 +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);
-    }
-
-    // New advanced retrieval options
-    if (request.enableQueryRewriting !== undefined) {
-      query.enableQueryRewriting = request.enableQueryRewriting.toString();
-    }
-
-    if (request.enableEntityExpansion !== undefined) {
-      query.enableEntityExpansion = request.enableEntityExpansion.toString();
-    }
-
-    if (request.enableGraphConnectivity !== undefined) {
-      query.enableGraphConnectivity = request.enableGraphConnectivity.toString();
-    }
+    // Use rerank_strategy to match app's parameter name
+    body.rerank_strategy = request.rerankingStrategy || 'cross-encoder';
 
-    if (request.enableSemanticDedup !== undefined) {
-      query.enableSemanticDedup = request.enableSemanticDedup.toString();
-    }
+    // Use POST method to match the app's endpoint
+    const response = await this.httpClient.request<any>({
+      method: 'POST',
+      path: '/v1/search',
+      body,
+    });
 
-    if (request.rerankingStrategy) {
-      query.rerankingStrategy = request.rerankingStrategy;
-    }
+    // Parse response from memory_pack format
+    const memoryPack = response.memory_pack || {};
+    const results = [];
 
-    if (request.fusionWeights) {
-      query.fusionWeights = JSON.stringify(request.fusionWeights);
+    // 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 this.httpClient.request<SearchResponse>({
-      method: 'GET',
-      path: '/v1/search',
-      query,
-    });
+    return {
+      results,
+      total: results.length,
+    };
   }
 }

package/src/types.ts

@@ -60,13 +60,13 @@ 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: true) */
+  /** Enable query rewriting (default: false - adds ~400ms latency) */
   enableQueryRewriting?: boolean;
   /** Enable entity expansion search (default: false) */
   enableEntityExpansion?: boolean;
@@ -74,7 +74,7 @@ export interface SearchRequest {
   enableGraphConnectivity?: boolean;
   /** Enable semantic deduplication (default: false) */
   enableSemanticDedup?: boolean;
-  /** Reranking strategy: 'none', 'cross-encoder', 'llm' (default: 'none') */
+  /** Reranking strategy: 'none', 'cross-encoder', 'llm' (default: 'none' - adds latency) */
   rerankingStrategy?: 'none' | 'cross-encoder' | 'llm';
   /** Custom fusion weights for multi-method retrieval */
   fusionWeights?: {
@@ -132,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;
 }
 
@@ -148,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;
 }
 
@@ -182,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;