@futdevpro/nts-dynamo 1.11.2 → 1.11.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/nts-dynamo",
-  "version": "01.11.2",
+  "version": "01.11.5",
   "description": "Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Program Ltd.",
   "DyBu_settings": {
     "packageType": "server-package",
@@ -163,12 +163,12 @@
   },
   "homepage": "https:/futdevpro.hu/projects/dynamo",
   "DISABLED": {
-    "@futdevpro/fsm-dynamo": "file:../tgz-collection/dynamo-fsm/futdevpro-fsm-dynamo-01.11.2.tgz",
+    "@futdevpro/fsm-dynamo": "file:../tgz-collection/dynamo-fsm/futdevpro-fsm-dynamo-01.11.5.tgz",
     
     "empty": ""
   },
   "peerDependencies": {
-    "@futdevpro/fsm-dynamo": "1.11.2",
+    "@futdevpro/fsm-dynamo": "1.11.5",
 
     "@types/express": "4.17.21",
     "@types/geoip-lite": "~1.4.1",

package/src/_modules/discord-assistant/_models/dias-knowledge.data-model.ts

@@ -5,10 +5,12 @@ import { DyFM_DataModel_Params, DyFM_Metadata } from '@futdevpro/fsm-dynamo';
 export class DyNTS_DiAs_Knowledge extends DyFM_Metadata {
 
   subject?: string;
-  subjectVectorized?: number[] = [];
+  /* subjectVectorized?: number[] = []; */
 
   description?: string;
-  descriptionVectorized?: number[] = [];
+  /* descriptionVectorized?: number[] = []; */
+
+  contentVectorized?: number[] = [];
 
   constructor(
     set?: DyNTS_DiAs_Knowledge,
@@ -28,19 +30,24 @@ export const DyNTS_DiAs_knowledge_dataParams = new DyFM_DataModel_Params<DyNTS_D
       type: 'string', index: true,
       required: true, unique: true,
     },
-    subjectVectorized: { 
+    /* subjectVectorized: { 
       type: 'number[]', 
       vectorizedFrom: 'subject',
       vectorizeUseIndex: 'subject',
-    },
+    }, */
     description: { 
       type: 'string', index: true,
       required: true,
     },
-    descriptionVectorized: { 
+    /* descriptionVectorized: { 
       type: 'number[]', 
       vectorizedFrom: 'description',
       vectorizeUseIndex: 'description',
+    }, */
+    contentVectorized: {
+      type: 'number[]', 
+      vectorizedFrom: [ 'description', 'subject' ],
+      vectorizeUseIndex: 'contentVectorized',
     },
   },
 });

package/src/_modules/discord-assistant/_services/dias-chunk.data-service.ts

@@ -1,16 +1,20 @@
-
-import { DyNTS_OAI_DocChunk } from '../../open-ai/_models/oai-doc-chunk.data-model';
-import { DyNTS_OAI_Chunk_ServiceBase } from '../../open-ai/_services/oai-chunk.service-base';
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_OAI_Chunk, DyNTS_OAI_defaultChunk_dataParams } from '../../open-ai/_models/oai-doc-chunk.data-model';
+import { DyNTS_OAI_Chunk_DataServiceBase } from '../../open-ai/_services/oai-chunk.service-base';
+import { DyFM_DataModel_Params, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
 import { DyFM_OpenAI_Settings, DyFM_OpenAIModel } from '@futdevpro/fsm-dynamo/open-ai';
 import { DyNTS_DiAs_Main_ControlService } from './dias-main.control-service';
 import { DyNTS_OAI_LLMChat_ServiceBase } from '../../open-ai/_services/oai-llm-chat.service-base';
 import { DyNTS_OAI_GPT_Message } from '../../open-ai/_models/interfaces/oai-gpt-message.interface';
 import { DyNTS_OAI_LLMDefaultPredefined_Requests } from '../../open-ai/_collections/oai-llm-predefined-requests.conts';
 import { DyNTS_OAI_Document_Util } from '../../open-ai/_collections/oai-document.util';
+import { DyNTS_OAI_DocumentPage } from '../../open-ai/_models/interfaces/oai-document-page.interface';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
 
 
-export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_ServiceBase {
+export abstract class DyNTS_DiAs_Chunk_DataService<
+  T_Chunk extends DyNTS_OAI_Chunk = DyNTS_OAI_Chunk,
+  T_Page extends DyNTS_OAI_DocumentPage<T_Chunk> = DyNTS_OAI_DocumentPage<T_Chunk>, 
+> extends DyNTS_OAI_Chunk_DataServiceBase<T_Chunk, T_Page> {
 
   protected abstract readonly mainDiscordBot_CS: DyNTS_DiAs_Main_ControlService;
 
@@ -20,10 +24,28 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
 
   constructor(
     issuer: string,
+    dataParams?: DyFM_DataModel_Params<T_Chunk>,
+    openAiSettings?: DyFM_OpenAI_Settings,
   ) {
-    super(issuer);
+    super(
+      dataParams ?? DyNTS_OAI_defaultChunk_dataParams as DyFM_DataModel_Params<T_Chunk>, 
+      openAiSettings ?? 
+        new DyFM_OpenAI_Settings({
+          openAIConfig: {
+            apiKey: DyNTS_global_settings.env_settings.openAi.apiKey,
+            organization: DyNTS_global_settings.env_settings.openAi.organization,
+            project: DyNTS_global_settings.env_settings.openAi.project,
+          },
+          defaultSettings: {
+            useModel: DyFM_OpenAIModel.textEmbedding_3Large,
+          },
+        }),
+      issuer
+    );
   }
 
+  abstract getPageLink(page: T_Page, issuer: string): string;
+
   async resolveConversation(
     conversation: DyNTS_OAI_GPT_Message[],
   ): Promise<string> {
@@ -71,7 +93,7 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
     numberOfCandidates: number = 100,
   ): Promise<string> {
     try {
-      const searchResults: DyNTS_OAI_DocChunk[] = await this.vectorSearchUsingConversation(
+      const searchResults: T_Chunk[] = await this.vectorSearchUsingConversation(
         conversation,
         limit,
         numberOfCandidates,
@@ -79,13 +101,8 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
 
       const parsedSearchResults: string = searchResults.map((result) => {
         return '' +
-          '\npage: ' + result.documentName +
-          '\npageLink: ' + DyNTS_OAI_Document_Util.getClickupPageLink(
-            result.documentName,
-            result.workspaceId,
-            result.documentId,
-            result.documentPageId
-          ) +
+          '\npage: ' + result.pageName +
+          '\npageLink: ' + result.pageLink +
           '\ncontent: ' +
           `\n${result.chunkParentedContent.replace(/\n/g, '\n  ')}`
       }).join('\n\n');
@@ -117,7 +134,7 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
     conversation: DyNTS_OAI_GPT_Message[],
     limit: number = 3,
     numberOfCandidates: number = 100,
-  ): Promise<DyNTS_OAI_DocChunk[]> {
+  ): Promise<T_Chunk[]> {
     try {
       const lastMessage: DyNTS_OAI_GPT_Message = conversation[conversation.length - 1];
 
@@ -134,7 +151,7 @@ export abstract class DyNTS_DiAs_Chunk_DataService extends DyNTS_OAI_Chunk_Servi
 
       DyFM_Log.testInfo('🔍 Document search question:', searchQuestion);
 
-      const searchResults: DyNTS_OAI_DocChunk[] = await this.vectorSearch(
+      const searchResults: T_Chunk[] = await this.vectorSearch(
         searchQuestion + ' ' + lastMessage.content,
         'chunkParentedContentVectorized',
         limit,

package/src/_modules/open-ai/_collections/oai-chunking.util.ts

@@ -1,5 +1,5 @@
 import { DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { DyNTS_OAI_DocChunk } from '../_models/oai-doc-chunk.data-model';
+import { DyNTS_OAI_Chunk } from '../_models/oai-doc-chunk.data-model';
 import { DyNTS_OAI_DocumentPage } from '../_models/interfaces/oai-document-page.interface';
 import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
 
@@ -20,10 +20,14 @@ export class DyNTS_OAI_Chunking_Util {
    * @param issuer - Kérés kezdeményezője
    * @returns Promise<CU_DocChunk[]> - Létrehozott chunk-ok listája
    */
-  static async chunkMdContent(
-    page: DyNTS_OAI_DocumentPage,
+  static async chunkMdContent<
+    T_Chunk extends DyNTS_OAI_Chunk,
+    T_Page extends DyNTS_OAI_DocumentPage<T_Chunk>
+  >(
+    page: T_Page,
+    getPageLink: (page: T_Page, issuer: string) => string,
     issuer: string
-  ): Promise<DyNTS_OAI_DocChunk[]> {
+  ): Promise<T_Chunk[]> {
     try {
       if (page.content.includes('#####')) {
         DyFM_Log.warn('lvl5+ headers are not supported yet for page: ' + page.name);
@@ -34,7 +38,7 @@ export class DyNTS_OAI_Chunking_Util {
       let leftovers = page.content;
       const maxChunkSize = DyNTS_global_settings.docChunking.maxChunkSize;
       const maxChunkCount = DyNTS_global_settings.docChunking.maxChunkCount;
-      const chunks: DyNTS_OAI_DocChunk[] = [];
+      const chunks: T_Chunk[] = [];
       let chunkIndex = 0;
       let currentPosition = 0; // Track current position in original content
 
@@ -58,20 +62,25 @@ export class DyNTS_OAI_Chunking_Util {
           if (chunkContent.length > 0) {
             const chunkWithHierarchy = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
             const chunkPath = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
+            const headParents = headerHierarchy.map(header => header.header);
+            const allFlaggedParents = [ ...page.allFlaggedParents, ...headParents ];
             
-            const chunk = new DyNTS_OAI_DocChunk({
-              workspaceId: page.workspaceId,
-              documentId: page.docId,
-              documentPageId: page._id,
+            const chunk: T_Chunk = new DyNTS_OAI_Chunk({
+              filePathParents: page.path,
+              chunkHeadParents: headParents,
 
-              documentName: page.name,
-              documentPath: page.path,
+              allFlaggedParents: allFlaggedParents,
+              allFlaggedParentsMerged: allFlaggedParents.join('/'),
 
+              documentName: page.documentId,
+              pageName: page.name,
+              pageLink: getPageLink(page, issuer),
               chunkIndex: chunkIndex,
-              chunkPath: chunkPath,
               
               chunkOriginalContent: chunkContent,
-            });
+
+              chunkParentedContent: chunkWithHierarchy,
+            }) as T_Chunk;
             chunk.chunkParentedContent = this.assembleChunkWithHeaders(chunk, issuer);
             chunks.push(chunk);
           }
@@ -99,23 +108,28 @@ export class DyNTS_OAI_Chunking_Util {
           
           const chunkWithHierarchy = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
           const chunkPath = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
+          const headParents = headerHierarchy.map(header => header.header);
+          const allFlaggedParents = [ ...page.allFlaggedParents, ...headParents ];
           
           /* console.log(`Chunk path:`, chunkPath);
           console.log(`Chunk with hierarchy preview:`, chunkWithHierarchy.substring(0, 100) + '...'); */
           
-          const chunk = new DyNTS_OAI_DocChunk({
-            workspaceId: page.workspaceId,
-            documentId: page.docId,
-            documentPageId: page._id,
-            
-            documentName: page.name,
-            documentPath: page.path,
+          const chunk: T_Chunk = new DyNTS_OAI_Chunk({
+            filePathParents: page.path,
+            chunkHeadParents: headParents,
 
+            allFlaggedParents: allFlaggedParents,
+            allFlaggedParentsMerged: allFlaggedParents.join('/'),
+
+            documentName: page.documentId,
+            pageName: page.name,
+            pageLink: getPageLink(page, issuer),
             chunkIndex: chunkIndex,
-            chunkPath: chunkPath,
-                        
+
             chunkOriginalContent: chunkContent,
-          });
+
+            chunkParentedContent: chunkWithHierarchy,
+          }) as T_Chunk;
           chunk.chunkParentedContent = this.assembleChunkWithHeaders(chunk, issuer);
           chunks.push(chunk);
           chunkIndex++;
@@ -132,20 +146,25 @@ export class DyNTS_OAI_Chunking_Util {
           const chunkContent = leftovers.substring(0, maxChunkSize).trim();
           const chunkWithHierarchy = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
           const chunkPath = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
+          const headParents = headerHierarchy.map(header => header.header);
+          const allFlaggedParents = [ ...page.allFlaggedParents, ...headParents ];
           
-          const chunk = new DyNTS_OAI_DocChunk({
-            workspaceId: page.workspaceId,
-            documentId: page.docId,
-            documentPageId: page._id,
+          const chunk: T_Chunk = new DyNTS_OAI_Chunk({
+            filePathParents: page.path,
+            chunkHeadParents: headParents,
 
-            documentName: page.name,
-            documentPath: page.path,
+            allFlaggedParents: allFlaggedParents,
+            allFlaggedParentsMerged: allFlaggedParents.join('/'),
 
+            documentName: page.documentId,
+            pageName: page.name,
+            pageLink: getPageLink(page, issuer),
             chunkIndex: chunkIndex,
-            chunkPath: chunkPath,
 
             chunkOriginalContent: chunkContent,
-          });
+
+            chunkParentedContent: chunkWithHierarchy,
+          }) as T_Chunk;
           chunk.chunkParentedContent = this.assembleChunkWithHeaders(chunk, issuer);
           chunks.push(chunk);
           chunkIndex++;
@@ -190,12 +209,12 @@ export class DyNTS_OAI_Chunking_Util {
     }
   }
 
-  private static assembleChunkWithHeaders(chunk: DyNTS_OAI_DocChunk, issuer: string): string {
+  private static assembleChunkWithHeaders(chunk: DyNTS_OAI_Chunk, issuer: string): string {
     try {
-      const fileHeaders = chunk.documentPath.map(
+      const fileHeaders = chunk.filePathParents.map(
         (header, index) => `${'>'.repeat(index + 1)} **${header}**`
       ).join('\n');
-      const headers = chunk.chunkPath.filter(
+      const headers = chunk.chunkHeadParents.filter(
         path => !chunk.chunkOriginalContent.includes(path)
       ).join('\n');
       return `${fileHeaders}\n\n${headers}\n\n${chunk.chunkOriginalContent}`;
@@ -208,7 +227,7 @@ export class DyNTS_OAI_Chunking_Util {
   }
 
   static reassembleChunksToContent(
-    chunks: DyNTS_OAI_DocChunk[],
+    chunks: DyNTS_OAI_Chunk[],
     issuer: string
   ): string {
     try {

package/src/_modules/open-ai/_models/interfaces/oai-chunk-compare-result.interface.ts

@@ -1,10 +1,15 @@
 
 
 import { DyNTS_OAI_CompareResult_Type } from '../../_enums/oai-compare-result-type.enum';
-import { DyNTS_OAI_DocChunk } from '../oai-doc-chunk.data-model';
+import { DyNTS_OAI_Chunk } from '../oai-doc-chunk.data-model';
 
 
-export interface DyNTS_OAI_ChunkCompareResult {
+export interface DyNTS_OAI_ChunkCompareResult<
+  T_Chunk extends DyNTS_OAI_Chunk = DyNTS_OAI_Chunk
+> {
   result: DyNTS_OAI_CompareResult_Type;
-  oldChunk: DyNTS_OAI_DocChunk;
+  oldChunk: T_Chunk;
 }
+
+
+

package/src/_modules/open-ai/_models/interfaces/oai-document-page.interface.ts

@@ -1,21 +1,27 @@
 import { DyFM_Metadata } from '@futdevpro/fsm-dynamo';
-import { DyNTS_OAI_DocChunk } from '../oai-doc-chunk.data-model';
+import { DyNTS_OAI_Chunk } from '../oai-doc-chunk.data-model';
 
 
 
 
-export interface DyNTS_OAI_DocumentPage extends DyFM_Metadata {
-  workspaceId: string;
-  docId: string;
-  parentPageId: string;
+export interface DyNTS_OAI_DocumentPage<
+  T_Chunk extends DyNTS_OAI_Chunk = DyNTS_OAI_Chunk
+> {
+  documentId: string;
+  pageId: string;
 
+  name: string;
+  
+  allFlaggedParents: string[];
+  allFlaggedParentsMerged: string;
+  
   /** Path to the page in the document, starting with the document name */
   path: string[];
-  documentParent: string;
 
-  name: string;
+  chunks: T_Chunk[];
   content: string;
-  
-  pages: DyNTS_OAI_DocumentPage[];
-  chunks: DyNTS_OAI_DocChunk[];
+
+  pages?: DyNTS_OAI_DocumentPage<T_Chunk>[];
 }
+
+

package/src/_modules/open-ai/_models/interfaces/oai-page-compare-result.interface.ts

@@ -1,18 +1,15 @@
+import { DyNTS_OAI_Chunk } from '../oai-doc-chunk.data-model';
+import { DyNTS_OAI_ChunkCompareResult, DyNTS_OAI_CompareResult_Type, DyNTS_OAI_DocumentPage } from '../..';
 
-import { DyNTS_OAI_CompareResult_Type } from '../../_enums/oai-compare-result-type.enum';
-import { DyNTS_OAI_DocChunk } from '../oai-doc-chunk.data-model';
-import { DyNTS_OAI_ChunkCompareResult } from './oai-chunk-compare-result.interface';
-import { DyNTS_OAI_DocumentPage } from './oai-document-page.interface';
-
-
-
-
-export interface DyNTS_OAI_PageCompareResult {
+export interface DyNTS_OAI_PageCompareResult<
+  T_Chunk extends DyNTS_OAI_Chunk = DyNTS_OAI_Chunk,
+  T_Doc extends DyNTS_OAI_DocumentPage<T_Chunk> = DyNTS_OAI_DocumentPage<T_Chunk>, 
+> {
   result: DyNTS_OAI_CompareResult_Type;
-  subjectPage: DyNTS_OAI_DocumentPage;
+  subjectPage: T_Doc;
   oldPageContent: string;
-  chunkCompareResults: DyNTS_OAI_ChunkCompareResult[];
+  chunkCompareResults: DyNTS_OAI_ChunkCompareResult<T_Chunk>[];
 
-  newChunks: DyNTS_OAI_DocChunk[];
-  oldChunks: DyNTS_OAI_DocChunk[];
+  newChunks: T_Chunk[];
+  oldChunks: T_Chunk[];
 }

package/src/_modules/open-ai/_models/oai-doc-chunk.data-model.ts

@@ -1,92 +1,101 @@
 
 
 
-import { DyFM_DataModel_Params, DyFM_Metadata } from '@futdevpro/fsm-dynamo';
+import { DyFM_DataModel_Params, DyFM_DataProperties, DyFM_Metadata } from '@futdevpro/fsm-dynamo';
 import { DyFM_OpenAIModel } from '@futdevpro/fsm-dynamo/open-ai';
 
+export class DyNTS_OAI_Chunk extends DyFM_Metadata {
+  /** Path to the page where the chunk is located ending with the page name */
+  filePathParents: string[] = [];
+  /** Headers that are parents of the chunk */
+  chunkHeadParents: string[] = [];
 
+  /** 
+   * All parents of the chunk, flagged, from the highest level to the lowest local level
+   * like: System:FDP, Project:Organizer, Side:Backend, Module:Chat, etc. 
+   * */
+  allFlaggedParents: string[] = [];
+  /** 
+   * All parents of the chunk, flagged, merged into a with '/' as separator
+   * */
+  allFlaggedParentsMerged: string;
+  
+  documentName: string;
+  pageName: string;
+  pageLink: string;
+  /** Index of the chunk in the page */
+  chunkIndex: number;
 
-export class DyNTS_OAI_DocChunk extends DyFM_Metadata {
-  workspaceId?: string;
-  documentId?: string;
-  documentPageId?: string;
-  mainDocumentName?: string;
-  documentName?: string;
-  documentPath?: string[];
+  chunkOriginalContent: string;
 
-  chunkIndex?: number;
-  /** parent headers */
-  chunkPath?: string[];
-
-  chunkOriginalContent?: string;
-
-  chunkParentedContent?: string;
-  chunkParentedContentVectorized?: number[] = [];
+  chunkParentedContent: string;
+  chunkParentedContentVectorized?: number[];
 
   constructor(
-    set?: DyNTS_OAI_DocChunk,
+    set: DyNTS_OAI_Chunk
   ) {
     super(set);
-
-    if (set) {
-      Object.assign(this, set);
-    }
+ 
+    Object.assign(this, set);
   }
 }
 
-export const DyNTS_OAI_docChunk_dataParams = new DyFM_DataModel_Params<DyNTS_OAI_DocChunk>({
-  dataName: 'oai_doc_chunk',
-  properties: {
-    workspaceId: { 
-      type: 'string', index: true,
-      required: true, 
-    },
-    documentId: { 
-      type: 'string', index: true,
-      required: true, 
-    },
-    documentPageId: { 
-      type: 'string', index: true,
-      required: true, 
-    },
-    mainDocumentName: { 
-      type: 'string',
-      required: true, 
-    },
-    documentName: { 
-      type: 'string',
-      required: true, 
-    },
-    documentPath: { 
-      type: 'string[]',
-      required: true, 
-    },
+export const chunk_propertyParams: DyFM_DataProperties<DyNTS_OAI_Chunk> = {
+  filePathParents: {
+    type: 'string[]', 
+    required: true,
+  },
+  chunkHeadParents: {
+    type: 'string[]', 
+    required: true,
+  },
+
+  allFlaggedParents: {
+    type: 'string[]', 
+    required: true,
+  },
+  allFlaggedParentsMerged: {
+    type: 'string', index: true,
+    required: true,
+  },
 
-    chunkIndex: { 
-      type: 'number', index: true,
-      required: true, 
-    },
-    chunkPath: { 
-      type: 'string[]',
-      required: true, 
-    },
+  documentName: {
+    type: 'string', index: true,
+    required: true,
+  },
+  pageName: {
+    type: 'string', index: true,
+    required: true,
+  },
+  pageLink: {
+    type: 'string', index: true,
+    required: true,
+  },
+  chunkIndex: {
+    type: 'number', index: true,
+    required: true,
+  },
 
-    chunkOriginalContent: { 
-      type: 'string',
-      required: true,
-    },
+  chunkOriginalContent: {
+    type: 'string',
+    required: true,
+  },
 
-    chunkParentedContent: { 
-      type: 'string', index: true,
-      required: true,
-    },
-    chunkParentedContentVectorized: { 
-      type: 'number[]', 
-      required: true, index: true,
-      embeddingModel: DyFM_OpenAIModel.textEmbedding_3Large,
-      vectorizedFrom: 'chunkParentedContent',
-      vectorizeUseIndex: 'chunkParentedContentVectorized',
-      vectorizeAlways: true,
-    },
+  chunkParentedContent: {
+    type: 'string', // index: true,
+    required: true,
+  },
+  chunkParentedContentVectorized: {
+    type: 'number[]',
+    required: true,
+    embeddingModel: DyFM_OpenAIModel.textEmbedding_3Large,
+    vectorizedFrom: [ 'chunkParentedContent' ],
+    vectorizeUseIndex: 'chunkParentedContentVectorized',
+    vectorizeAlways: true,
   },
+}
+
+export const DyNTS_OAI_defaultChunk_dataParams: DyFM_DataModel_Params<DyNTS_OAI_Chunk> = new DyFM_DataModel_Params<DyNTS_OAI_Chunk>({
+  dataName: 'doc_chunk',
+  properties: chunk_propertyParams,
 });