@futdevpro/nts-dynamo 1.10.23 → 1.10.24

package/src/_modules/open-ai/_services/gpt.service-base.ts

@@ -0,0 +1,440 @@
+
+import { OpenAI, ClientOptions } from 'openai';
+import { ChatCompletion, ChatCompletionMessageParam } from 'openai/resources';
+
+import { DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_OpenAIModel } from '../_enums/open-ai-model.enum';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_OpenAI_ServiceBase } from './open-ai.service-base';
+import { DyNTS_GPTCall_Settings } from '../_models/gpt-call-settings.interface';
+import { RequestOptions } from 'openai/core';
+import { ChatCompletionCreateParamsBase } from 'openai/resources/chat/completions';
+
+/**
+ * {
+    organization: 'org-XY',
+    apiKey: 'sk-XY',
+    project: 'proj_XY',
+  }
+ */
+
+// Di Dictionary DiModel DiEz DiAz
+
+export class DyNTS_GPT_ServiceBase extends DyNTS_OpenAI_ServiceBase {
+
+  defaultLogReplacer: string = '...';
+  
+  async askYesNoQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<boolean> {
+    question += ' (Only answer with "Yes" or "No")';
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    return answer.toUpperCase().includes('YES');
+  }
+
+  async askSimpleQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<string> {
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    return await this.getQuestionAnswer(question, issuer);
+  }
+
+  async askPercentageQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<number> {
+    question += ' (Only answer with a number between 0 and 1, e.g.: 0.65)';
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    if (isNaN(+answer)) {
+      DyFM_Log.error('GPT_ServiceBase', 'asykPercentageQuestion', 'Invalid answer', {
+        question,
+        answer,
+      });
+
+      return null;
+    }
+
+    return +answer;
+  }
+
+  async askSelectQuestion(
+    question: string, 
+    selectFrom: string[], 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<string> {
+    question += ` (Only answer with one of the following: ${this.getListAsText(selectFrom)})`;
+    
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    let answer = await this.getQuestionAnswer(question, issuer);
+    
+    answer = answer.toLocaleUpperCase();
+    
+    for (const item of selectFrom) {
+      if (answer.includes(item.toLocaleUpperCase())) return item;
+    }
+
+    return null;
+  }
+
+  async askMultipleSelectQuestionWithOptions(
+    question: string, 
+    options: string[], 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<string[]> {
+    question += (` (You can choose one or more of the following: ${this.getListAsText(options)})`);
+    
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    let answer = await this.getQuestionAnswer(question, issuer);
+    
+    answer = answer.toLocaleUpperCase();
+    
+    const result: string[] = [];
+
+    for (const item of options) {
+      if (answer.includes(item.toLocaleUpperCase())) {
+        result.push(item);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Azt kérjük tőle, hogy adjon egy JSON formában választ.
+   * Amit aztán megpróbálunk JSON.parse-olni.
+   * Ha nem sikerül, akkor { unparsable: answer }-t adunk vissza.
+   */
+  async askJSONQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<any> {
+    question += ' (The answer must be in JSON format)';
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+    
+    try {
+      // replace all ```json, ```, \n
+      return JSON.parse(
+        answer.replaceAll('```json', '').replaceAll('```', '').replaceAll('\n', '')
+      );
+    } catch (error) {
+      return {
+        unparsable: answer,
+      };
+    }
+  }
+
+  /**
+   * Azt kérjük tőle, hogy adjon egy JSON formában választ.
+   * Amit aztán megpróbálunk JSON.parse-olni.
+   * Ha nem sikerül, akkor { unparsable: answer }-t adunk vissza.
+   * 
+   * A keysDescription-be leírjuk, milyen kulcsokat várunk. (nem konkrét kulcsneveket)
+   */
+  async askJSONQuestionWithKeysDescription(
+    question: string, 
+    keysDescription: string,
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<any> {
+    question += ` (The answer must be in JSON format, ${keysDescription})`;
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    try {
+      // replace all ```json, ```, \n
+      return JSON.parse(
+        answer.replaceAll('```json', '').replaceAll('```', '').replaceAll('\n', '')
+      );
+    } catch (error) {
+      return {
+        unparsable: answer,
+      };
+    }
+  }
+
+  /**
+   * Azt kérjük tőle, hogy adjon egy JSON formában választ.
+   * Amit aztán megpróbálunk JSON.parse-olni.
+   * Ha nem sikerül, akkor { unparsable: answer }-t adunk vissza.
+   * 
+   * A keys-be leírjuk a konkrét kulcsneveket.
+   */
+  async askJSONQuestionWithExactKeys(
+    question: string, 
+    keys: string[],
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<any> {
+    question += ` (The answer must be in JSON format, ` +
+      `where the keys are: ${this.getListAsText(keys)})`;
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    try {
+      // replace all ```json, ```, \n
+      return JSON.parse(
+        answer.replaceAll('```json', '').replaceAll('```', '').replaceAll('\n', '')
+      );
+    } catch (error) {
+      return {
+        unparsable: answer,
+      };
+    }
+  }
+
+  async askListQuestion(
+    question: string, 
+    issuer: string,
+    replaceThisInLog?: string
+  ): Promise<string[]> {
+    question += ' (The answer must be in JSON format, a list of strings)';
+
+    this.logQuestion(question, issuer, replaceThisInLog);
+
+    const answer = await this.getQuestionAnswer(question, issuer);
+
+    try {
+      const parsed = JSON.parse(
+        answer.replaceAll('```json', '').replaceAll('```', '').replaceAll('\n', '')
+      );
+
+      if (Array.isArray(parsed)) {
+        return parsed;
+      } else if (typeof parsed === 'object') {
+        return Object.values(parsed);
+      } else {
+        DyFM_Log.error('GPT_ServiceBase', 'askListQuestion', 'Invalid answer', {
+          question,
+          answer,
+        });
+
+        return [ parsed ];
+      }
+    } catch (error) {
+      return answer.split('\n').filter(item => item);
+    }
+  }
+
+  private logQuestion(question: string, issuer: string, replaceThisInLog?: string): void {
+    if (this.debugLog) {
+      if (replaceThisInLog) {
+        question = question.replace(replaceThisInLog, this.defaultLogReplacer);
+      }
+
+      console.log('\n - ', question);
+    }
+  }
+
+  /**
+   * This function will log the answer if the debugLog is true
+   */
+  async getQuestionAnswer(
+    question: string, 
+    issuer: string,
+    messageSettings: DyNTS_GPTCall_Settings = this.defaultSettings
+  ): Promise<string> {
+    const answer = await this.resolveSimpleUserMessage(question, issuer, messageSettings);
+
+    console.log(' - ', answer);
+
+    return answer;
+  }
+
+  /**
+   * olvasható mondatszerű-listaszerű formába teszi a listaelemeket
+   * pl.: ['a', 'b', 'c'] -> '"a", "b" or "c"'
+   */
+  getListAsText(list: string[]): string {
+    list = list.filter(item => item?.trim()).map(item => `"${item}"`);
+
+    /* list = list.map(item => item.toLocaleLowerCase()); */
+
+    list.push(list.pop() + ' or ' + list.pop());
+
+    return list.join(', ');
+  }
+  
+  /**
+   * This function will log the question and the answer if the debugLog is true
+   */
+  async getAnswer(
+    question: string, 
+    issuer: string,
+    settings?: DyNTS_GPTCall_Settings
+  ): Promise<string> {
+    if (this.debugLog) {
+      console.log('\n - ', question);
+    }
+
+    const answer = await this.resolveSimpleUserMessage(question, issuer, settings);
+
+    if (this.debugLog) {
+      console.log(' - ', answer);
+    }
+
+    return answer;
+  }
+
+  async resolveSimpleUserMessage(
+    message: string,
+    issuer: string,
+    settings?: DyNTS_GPTCall_Settings
+  ): Promise<string> {
+    return this.resolveConversation(
+      [{ role: 'user', content: message }], 
+      issuer,
+      settings, 
+      false
+    ) as Promise<string>;
+  }
+
+  async resolveConversation(
+    conversation: DyNTS_GPT_Message[],
+    issuer: string,
+    settings?: DyNTS_GPTCall_Settings,
+    getFullResponse?: boolean
+  ): Promise<string | ChatCompletion> {
+    try {
+      const result: ChatCompletion = await this.openai.chat.completions.create(
+        this.getMessageCreateInput(conversation, issuer, settings)
+      ) as ChatCompletion;
+
+      if (getFullResponse) {
+        return result;
+      }
+
+      return result.choices[0].message.content;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('resolveConversation', error, issuer),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-OAB-RC0`,
+      });
+    }
+  }
+
+  /**
+   * TODO: Overview this: maybe it should use each setting from default if not provided here
+   */
+  private getMessageCreateInput(
+    messages: DyNTS_GPT_Message[],
+    issuer: string,
+    settings: DyNTS_GPTCall_Settings = this.defaultSettings
+  ): ChatCompletionCreateParamsBase {
+    try {
+      messages.unshift(this.getDefaultSystemMessage(settings));
+
+      const result: ChatCompletionCreateParamsBase = {
+        model: settings.useModel ?? this.defaultModel,
+        messages: messages as ChatCompletionMessageParam[],
+      };
+
+      if (DyFM_notNull(settings.temperature)) {
+        result.temperature = settings.temperature;
+      }
+      
+      if (DyFM_notNull(settings.maxTokens)) {
+        result.max_tokens = settings.maxTokens;
+      }
+
+      if (DyFM_notNull(settings.topP)) {
+        result.top_p = settings.topP;
+      }
+
+      if (DyFM_notNull(settings.frequencyPenalty)) {
+        result.frequency_penalty = settings.frequencyPenalty;
+      }
+
+      if (DyFM_notNull(settings.presencePenalty)) {
+        result.presence_penalty = settings.presencePenalty;
+      }
+
+      return result;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('getMessageCreateSettings', error, issuer),
+        
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-OAB-RC0`,
+      });
+    }
+  }
+
+  private getDefaultSystemMessage(settings: DyNTS_GPTCall_Settings): DyNTS_GPT_Message {
+    return {
+      role: DyNTS_GPT_Message_Role.system,
+      content: settings.systemPrompt || this.defaultSystemPrompt,
+    };
+  }
+}
+
+export interface DyNTS_GPT_Message {
+  role: DyNTS_GPT_Message_Role | string;
+  content: string;
+}
+
+export enum DyNTS_GPT_Message_Role {
+  /**
+   * Developer-provided instructions that the model should follow, regardless of
+   * messages sent by the user. With o1 models and newer, `developer` messages
+   * replace the previous `system` messages.
+   */
+  developer = 'developer',
+  
+  /**
+   * Developer-provided instructions that the model should follow, regardless of
+   * messages sent by the user. With o1 models and newer, use `developer` messages
+   * for this purpose instead.
+   */
+  system = 'system',
+  
+  /**
+   * Messages sent by an end user, containing prompts or additional context
+   * information.
+   */
+  user = 'user',
+  
+  /**
+   * Messages sent by the model in response to user messages.
+   */
+  assistant = 'assistant',
+
+  /** ??? */
+  tool = 'tool',
+  
+  /**
+   * ???
+   * @deprecated
+   */
+  function = 'function',
+}
+
+export function DyFM_notNull(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/src/_modules/open-ai/_services/open-ai.service-base.ts

@@ -0,0 +1,73 @@
+
+import { OpenAI, ClientOptions } from 'openai';
+import { ChatCompletion, ChatCompletionMessageParam } from 'openai/resources';
+
+import { DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_OpenAIModel } from '../_enums/open-ai-model.enum';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_OpenAI_Settings } from '../_models/open-ai-settings.interface';
+import { DyNTS_GPTCall_Settings } from '../_models/gpt-call-settings.interface';
+
+
+/**
+ * {
+ *   organization: 'org-XY',
+ *   apiKey: 'sk-XY',
+ *   project: 'proj_XY',
+ * }
+ */
+
+// Di Dictionary DiModel DiEz DiAz
+
+export class DyNTS_OpenAI_ServiceBase {
+    
+  readonly defaultErrorUserMsg: string = 
+    `We encountered an unhandled Control Service Error, ` +
+    `\nplease contact the responsible development team.`; 
+
+  readonly openai: OpenAI;
+
+  /* readonly defaultSystemPrompt: string;
+  readonly defaultModel: DyNTS_OpenAIModel | string; */
+  readonly defaultSettings: DyNTS_GPTCall_Settings;
+
+  get debugLog(): boolean {
+    return this.defaultSettings.debugLog;
+  }
+
+  get defaultSystemPrompt(): string {
+    return this.defaultSettings.systemPrompt;
+  }
+
+  get defaultModel(): DyNTS_OpenAIModel | string {
+    return this.defaultSettings.useModel;
+  }
+
+  constructor(
+    set: DyNTS_OpenAI_Settings
+  ) {
+    this.openai = new OpenAI(set.openAIConfig);
+    this.defaultSettings = set.defaultSettings ?? new DyNTS_GPTCall_Settings();
+  }
+  
+  protected getDefaultErrorSettings(
+    fnName: string, 
+    error: DyFM_AnyError,
+    issuer: string
+  ): DyFM_Error_Settings {
+    return {
+      status: (error as DyFM_Error)?.___status ?? 500,
+      message: (error as Error)?.message ??
+        (error as DyFM_Error)?._message ??
+        `${fnName} was UNSUCCESSFUL (${DyNTS_global_settings.systemShortCodeName})`,
+      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
+      userMessage: (error as DyFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
+      issuer: issuer,
+      issuerService: this.constructor?.name,
+      error: error,
+    };
+  }
+}
+
+

package/src/_modules/open-ai/index.ts

@@ -0,0 +1,13 @@
+
+
+export * from './_enums/open-ai-model.enum';
+
+export * from './_models/gpt-call-settings.interface';
+export * from './_models/open-ai-api-env-settings.interface';
+export * from './_models/open-ai-settings.interface';
+
+export * from './_services/embedding.control-service';
+export * from './_services/gpt.service-base';
+export * from './_services/open-ai.service-base';
+
+

package/src/_services/base/db.service.ts

@@ -1028,6 +1028,47 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
       });
   }
 
+  /**
+   * {
+      "mappings": {
+        "dynamic": true,
+        "fields": {
+          "embedding": {
+            "type": "knnVector",
+            "dimensions": 768
+          }
+        }
+      }
+    }
+   */
+  /**
+   * 
+   * @param set db.collection.aggregate([
+      {
+        $vectorSearch: {
+          index: "index_neve",
+          queryVector: [a keresett embedding],
+          path: "title.embedding",
+          numCandidates: 100,
+          limit: 5
+        }
+      },
+      {
+        $vectorSearch: {
+          index: "index_neve",
+          queryVector: [a keresett embedding],
+          path: "description.embedding",
+          numCandidates: 100,
+          limit: 5
+        }
+      }
+    ]);
+   * @returns 
+   */
+  async aggregate(set: any) {
+    return this.dataModel.aggregate(set);
+  }
+
   // ----------------------------------------------------------------------------------
   // ----------------------------------------------------------------------------------
   // ----------------------------------------------------------------------------------

package/src/_services/server/app.server.ts

@@ -42,6 +42,24 @@ import { DyNTS_SingletonService } from '../base/singleton.service';
 import { DyNTS_GlobalService } from '../core/global.service';
 import { DyNTS_RoutingModule } from '../route/routing-module.service';
 
+/**
+ * 
+  * function MyDecorator(config: any) {
+      return function (target: Function) {
+        // attach metadata or modify target
+        target.prototype.myMeta = config;
+      };
+    }
+
+    @MyDecorator({ role: 'admin' })
+    class User {
+      printRole() {
+        console.log((this as any).myMeta.role); // → "admin"
+      }
+    }
+
+ */
+
 /**
  * This will be the MAIN service of our server project,
  * follow the types and type instructions while setting up your project