@memori.ai/memori-api-client 0.2.0 → 0.3.0

package/src/engine/customDictionary.ts

@@ -0,0 +1,85 @@
+import { ResponseSpec, CustomWord } from '../types';
+import { apiFetcher } from '../apiFetcher';
+
+/****************************
+ *                          *
+ *     CustomDictionary     *
+ *                          *
+ ****************************/
+
+export default (apiUrl: string) => ({
+  /**
+   * Lists all Custom Words.
+   * @param {string} sessionId The session ID
+   */
+  getCustomWords: async (sessionId: string) =>
+    apiFetcher(`/CustomWords/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        customWords: CustomWord[];
+      }
+    >,
+
+  /**
+   * Gets the details of a Custom Word object.
+   * @param {string} sessionId The session ID
+   * @param {string} customWordID The Custom Word object ID
+   */
+  getCustomWord: async (sessionId: string, customWordID: string) =>
+    apiFetcher(`/CustomWord/${sessionId}/${customWordID}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        customWord: CustomWord;
+      }
+    >,
+
+  /**
+   * Removes an existing Custom Word object.
+   * @param {string} sessionId The session ID
+   * @param {string} key The key of the Custom Word
+   */
+  deleteCustomWord: async (sessionId: string, key: string) =>
+    apiFetcher(`/CustomWord/${sessionId}/${key}`, {
+      method: 'DELETE',
+      apiUrl,
+    }) as Promise<ResponseSpec>,
+
+  /**
+   * Adds a new Custom Word object.
+   * @param {string} sessionId The session ID
+   * @param {CustomWord} customWord Custom Word
+   */
+  postCustomWord: async (
+    sessionId: string,
+    customWord: Pick<CustomWord, 'word'> & Pick<CustomWord, 'definition'>
+  ) =>
+    apiFetcher(`/CustomWord/${sessionId}`, {
+      method: 'POST',
+      apiUrl,
+      body: customWord,
+    }) as Promise<
+      ResponseSpec & {
+        customWord: CustomWord;
+      }
+    >,
+
+  /**
+   * Updates an existing Custom Word object.
+   * Only the Definition field is considered for update. To change the Word field a new Custom Word must be added and the existing must be removed.
+   * @param {string} sessionId The session ID
+   * @param {CustomWord} customWord Custom Word
+   */
+  patchCustomWord: async (
+    sessionId: string,
+    customWord: Partial<CustomWord> & { customWordID: string }
+  ) =>
+    apiFetcher(`/CustomWord/${sessionId}/${customWord.customWordID}`, {
+      method: 'PATCH',
+      apiUrl,
+      body: customWord,
+    }) as Promise<ResponseSpec>,
+});

package/src/engine/dialog.ts

@@ -130,7 +130,7 @@ export default (apiUrl: string) => ({
    * Submits a Date Selected event to the session's Dialog State Machine.
    * @param {string} sessionId The session ID
    */
-  postDateSelectedEvent: async ({ sessionId }: { sessionId: string }) =>
+  postDateSelectedEvent: async (sessionId: string) =>
     apiFetcher(`/DateSelectedEvent/${sessionId}`, {
       method: 'GET',
       apiUrl,
@@ -140,7 +140,7 @@ export default (apiUrl: string) => ({
    * Submits a Place Selected event to the session's Dialog State Machine.
    * @param {string} sessionId The session ID
    */
-  postPlaceSelectedEvent: async ({ sessionId }: { sessionId: string }) =>
+  postPlaceSelectedEvent: async (sessionId: string) =>
     apiFetcher(`/PlaceSelectedEvent/${sessionId}`, {
       method: 'GET',
       apiUrl,
@@ -150,7 +150,7 @@ export default (apiUrl: string) => ({
    * Submits a Tag Selected event to the session's Dialog State Machine.
    * @param {string} sessionId The session ID
    */
-  postTagSelectedEvent: async ({ sessionId }: { sessionId: string }) =>
+  postTagSelectedEvent: async (sessionId: string) =>
     apiFetcher(`/TagSelectedEvent/${sessionId}`, {
       method: 'GET',
       apiUrl,

package/src/engine/importExport.ts

@@ -1,24 +1,42 @@
 import { ResponseSpec } from '../types';
 import { apiFetcher } from '../apiFetcher';
 
-export interface ImportExportBody {
-  csvRows: string[];
+export interface ImportCSVParams {
+  includedRows?: number[];
+  hasHeaders?: boolean;
+  headerNames?: string[];
+  forceImport?: boolean;
   questionColumnName: string;
   answerColumnName: string;
-  propertyColumnNames: string[];
-  includedRows: number[];
-  csvSeparator: string;
-  questionTitleVariantsSeparator: string;
-  hasHeaders: boolean;
-  forceImport: boolean;
-  headerNames: string[];
+  contextVarsToMatchColumnName?: string;
+  contextVarsToSetColumnName?: string;
+  csvSeparator?: string;
+  questionTitleVariantsSeparator?: string;
 }
 
-export interface ImportExportReponse {
+export interface ExportCSVParams {
+  newLine: '\n' | '\r\n';
+  hasHeaders?: boolean;
+  questionColumnName: string;
+  answerColumnName: string;
+  contextVarsToMatchColumnName?: string;
+  contextVarsToSetColumnName?: string;
+  csvSeparator?: string;
+  questionTitleVariantsSeparator?: string;
+}
+
+export interface ImportReponse {
   importID: string;
-  importedMemories: number;
+  importedMemories?: number;
   importWarnings?: {
-    warningType: string;
+    warningType: 'Existing Similar Memory' | 'Internal Error';
+    rowNumber?: number;
+    csvRow: string;
+    text?: string;
+    similarTexts?: {
+      text: string;
+      similarityLevel: 'HIGH' | 'MEDIUM' | 'LOW';
+    }[];
   }[];
 }
 
@@ -32,12 +50,34 @@ export default (apiUrl: string) => ({
   /**
    * Imports memories from a CSV file.
    * @param {string} sessionId The session ID
-   * @param {ImportExportBody} csvData The CSV content info to import
+   * @param {string[]} csvRows Rows of the CSV file.
+   * @param {ImportCSVParams} params The specifications and content of the CSV file
    */
-  postImportExport: async (sessionId: string, csvData: ImportExportBody) =>
+  importCSV: async (
+    sessionId: string,
+    csvRows: string[],
+    params: ImportCSVParams
+  ) =>
     apiFetcher(`/ImportExport/ImportCSV/${sessionId}`, {
       method: 'POST',
       apiUrl,
-      body: csvData,
-    }) as Promise<ResponseSpec & ImportExportReponse>,
+      body: {
+        csvRows,
+        ...params,
+      },
+    }) as Promise<ResponseSpec & ImportReponse>,
+
+  /**
+   * Exports memories to a CSV file.
+   * @param {string} sessionID The session ID
+   * @param {ExportCSVParams} params - The specifications of the CSV file
+   * @returns The CSV file content
+   */
+  exportCSV: async (sessionID: string, params: ExportCSVParams) =>
+    apiFetcher(`/ImportExport/ExportCSV/${sessionID}`, {
+      method: 'POST',
+      apiUrl,
+      body: params,
+      text: true,
+    }) as Promise<string>,
 });

package/src/engine/intents.ts

@@ -1,4 +1,4 @@
-import { ResponseSpec } from '../types';
+import { ResponseSpec, Intent, IntentSlot } from '../types';
 import { apiFetcher } from '../apiFetcher';
 
 /*******************
@@ -16,7 +16,11 @@ export default (apiUrl: string) => ({
     apiFetcher(`/Intents/${sessionId}`, {
       method: 'GET',
       apiUrl,
-    }) as Promise<ResponseSpec>,
+    }) as Promise<
+      ResponseSpec & {
+        intents: (Intent & { intentID: string })[];
+      }
+    >,
 
   /**
    * Gets the details of an Intent object.
@@ -27,17 +31,25 @@ export default (apiUrl: string) => ({
     apiFetcher(`/Intent/${sessionId}/${intentId}`, {
       method: 'GET',
       apiUrl,
-    }) as Promise<ResponseSpec>,
+    }) as Promise<
+      ResponseSpec & {
+        intent: Intent & { intentID: string };
+      }
+    >,
 
   /**
    * Updates an existing Intent object.
    * @param {string} sessionId The session ID
-   * @param {string} intentId The Intent object ID
+   * @param {Intent} intent The Intent object
    */
-  patchIntent: async (sessionId: string, intentId: string) =>
-    apiFetcher(`/Intent/${sessionId}/${intentId}`, {
-      method: 'GET',
+  patchIntent: async (
+    sessionId: string,
+    intent: Partial<Intent> & { intentID: string }
+  ) =>
+    apiFetcher(`/Intent/${sessionId}/${intent.intentID}`, {
+      method: 'PATCH',
       apiUrl,
+      body: intent,
     }) as Promise<ResponseSpec>,
 
   /**
@@ -47,19 +59,25 @@ export default (apiUrl: string) => ({
    */
   deleteIntent: async (sessionId: string, intentId: string) =>
     apiFetcher(`/Intent/${sessionId}/${intentId}`, {
-      method: 'GET',
+      method: 'DELETE',
       apiUrl,
     }) as Promise<ResponseSpec>,
 
   /**
    * Adds a new Intent object.
    * @param {string} sessionId The session ID
+   * @param {Intent} intent The Intent object
    */
-  postIntent: async (sessionId: string) =>
+  createIntent: async (sessionId: string, intent: Intent) =>
     apiFetcher(`/Intent/${sessionId}`, {
-      method: 'GET',
+      method: 'POST',
       apiUrl,
-    }) as Promise<ResponseSpec>,
+      body: intent,
+    }) as Promise<
+      ResponseSpec & {
+        intentID: string;
+      }
+    >,
 
   /**
    * Lists all Intent Slot objects.
@@ -69,7 +87,13 @@ export default (apiUrl: string) => ({
     apiFetcher(`/IntentSlots/${sessionId}`, {
       method: 'GET',
       apiUrl,
-    }) as Promise<ResponseSpec>,
+    }) as Promise<
+      ResponseSpec & {
+        intentSlots: (IntentSlot & {
+          intentSlotID: string;
+        })[];
+      }
+    >,
 
   /**
    * Gets the details of an Intent Slot object.
@@ -80,17 +104,25 @@ export default (apiUrl: string) => ({
     apiFetcher(`/IntentSlot/${sessionId}/${slotId}`, {
       method: 'GET',
       apiUrl,
-    }) as Promise<ResponseSpec>,
+    }) as Promise<
+      ResponseSpec & {
+        intentSlot: IntentSlot & { intentSlotID: string };
+      }
+    >,
 
   /**
    * Updates an existing Intent Slot object.
    * @param {string} sessionId The session ID
-   * @param {string} slotId The Intent Slot object ID
+   * @param {IntentSlot} intentSlot The Intent Slot object
    */
-  patchIntentSlot: async (sessionId: string, slotId: string) =>
-    apiFetcher(`/IntentSlot/${sessionId}/${slotId}`, {
-      method: 'GET',
+  patchIntentSlot: async (
+    sessionId: string,
+    intentSlot: Partial<IntentSlot> & { intentSlotID: string }
+  ) =>
+    apiFetcher(`/IntentSlot/${sessionId}/${intentSlot.intentSlotID}`, {
+      method: 'PATCH',
       apiUrl,
+      body: intentSlot,
     }) as Promise<ResponseSpec>,
 
   /**
@@ -100,7 +132,7 @@ export default (apiUrl: string) => ({
    */
   deleteIntentSlot: async (sessionId: string, slotId: string) =>
     apiFetcher(`/IntentSlot/${sessionId}/${slotId}`, {
-      method: 'GET',
+      method: 'DELETE',
       apiUrl,
     }) as Promise<ResponseSpec>,
 
@@ -108,9 +140,14 @@ export default (apiUrl: string) => ({
    * Adds a new Intent Slot object.
    * @param {string} sessionId The session ID
    */
-  postIntentSlot: async (sessionId: string) =>
+  createIntentSlot: async (sessionId: string, intentSlot: IntentSlot) =>
     apiFetcher(`/IntentSlot/${sessionId}`, {
-      method: 'GET',
+      method: 'POST',
       apiUrl,
-    }) as Promise<ResponseSpec>,
+      body: intentSlot,
+    }) as Promise<
+      ResponseSpec & {
+        intentSlotID: string;
+      }
+    >,
 });

package/src/engine/nlp.ts

@@ -17,7 +17,26 @@ export default (apiUrl: string) => ({
     apiFetcher(`/WordVector/${sessionId}/${word}`, {
       method: 'GET',
       apiUrl,
-    }) as Promise<ResponseSpec>,
+    }) as Promise<
+      ResponseSpec & {
+        vector: number[];
+      }
+    >,
+
+  /**
+   * Searches for the 10 words most semantically similar words to the specified word.
+   * @param {string} sessionId The session ID
+   * @param {string} word Word to be looked up
+   */
+  getSimilarWords: async (sessionId: string, word: string) =>
+    apiFetcher(`/SimilarWords/${sessionId}/${word}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        similarWords: string[];
+      }
+    >,
 
   /**
    * Tries to guess the language of a sentence by analyzing key word occurrences.
@@ -36,4 +55,62 @@ export default (apiUrl: string) => ({
         };
       }
     >,
+
+  /**
+   * Computes the similarity between a reference and a comparison sentences.
+   * @param {string} sessionId The session ID
+   * @param {string} referenceText Text of the reference sentence.
+   * @param {'QUESTION' | 'ANSWER'} referenceTextType Type of reference text, i.e. question or answer. Only types supported are: 'QUESTION' and 'ANSWER'.
+   * @param {string} comparisonText Text of the comparison sentence.
+   * @param {'QUESTION' | 'ANSWER'} comparisonTextType Type of comparison text, i.e. question or answer. Only types supported are: 'QUESTION' and 'ANSWER'.
+   */
+  computeSimilarity: async (
+    sessionId: string,
+    referenceText: string,
+    referenceTextType: 'QUESTION' | 'ANSWER',
+    comparisonText: string,
+    comparisonTextType: 'QUESTION' | 'ANSWER'
+  ) =>
+    apiFetcher(`/ComputeSimilarity/${sessionId}`, {
+      method: 'POST',
+      apiUrl,
+      body: {
+        referenceText,
+        referenceTextType,
+        comparisonText,
+        comparisonTextType,
+      },
+    }) as Promise<
+      ResponseSpec & {
+        /**
+         * Similarity index, between 0.0 (totally different) and 1.0 (identical).
+         */
+        similarity: number;
+        /**
+         * Similarity level, i.e. none, low, medium or high.
+         * Currently supported similarity levels are:
+         * NONE, LOW, MEDIUM, HIGH
+         */
+        similarityLevel: 'NONE' | 'LOW' | 'MEDIUM' | 'HIGH';
+      }
+    >,
+
+  /**
+   * Checks the words of a sentence for their definition in the word vector dictionary.
+   * @param {string} sessionId The session ID
+   * @param {string} text Text of the sentence.
+   */
+  checkWords: async (sessionId: string, text: string) =>
+    apiFetcher(`/CheckWords/${sessionId}`, {
+      method: 'POST',
+      apiUrl,
+      body: { text },
+    }) as Promise<
+      ResponseSpec & {
+        /**
+         * List of words missing from the word vector dictionary.
+         */
+        undefinedWords: string[];
+      }
+    >,
 });

package/src/engine/stats.ts

@@ -1,4 +1,4 @@
-import { ResponseSpec, Stats, EventLog } from '../types';
+import { ResponseSpec, Stats, Memory, EventLog } from '../types';
 import { apiFetcher } from '../apiFetcher';
 
 /*****************
@@ -22,6 +22,72 @@ export default (apiUrl: string) => ({
       }
     >,
 
+  /**
+   * Computes content quality indexes for a Memori.
+   * @param {string} memoriID - The Memori object ID
+   */
+  getContentQualityIndexes: async (memoriID: string) =>
+    apiFetcher(`/ContentQualityIndexes/${memoriID}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        /**
+         * @type {number}
+         * An index of content quality of this Memori. The more content is added (and especially content with media, or stories with dates and places) the more the index grows.
+         */
+        contentQualityIndex: number;
+
+        /**
+         * @type {number}
+         * An index of answer quality of this Memori. It is the ratio of the number of successful answer vs. the total of answers (successful, wrongful or missing).
+         */
+        answerQualityIndex: number;
+
+        /**
+         * @type {number}
+         * The current number of unanswered questions.
+         */
+        unansweredQuestions: number;
+      }
+    >,
+
+  /**
+   * Computes text quality indexes for a Memori.
+   * @param {string} sessionId - The session ID
+   */
+  getTextQualityIndexes: async (sessionId: string) =>
+    apiFetcher(`/TextQualityIndexes/${sessionId}`, {
+      method: 'GET',
+      apiUrl,
+    }) as Promise<
+      ResponseSpec & {
+        /**
+         * @type {number}
+         * An index of text quality of this Memori. It is the ratio of the defined words vs. the total of unique words used in question texts and story titles. A value of 1.0 means that no words are undefined, a value of 0.0 means that all words are undefined. Undefined words in a question text or story title have a profound negative impact on the ability to match them with user input.
+         */
+        textQualityIndex: number;
+
+        /**
+         * @type {string[]}
+         * List of undefined words found in question texts and story titles.
+         */
+        undefinedWords: string[];
+
+        /**
+         * @type {number}
+         * An index of text quality of the content of this Memori. It is the ratio of correct question texts and stories titles vs. the total number of question texts and story titles. A value of 1.0 means that all question texts and story titles are correct, a value of 0.0 means that no question text or story title is correct. A question text or story title is defined incorrect (or "faulty") if it contains 25% or more of undefined words. Undefined words in a question text or story title have a profound negative impact on the ability to match them with user input.
+         */
+        contentTextQualityIndex: number;
+
+        /**
+         * @type {Memory[]}
+         * List of faulty Memory objects (questions and stories). A question or story is defined as "faulty" if it contains at least one undefined word.
+         */
+        faultyMemories?: Memory[];
+      }
+    >,
+
   /**
    * Get the Event Log objects for the Memori of the current session in a specific date interval
    * @param {string} sessionId The session ID
@@ -41,4 +107,54 @@ export default (apiUrl: string) => ({
         eventLogs: EventLog[];
       }
     >,
+
+  /**
+   * Gets the Event Log objects for a specific Memory object in a specific date interval.
+   * @param {string} sessionId - The session ID
+   * @param {string} memoryId - The Memory object ID
+   * @param {string} strDateFrom - The optional begin of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   * @param {string} strDateTo - The optional end of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   */
+  getMemoryEventLogs: async (
+    sessionId: string,
+    memoryId: string,
+    strDateFrom: string,
+    strDateTo: string
+  ) =>
+    apiFetcher(
+      `/EventLogs/${sessionId}/${memoryId}/${strDateFrom}/${strDateTo}`,
+      {
+        method: 'GET',
+        apiUrl,
+      }
+    ) as Promise<
+      ResponseSpec & {
+        eventLogs: EventLog[];
+      }
+    >,
+
+  /**
+   * Gets the Event Log objects for a specific Intent object in a specific date interval.
+   * @param {string} sessionId - The session ID
+   * @param {string} intentId - The Intent object ID
+   * @param {string} strDateFrom - The optional begin of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   * @param {string} strDateTo - The optional end of the date interval, in UTC time, in the format yyyyMMddHHmmssfff
+   */
+  getIntentEventLogs: async (
+    sessionId: string,
+    intentId: string,
+    strDateFrom: string,
+    strDateTo: string
+  ) =>
+    apiFetcher(
+      `/EventLogs/${sessionId}/${intentId}/${strDateFrom}/${strDateTo}`,
+      {
+        method: 'GET',
+        apiUrl,
+      }
+    ) as Promise<
+      ResponseSpec & {
+        eventLogs: EventLog[];
+      }
+    >,
 });

package/src/engine.ts

@@ -13,6 +13,8 @@ import session from './engine/session';
 import stats from './engine/stats';
 import unansweredQuestions from './engine/unansweredQuestions';
 import contextVars from './engine/contextVars';
+import customDictionary from './engine/customDictionary';
+import chatLogs from './engine/chatLogs';
 
 export default (apiUrl: string) => ({
   correlationPairs: correlationPairs(apiUrl),
@@ -45,4 +47,8 @@ export default (apiUrl: string) => ({
   ...unansweredQuestions(apiUrl),
   contextVars: contextVars(apiUrl),
   ...contextVars(apiUrl),
+  customDictionary: customDictionary(apiUrl),
+  ...customDictionary(apiUrl),
+  chatLogs: chatLogs(apiUrl),
+  ...chatLogs(apiUrl),
 });