@drax/ai-back 0.13.0

package/dist/config/OpenAiConfig.js

@@ -0,0 +1,7 @@
+var OpenAiConfig;
+(function (OpenAiConfig) {
+    OpenAiConfig["OpenAiApiKey"] = "OPENAI_API_KEY";
+    OpenAiConfig["OpenAiModel"] = "OPENAI_MODEL";
+})(OpenAiConfig || (OpenAiConfig = {}));
+export default OpenAiConfig;
+export { OpenAiConfig };

package/dist/factory/AiProviderFactory.js

@@ -0,0 +1,17 @@
+import OpenAiProviderFactory from "./OpenAiProviderFactory.js";
+class AiProviderFactory {
+    static instance(provider) {
+        if (!AiProviderFactory.singleton) {
+            switch (provider) {
+                case 'OpenAi':
+                    AiProviderFactory.singleton = OpenAiProviderFactory.instance();
+                    break;
+                default:
+                    throw new Error(`Unsupported AI provider: ${provider}`);
+            }
+        }
+        return AiProviderFactory.singleton;
+    }
+}
+export default AiProviderFactory;
+export { AiProviderFactory };

package/dist/factory/OpenAiProviderFactory.js

@@ -0,0 +1,13 @@
+import { DraxConfig } from "@drax/common-back";
+import OpenAiConfig from "../config/OpenAiConfig.js";
+import OpenAiProvider from "../providers/OpenAiProvider.js";
+class OpenAiProviderFactory {
+    static instance() {
+        if (!OpenAiProviderFactory.singleton) {
+            OpenAiProviderFactory.singleton = new OpenAiProvider(DraxConfig.getOrLoad(OpenAiConfig.OpenAiApiKey), DraxConfig.getOrLoad(OpenAiConfig.OpenAiModel));
+        }
+        return OpenAiProviderFactory.singleton;
+    }
+}
+export default OpenAiProviderFactory;
+export { OpenAiProviderFactory };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { OpenAiConfig } from "./config/OpenAiConfig.js";
+import { OpenAiProviderFactory } from "./factory/OpenAiProviderFactory.js";
+import { OpenAiProvider } from "./providers/OpenAiProvider.js";
+import { KnowledgeService } from "./services/KnowledgeService.js";
+export { OpenAiConfig, OpenAiProviderFactory, OpenAiProvider, KnowledgeService };

package/dist/interfaces/IAIProvider.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/OpenAiProvider.js

@@ -0,0 +1,75 @@
+import OpenAI from "openai";
+import { zodResponseFormat } from "openai/helpers/zod";
+class OpenAiProvider {
+    constructor(apiKey, model) {
+        if (!apiKey) {
+            throw new Error("OpenAI apiKey required");
+        }
+        if (!model) {
+            throw new Error("OpenAI model required");
+        }
+        this._apiKey = apiKey;
+        this._model = model;
+    }
+    get model() {
+        if (!this._model) {
+            throw new Error("OpenAI model not found");
+        }
+        return this._model;
+    }
+    get client() {
+        if (!this._client) {
+            this._client = new OpenAI({
+                apiKey: this._apiKey,
+            });
+        }
+        return this._client;
+    }
+    async generateEmbedding({ text, model = "text-embedding-ada-002" }) {
+        const response = await this.client.embeddings.create({
+            model: model,
+            input: text,
+        });
+        return response.data[0].embedding;
+    }
+    async prompt(input) {
+        if (!input.systemPrompt) {
+            throw new Error("systemPrompt required");
+        }
+        const model = input.model ?? this.model;
+        let systemPrompt = input.systemPrompt;
+        if (input.memory && input.memory.length > 0) {
+            systemPrompt += `\n\n ${input.memoryHeader ?? '[MEMORIA]'}\n ${input.memory.map(m => `${m.key}: ${m.value}`).join('\n')}`;
+        }
+        if (input.knowledgeBase && input.knowledgeBase.length > 0) {
+            systemPrompt += `\n\n${input.knowledgeBaseHeader ?? '[BASE DE CONOCIMIENTO]'}\n ${input.knowledgeBase.join('\n')}`;
+        }
+        let userInput = input.userInput;
+        const startTime = performance.now();
+        const chatCompletion = await this.client.chat.completions.create({
+            messages: [
+                { role: 'system', content: systemPrompt },
+                ...(input.history ? input.history : []),
+                { role: 'user', content: userInput },
+            ],
+            ...(input.zodSchema ? { response_format: zodResponseFormat(input.zodSchema, "event") } : {}),
+            ...(input.jsonSchema ? { response_format: input.jsonSchema } : {}),
+            model: model,
+        });
+        const output = chatCompletion.choices[0].message.content;
+        const tokens = chatCompletion.usage.total_tokens;
+        const inputTokens = chatCompletion.usage.prompt_tokens;
+        const outputTokens = chatCompletion.usage.completion_tokens;
+        const endTime = performance.now();
+        const time = endTime - startTime;
+        return {
+            output,
+            tokens,
+            inputTokens,
+            outputTokens,
+            time
+        };
+    }
+}
+export default OpenAiProvider;
+export { OpenAiProvider };

package/dist/services/KnowledgeService.js

@@ -0,0 +1,52 @@
+import fs from 'fs/promises';
+import { getTextExtractor } from 'office-text-extractor';
+import { JSDOM } from 'jsdom';
+class KnowledgeService {
+    async getFromTxt(filePath) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return this.sanitizeText(content);
+    }
+    async getFromPdf(path, type = 'url') {
+        const extractor = getTextExtractor();
+        const text = await extractor.extractText({ input: path, type: type });
+        return this.sanitizeText(text);
+    }
+    async getFromUrl(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const html = await response.text();
+        const dom = new JSDOM(html);
+        const content = dom.window.document.body.textContent || '';
+        return this.sanitizeText(content);
+    }
+    sanitizeText(text) {
+        // Normalización
+        text = text.toLowerCase();
+        // Limpieza ligera (solo espacios largos)
+        text = text.replace(/\s+/g, " ").trim();
+        return text;
+    }
+    chunkTextBySentence(text, chunkSize = 512) {
+        const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
+        const chunks = [];
+        let currentChunk = '';
+        for (const sentence of sentences) {
+            const potentialChunk = currentChunk + ' ' + sentence;
+            if (potentialChunk.length > chunkSize && currentChunk !== '') {
+                chunks.push(currentChunk.trim());
+                currentChunk = sentence;
+            }
+            else {
+                currentChunk = potentialChunk;
+            }
+        }
+        if (currentChunk) {
+            chunks.push(currentChunk.trim());
+        }
+        return chunks;
+    }
+}
+export default KnowledgeService;
+export { KnowledgeService };

package/dist/vectors/ChromaVector.js

@@ -0,0 +1,65 @@
+import { ChromaClient } from 'chromadb';
+class ChromaVector {
+    constructor(path = 'http://localhost:8000', database) {
+        this.client = new ChromaClient({ path, database });
+        this.collections = new Map();
+    }
+    async initializeCollection(collectionName) {
+        if (!this.collections.has(collectionName)) {
+            const collection = await this.client.createCollection({
+                name: collectionName,
+                // embeddingFunction: embeddingFunction
+            });
+            this.collections.set(collectionName, collection);
+        }
+    }
+    async addDocument(collectionName, document) {
+        await this.initializeCollection(collectionName);
+        const collection = this.collections.get(collectionName);
+        if (collection) {
+            await collection.add({
+                ids: [document.id],
+                documents: [document.content],
+                metadatas: [document.metadata || {}],
+                embeddings: document.embedding ? [document.embedding] : undefined, // Add this line
+            });
+        }
+        else {
+            throw new Error(`Collection ${collectionName} not found`);
+        }
+    }
+    async queryCollection(collectionName, query, topK = 5) {
+        await this.initializeCollection(collectionName);
+        const collection = this.collections.get(collectionName);
+        if (collection) {
+            const results = await collection.query({
+                queryTexts: [query],
+                nResults: topK,
+            });
+            return results.documents[0] || [];
+        }
+        else {
+            throw new Error(`Collection ${collectionName} not found`);
+        }
+    }
+    async deleteDocument(collectionName, documentId) {
+        const collection = this.collections.get(collectionName);
+        if (collection) {
+            await collection.delete({
+                ids: [documentId],
+            });
+        }
+        else {
+            throw new Error(`Collection ${collectionName} not found`);
+        }
+    }
+    async listCollections() {
+        return await this.client.listCollections();
+    }
+    async deleteCollection(collectionName) {
+        await this.client.deleteCollection({ name: collectionName });
+        this.collections.delete(collectionName);
+    }
+}
+export default ChromaVector;
+export { ChromaVector };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@drax/ai-back",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.13.0",
+  "description": "Ai utils",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "prepublish": "tsc",
+    "tscrun": "tsc",
+    "clean": "rm -rf dist",
+    "tsc": "tsc -b tsconfig.json",
+    "test": "vitest test/**"
+  },
+  "author": "Cristian Incarnato & Drax Team",
+  "license": "ISC",
+  "peerDependencies": {
+    "chromadb": "^2.2.0",
+    "jsdom": "^26.0.0",
+    "office-text-extractor": "^3.0.3",
+    "openai": "^4.72.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.10",
+    "chromadb": "^2.2.0",
+    "jsdom": "^26.0.0",
+    "office-text-extractor": "^3.0.3",
+    "openai": "^4.72.0",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.10",
+    "typescript": "^5.6.2",
+    "vitest": "^3.0.8"
+  },
+  "gitHead": "ff7df3bb96303a056ad2e1ee70dc9dfa4a43ef9e"
+}

package/src/config/OpenAiConfig.ts

@@ -0,0 +1,12 @@
+
+enum OpenAiConfig {
+
+    OpenAiApiKey = "OPENAI_API_KEY",
+    OpenAiModel = "OPENAI_MODEL",
+
+}
+
+
+export default OpenAiConfig;
+
+export {OpenAiConfig}

package/src/factory/AiProviderFactory.ts

@@ -0,0 +1,25 @@
+import type {IAIProvider} from "../interfaces/IAIProvider"
+import OpenAiProviderFactory from "./OpenAiProviderFactory.js";
+
+class AiProviderFactory {
+    private static singleton: IAIProvider;
+
+    public static instance(provider: string): IAIProvider {
+        if (!AiProviderFactory.singleton) {
+            switch (provider) {
+                case 'OpenAi':
+                    AiProviderFactory.singleton =  OpenAiProviderFactory.instance()
+                    break;
+                default:
+                    throw new Error(`Unsupported AI provider: ${provider}`);
+            }
+        }
+        return AiProviderFactory.singleton;
+    }
+}
+
+export default AiProviderFactory
+export {
+    AiProviderFactory
+}
+

package/src/factory/OpenAiProviderFactory.ts

@@ -0,0 +1,24 @@
+import {DraxConfig} from "@drax/common-back";
+import OpenAiConfig from "../config/OpenAiConfig.js";
+import type {IAIProvider} from "../interfaces/IAIProvider"
+import OpenAiProvider from "../providers/OpenAiProvider.js";
+
+class OpenAiProviderFactory {
+    private static singleton: IAIProvider;
+
+    public static instance(): IAIProvider {
+        if (!OpenAiProviderFactory.singleton) {
+            OpenAiProviderFactory.singleton = new OpenAiProvider(
+                DraxConfig.getOrLoad(OpenAiConfig.OpenAiApiKey),
+                DraxConfig.getOrLoad(OpenAiConfig.OpenAiModel)
+            );
+        }
+        return OpenAiProviderFactory.singleton;
+    }
+}
+
+export default OpenAiProviderFactory
+export {
+    OpenAiProviderFactory
+}
+

package/src/index.ts

@@ -0,0 +1,20 @@
+import {OpenAiConfig} from "./config/OpenAiConfig.js";
+import {OpenAiProviderFactory} from "./factory/OpenAiProviderFactory.js";
+import {OpenAiProvider} from "./providers/OpenAiProvider.js";
+import {KnowledgeService} from "./services/KnowledgeService.js";
+import type {IAIProvider, IPromptResponse, IPromptParams, IPromptMessage, IPromptMemory} from "./interfaces/IAIProvider.js";
+
+export type {
+    IAIProvider,
+    IPromptParams,
+    IPromptMessage,
+    IPromptMemory,
+    IPromptResponse,
+}
+
+export {
+    OpenAiConfig,
+    OpenAiProviderFactory,
+    OpenAiProvider,
+    KnowledgeService
+}

package/src/interfaces/IAIProvider.ts

@@ -0,0 +1,41 @@
+import { ZodSchema } from 'zod'
+
+type Role = 'user' | 'assistant' | 'system';
+
+interface IPromptMessage {
+    role: Role;
+    content: string;
+}
+
+interface IPromptMemory {
+    key: string;
+    value: string;
+}
+
+
+interface IPromptParams {
+    systemPrompt: string,
+    userInput?: string,
+    history?: IPromptMessage[],
+    memory?: IPromptMemory[],
+    memoryHeader?: string | '[MEMORY]' | '[MEMORIA]'
+    knowledgeBase?: string[],
+    knowledgeBaseHeader?: string | '[KNOWLEDGE BASE]' | '[BASE DE CONOCIMIENTO]',
+    zodSchema?: ZodSchema<any>,
+    jsonSchema?: object,
+    model?: string,
+}
+
+interface IPromptResponse {
+    output: any,
+    tokens: number,
+    inputTokens: number,
+    outputTokens: number,
+    time: number
+}
+
+interface IAIProvider {
+    prompt(input: IPromptParams): Promise<IPromptResponse>
+}
+
+export type {IAIProvider, IPromptParams, IPromptResponse, IPromptMessage, IPromptMemory}

package/src/providers/OpenAiProvider.ts

@@ -0,0 +1,106 @@
+import OpenAI from "openai";
+import type {ZodTypeAny} from "zod"
+import { zodResponseFormat } from "openai/helpers/zod";
+import type {IAIProvider, IPromptParams, IPromptResponse} from "../interfaces/IAIProvider";
+
+class OpenAiProvider implements IAIProvider{
+    protected _apiKey: string
+    protected _model: any
+    protected _client: any
+
+    constructor(apiKey: string, model: string) {
+
+        if (!apiKey) {
+            throw new Error("OpenAI apiKey required")
+        }
+        if (!model) {
+            throw new Error("OpenAI model required")
+        }
+
+        this._apiKey = apiKey
+        this._model = model
+    }
+
+    get model(){
+        if(!this._model){
+            throw new Error("OpenAI model not found")
+        }
+        return this._model;
+    }
+
+    get client(){
+        if(!this._client){
+            this._client = new OpenAI({
+                apiKey: this._apiKey,
+            });
+        }
+
+        return this._client
+    }
+
+    async generateEmbedding({text, model="text-embedding-ada-002"}: {text:string,model:string }): Promise<number[]> {
+        const response = await this.client.embeddings.create({
+            model: model,
+            input: text,
+        });
+        return response.data[0].embedding;
+    }
+
+    async prompt(input: IPromptParams): Promise<IPromptResponse> {
+
+        if(!input.systemPrompt){
+            throw new Error("systemPrompt required")
+        }
+
+        const model = input.model ?? this.model
+
+        let systemPrompt = input.systemPrompt
+
+        if(input.memory && input.memory.length > 0){
+            systemPrompt += `\n\n ${input.memoryHeader ?? '[MEMORIA]'}\n ${input.memory.map(m => `${m.key}: ${m.value}`).join('\n')}`
+        }
+
+        if(input.knowledgeBase && input.knowledgeBase.length > 0){
+            systemPrompt += `\n\n${input.knowledgeBaseHeader ?? '[BASE DE CONOCIMIENTO]'}\n ${input.knowledgeBase.join('\n')}`
+        }
+
+
+        let userInput = input.userInput
+
+        const startTime = performance.now()
+
+        const chatCompletion = await this.client.chat.completions.create({
+            messages: [
+                {role: 'system', content: systemPrompt},
+                ...(input.history ? input.history : []),
+                {role: 'user', content: userInput},
+            ],
+
+            ...(input.zodSchema ? {response_format: zodResponseFormat(input.zodSchema, "event")} : {}),
+            ...(input.jsonSchema ? {response_format: input.jsonSchema} : {}),
+            model: model,
+        });
+
+
+        const output = chatCompletion.choices[0].message.content
+        const tokens = chatCompletion.usage.total_tokens
+        const inputTokens = chatCompletion.usage.prompt_tokens
+        const outputTokens = chatCompletion.usage.completion_tokens
+
+        const endTime = performance.now()
+        const time = endTime - startTime
+
+        return {
+            output,
+            tokens,
+            inputTokens,
+            outputTokens,
+            time
+        }
+    }
+
+}
+
+
+export default OpenAiProvider
+export {OpenAiProvider}

package/src/services/KnowledgeService.ts

@@ -0,0 +1,66 @@
+import fs from 'fs/promises';
+import {getTextExtractor} from 'office-text-extractor'
+import {JSDOM} from 'jsdom';
+
+class KnowledgeService {
+
+
+    async getFromTxt(filePath: string): Promise<string> {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return this.sanitizeText(content);
+    }
+
+    async getFromPdf(path: string, type: 'url'|'file' = 'url'): Promise<string> {
+        const extractor = getTextExtractor()
+        const text = await extractor.extractText({input: path, type: type});
+        return this.sanitizeText(text);
+    }
+
+    async getFromUrl(url: string): Promise<string> {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const html = await response.text();
+        const dom = new JSDOM(html);
+        const content = dom.window.document.body.textContent || '';
+        return this.sanitizeText(content);
+    }
+
+
+      sanitizeText(text: string): string {
+        // Normalización
+        text = text.toLowerCase();
+
+        // Limpieza ligera (solo espacios largos)
+        text = text.replace(/\s+/g, " ").trim();
+
+        return text
+    }
+
+
+    chunkTextBySentence(text: string, chunkSize: number = 512): string[] {
+        const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
+        const chunks: string[] = [];
+        let currentChunk = '';
+
+        for (const sentence of sentences) {
+            const potentialChunk = currentChunk + ' ' + sentence;
+            if (potentialChunk.length > chunkSize && currentChunk !== '') {
+                chunks.push(currentChunk.trim());
+                currentChunk = sentence;
+            } else {
+                currentChunk = potentialChunk;
+            }
+        }
+
+        if (currentChunk) {
+            chunks.push(currentChunk.trim());
+        }
+
+        return chunks;
+    }
+}
+
+export default KnowledgeService;
+export {KnowledgeService}

package/src/vectors/ChromaVector.ts

@@ -0,0 +1,80 @@
+import {ChromaClient, Collection, Document} from 'chromadb';
+
+interface VectorDocument {
+  id: string;
+  content: string;
+  metadata?: Record<string, any>;
+  embedding?: number[];  // Add this line
+}
+
+class ChromaVector {
+  private client: ChromaClient;
+  private collections: Map<string, Collection>;
+
+  constructor(path: string = 'http://localhost:8000', database ?: string) {
+    this.client = new ChromaClient({path, database});
+    this.collections = new Map();
+  }
+
+  async initializeCollection(collectionName: string): Promise<void> {
+    if (!this.collections.has(collectionName)) {
+      const collection = await this.client.createCollection({
+        name: collectionName,
+        // embeddingFunction: embeddingFunction
+      });
+      this.collections.set(collectionName, collection);
+    }
+  }
+
+  async addDocument(collectionName: string, document: VectorDocument): Promise<void> {
+    await this.initializeCollection(collectionName);
+    const collection = this.collections.get(collectionName);
+    if (collection) {
+      await collection.add({
+        ids: [document.id],
+        documents: [document.content],
+        metadatas: [document.metadata || {}],
+        embeddings: document.embedding ? [document.embedding] : undefined,  // Add this line
+      });
+    } else {
+      throw new Error(`Collection ${collectionName} not found`);
+    }
+  }
+
+  async queryCollection(collectionName: string, query: string, topK: number = 5): Promise<Document[]> {
+    await this.initializeCollection(collectionName);
+    const collection = this.collections.get(collectionName);
+    if (collection) {
+      const results = await collection.query({
+        queryTexts: [query],
+        nResults: topK,
+      });
+      return results.documents[0] || [];
+    } else {
+      throw new Error(`Collection ${collectionName} not found`);
+    }
+  }
+
+  async deleteDocument(collectionName: string, documentId: string): Promise<void> {
+    const collection = this.collections.get(collectionName);
+    if (collection) {
+      await collection.delete({
+        ids: [documentId],
+      });
+    } else {
+      throw new Error(`Collection ${collectionName} not found`);
+    }
+  }
+
+  async listCollections(): Promise<string[]> {
+    return await this.client.listCollections();
+  }
+
+  async deleteCollection(collectionName: string): Promise<void> {
+    await this.client.deleteCollection({ name: collectionName });
+    this.collections.delete(collectionName);
+  }
+}
+
+export default ChromaVector;
+export {ChromaVector}