@memorylayerai/sdk 0.4.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorylayerai/sdk",
-  "version": "0.4.0",
+  "version": "0.6.1",
   "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

@@ -1,3 +1,36 @@
+/**
+ * Model provider options for multi-provider support
+ * Allows overriding org-level settings at request time
+ *
+ * Supported providers:
+ * - 'openai': OpenAI GPT models and text-embedding models
+ * - 'google': Google Gemini models and text-embedding-004
+ * - 'anthropic': Anthropic Claude models (uses OpenAI embeddings for vector search)
+ */
+export type ModelProvider = 'openai' | 'google' | 'anthropic';
+
+/**
+ * Model settings for request-level override
+ */
+export interface ModelSettings {
+  /** Model provider: 'openai', 'google', or 'anthropic' */
+  provider?: ModelProvider;
+  /**
+   * Embedding model to use:
+   * - OpenAI: 'text-embedding-3-small', 'text-embedding-3-large', 'text-embedding-ada-002'
+   * - Google: 'text-embedding-004'
+   * - Anthropic: Uses OpenAI embeddings (specify OpenAI model)
+   */
+  embeddingModel?: string;
+  /**
+   * Language model for extraction/generation:
+   * - OpenAI: 'gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1', 'o1-mini'
+   * - Google: 'gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.0-flash'
+   * - Anthropic: 'claude-3-5-sonnet-20241022', 'claude-3-opus-20240229', 'claude-3-haiku-20240307'
+   */
+  languageModel?: string;
+}
+
 /**
  * Memory object
  */
@@ -60,13 +93,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 +107,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?: {
@@ -84,6 +117,8 @@ export interface SearchRequest {
     entity?: number;
     graph?: number;
   };
+  /** Model settings override (optional - uses org settings if not specified) */
+  modelSettings?: ModelSettings;
 }
 
 /**
@@ -132,10 +167,12 @@ 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;
+  /** Model settings override (optional - uses org settings if not specified) */
+  modelSettings?: ModelSettings;
 }
 
 /**
@@ -148,10 +185,12 @@ 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;
+  /** Model settings override (optional - uses org settings if not specified) */
+  modelSettings?: ModelSettings;
 }
 
 /**
@@ -182,11 +221,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;