agenticaichat 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -1,7 +1,20 @@
 export { ChatbotWidget } from './widget';
-export type { ChatbotWidgetProps } from './widget/ChatbotWidget';
-export { DatabaseConnector } from './core/DatabaseConnector';
-export { NLToSQLConverter } from './core/NLToSQLConverter';
 export { ChatbotEngine } from './core/ChatbotEngine';
-export type { DatabaseType, DatabaseConfig, DatabaseSchema, TableSchema, ColumnSchema, OpenAIConfig, ChatMessage, QueryRequest, QueryResponse, ChatbotConfig } from './types';
+export { EngineFactory } from './core/EngineFactory';
+export { DatabaseEngine } from './engines/base/DatabaseEngine';
+export { SqlEngine } from './engines/sql/SqlEngine';
+export { NoSqlEngine } from './engines/nosql/NoSqlEngine';
+export { PostgresDialect } from './engines/sql/dialects/PostgresDialect';
+export { MySQLDialect } from './engines/sql/dialects/MySQLDialect';
+export { SQLiteDialect } from './engines/sql/dialects/SQLiteDialect';
+export { MongoEngine } from './engines/nosql/MongoEngine';
+export { LLMFactory } from './llm/LLMFactory';
+export type { ILLMProvider } from './llm/types';
+export { OpenAIProvider } from './llm/providers/OpenAIProvider';
+export { GeminiProvider } from './llm/providers/GeminiProvider';
+export { ClaudeProvider } from './llm/providers/ClaudeProvider';
+export { GrokProvider } from './llm/providers/GrokProvider';
+export { TogetherAIProvider } from './llm/providers/TogetherAIProvider';
+export { DeepInfraProvider } from './llm/providers/DeepInfraProvider';
+export type { DatabaseCategory, SqlDatabaseType, NoSqlDatabaseType, SupportedDatabaseType, DatabaseConfig, DatabaseSchema, TableSchema, ColumnSchema, LLMConfig, LLMProviderType, ChatMessage, QueryRequest, QueryResponse, QueryResult, EngineStatus, ChatbotConfig } from './types';
 export { Logger, logger } from './utils/logger';

package/dist/index.js

@@ -1,17 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = exports.Logger = exports.ChatbotEngine = exports.NLToSQLConverter = exports.DatabaseConnector = exports.ChatbotWidget = void 0;
-// Client-side exports (safe for browser)
+exports.logger = exports.Logger = exports.DeepInfraProvider = exports.TogetherAIProvider = exports.GrokProvider = exports.ClaudeProvider = exports.GeminiProvider = exports.OpenAIProvider = exports.LLMFactory = exports.MongoEngine = exports.SQLiteDialect = exports.MySQLDialect = exports.PostgresDialect = exports.NoSqlEngine = exports.SqlEngine = exports.DatabaseEngine = exports.EngineFactory = exports.ChatbotEngine = exports.ChatbotWidget = void 0;
+// ============================================
+// CLIENT-SIDE EXPORTS (Safe for browser)
+// ============================================
 var widget_1 = require("./widget");
 Object.defineProperty(exports, "ChatbotWidget", { enumerable: true, get: function () { return widget_1.ChatbotWidget; } });
-// Server-side exports (Node.js only)
-// These should only be imported in API routes or server components
-var DatabaseConnector_1 = require("./core/DatabaseConnector");
-Object.defineProperty(exports, "DatabaseConnector", { enumerable: true, get: function () { return DatabaseConnector_1.DatabaseConnector; } });
-var NLToSQLConverter_1 = require("./core/NLToSQLConverter");
-Object.defineProperty(exports, "NLToSQLConverter", { enumerable: true, get: function () { return NLToSQLConverter_1.NLToSQLConverter; } });
+// ============================================
+// SERVER-SIDE EXPORTS (Node.js only)
+// ============================================
+// Note: Import these ONLY in API routes or server components
+// Core classes
 var ChatbotEngine_1 = require("./core/ChatbotEngine");
 Object.defineProperty(exports, "ChatbotEngine", { enumerable: true, get: function () { return ChatbotEngine_1.ChatbotEngine; } });
+var EngineFactory_1 = require("./core/EngineFactory");
+Object.defineProperty(exports, "EngineFactory", { enumerable: true, get: function () { return EngineFactory_1.EngineFactory; } });
+// Engines
+var DatabaseEngine_1 = require("./engines/base/DatabaseEngine");
+Object.defineProperty(exports, "DatabaseEngine", { enumerable: true, get: function () { return DatabaseEngine_1.DatabaseEngine; } });
+var SqlEngine_1 = require("./engines/sql/SqlEngine");
+Object.defineProperty(exports, "SqlEngine", { enumerable: true, get: function () { return SqlEngine_1.SqlEngine; } });
+var NoSqlEngine_1 = require("./engines/nosql/NoSqlEngine");
+Object.defineProperty(exports, "NoSqlEngine", { enumerable: true, get: function () { return NoSqlEngine_1.NoSqlEngine; } });
+// SQL dialects
+var PostgresDialect_1 = require("./engines/sql/dialects/PostgresDialect");
+Object.defineProperty(exports, "PostgresDialect", { enumerable: true, get: function () { return PostgresDialect_1.PostgresDialect; } });
+var MySQLDialect_1 = require("./engines/sql/dialects/MySQLDialect");
+Object.defineProperty(exports, "MySQLDialect", { enumerable: true, get: function () { return MySQLDialect_1.MySQLDialect; } });
+var SQLiteDialect_1 = require("./engines/sql/dialects/SQLiteDialect");
+Object.defineProperty(exports, "SQLiteDialect", { enumerable: true, get: function () { return SQLiteDialect_1.SQLiteDialect; } });
+// NoSQL engines
+var MongoEngine_1 = require("./engines/nosql/MongoEngine");
+Object.defineProperty(exports, "MongoEngine", { enumerable: true, get: function () { return MongoEngine_1.MongoEngine; } });
+// LLM classes
+var LLMFactory_1 = require("./llm/LLMFactory");
+Object.defineProperty(exports, "LLMFactory", { enumerable: true, get: function () { return LLMFactory_1.LLMFactory; } });
+// LLM providers
+var OpenAIProvider_1 = require("./llm/providers/OpenAIProvider");
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return OpenAIProvider_1.OpenAIProvider; } });
+var GeminiProvider_1 = require("./llm/providers/GeminiProvider");
+Object.defineProperty(exports, "GeminiProvider", { enumerable: true, get: function () { return GeminiProvider_1.GeminiProvider; } });
+var ClaudeProvider_1 = require("./llm/providers/ClaudeProvider");
+Object.defineProperty(exports, "ClaudeProvider", { enumerable: true, get: function () { return ClaudeProvider_1.ClaudeProvider; } });
+var GrokProvider_1 = require("./llm/providers/GrokProvider");
+Object.defineProperty(exports, "GrokProvider", { enumerable: true, get: function () { return GrokProvider_1.GrokProvider; } });
+var TogetherAIProvider_1 = require("./llm/providers/TogetherAIProvider");
+Object.defineProperty(exports, "TogetherAIProvider", { enumerable: true, get: function () { return TogetherAIProvider_1.TogetherAIProvider; } });
+var DeepInfraProvider_1 = require("./llm/providers/DeepInfraProvider");
+Object.defineProperty(exports, "DeepInfraProvider", { enumerable: true, get: function () { return DeepInfraProvider_1.DeepInfraProvider; } });
 // Utils
 var logger_1 = require("./utils/logger");
 Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });

package/dist/llm/LLMFactory.d.ts

@@ -0,0 +1,25 @@
+import { ILLMProvider } from './types';
+import { LLMConfig } from '../types';
+export declare class LLMFactory {
+    /**
+     * Create appropriate LLM provider based on config
+     */
+    static createProvider(config: LLMConfig): ILLMProvider;
+    /**
+     * Get list of supported providers with metadata
+     */
+    static getSupportedProviders(): {
+        name: string;
+        value: string;
+        description: string;
+        models: string[];
+        website: string;
+    }[];
+    /**
+     * Validate provider configuration
+     */
+    static validateConfig(config: LLMConfig): {
+        valid: boolean;
+        error?: string;
+    };
+}

package/dist/llm/LLMFactory.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMFactory = void 0;
+const OpenAIProvider_1 = require("./providers/OpenAIProvider");
+const GeminiProvider_1 = require("./providers/GeminiProvider");
+const ClaudeProvider_1 = require("./providers/ClaudeProvider");
+const GrokProvider_1 = require("./providers/GrokProvider");
+const TogetherAIProvider_1 = require("./providers/TogetherAIProvider");
+const DeepInfraProvider_1 = require("./providers/DeepInfraProvider");
+// import { GroqProvider } from './providers/GroqProvider';
+const logger_1 = require("../utils/logger");
+class LLMFactory {
+    /**
+     * Create appropriate LLM provider based on config
+     */
+    static createProvider(config) {
+        logger_1.logger.info(`Creating LLM provider: ${config.provider}`);
+        const providerConfig = {
+            apiKey: config.apiKey,
+            model: config.model
+        };
+        switch (config.provider) {
+            case 'openai':
+                return new OpenAIProvider_1.OpenAIProvider(providerConfig);
+            case 'gemini':
+                return new GeminiProvider_1.GeminiProvider(providerConfig);
+            case 'claude':
+                return new ClaudeProvider_1.ClaudeProvider(providerConfig);
+            case 'grok':
+                return new GrokProvider_1.GrokProvider(providerConfig);
+            case 'together':
+                return new TogetherAIProvider_1.TogetherAIProvider(providerConfig);
+            case 'deepinfra':
+                return new DeepInfraProvider_1.DeepInfraProvider(providerConfig);
+            // case 'groq':
+            //   return new GroqProvider(providerConfig);
+            default:
+                throw new Error(`Unsupported LLM provider: ${config.provider}`);
+        }
+    }
+    /**
+     * Get list of supported providers with metadata
+     */
+    static getSupportedProviders() {
+        return [
+            {
+                name: 'OpenAI (GPT-3.5/GPT-4)',
+                value: 'openai',
+                description: 'Most popular, reliable, high quality',
+                models: ['gpt-3.5-turbo', 'gpt-4', 'gpt-4-turbo'],
+                website: 'https://platform.openai.com'
+            },
+            {
+                name: 'Google Gemini (1.5 Pro/Flash)',
+                value: 'gemini',
+                description: 'Fast, affordable, multimodal support',
+                models: ['gemini-1.5-pro', 'gemini-1.5-flash'],
+                website: 'https://ai.google.dev'
+            },
+            {
+                name: 'Anthropic Claude (Sonnet/Opus/Haiku)',
+                value: 'claude',
+                description: 'Best reasoning, longest context window',
+                models: [
+                    'claude-3-sonnet-20240229',
+                    'claude-3-opus-20240229',
+                    'claude-3-haiku-20240307'
+                ],
+                website: 'https://www.anthropic.com'
+            },
+            {
+                name: 'xAI Grok',
+                value: 'grok',
+                description: 'Real-time data, Twitter integration',
+                models: ['grok-beta'],
+                website: 'https://x.ai'
+            },
+            {
+                name: 'Together AI',
+                value: 'together',
+                description: 'Open-source models, cost-effective',
+                models: [
+                    'mistralai/Mixtral-8x7B-Instruct-v0.1',
+                    'meta-llama/Llama-3-70b-chat-hf'
+                ],
+                website: 'https://www.together.ai'
+            },
+            {
+                name: 'DeepInfra',
+                value: 'deepinfra',
+                description: 'Multiple models, serverless infrastructure',
+                models: [
+                    'meta-llama/Meta-Llama-3-70B-Instruct',
+                    'mistralai/Mixtral-8x7B-Instruct-v0.1'
+                ],
+                website: 'https://deepinfra.com'
+            },
+            {
+                name: 'Groq',
+                value: 'groq',
+                description: 'Ultra-fast inference, hardware acceleration',
+                models: ['llama3-70b-8192', 'mixtral-8x7b-32768'],
+                website: 'https://groq.com'
+            }
+        ];
+    }
+    /**
+     * Validate provider configuration
+     */
+    static validateConfig(config) {
+        // Check provider is supported
+        const supportedProviders = this.getSupportedProviders();
+        const providerExists = supportedProviders.some(p => p.value === config.provider);
+        if (!providerExists) {
+            return {
+                valid: false,
+                error: `Unsupported provider: ${config.provider}. Supported: ${supportedProviders.map(p => p.value).join(', ')}`
+            };
+        }
+        // Check API key
+        if (!config.apiKey || config.apiKey.trim() === '') {
+            return {
+                valid: false,
+                error: 'API key is required'
+            };
+        }
+        // Check model
+        if (!config.model || config.model.trim() === '') {
+            return {
+                valid: false,
+                error: 'Model name is required'
+            };
+        }
+        return { valid: true };
+    }
+}
+exports.LLMFactory = LLMFactory;

package/dist/llm/providers/ClaudeProvider.d.ts

@@ -0,0 +1,13 @@
+import { ILLMProvider, ClaudeProviderConfig } from '../types';
+import { DatabaseSchema } from '../../types';
+export declare class ClaudeProvider implements ILLMProvider {
+    private client;
+    private model;
+    private configured;
+    constructor(config: ClaudeProviderConfig);
+    isConfigured(): boolean;
+    generateSQL(userQuery: string, schema: DatabaseSchema): Promise<string>;
+    generateHumanResponse(userQuery: string, queryResult: any): Promise<string>;
+    private buildSQLPrompt;
+    private formatSchema;
+}

package/dist/llm/providers/ClaudeProvider.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeProvider = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const logger_1 = require("../../utils/logger");
+class ClaudeProvider {
+    constructor(config) {
+        this.configured = false;
+        if (!config.apiKey) {
+            logger_1.logger.error('Claude API key is required');
+            return;
+        }
+        this.client = new sdk_1.default({
+            apiKey: config.apiKey
+        });
+        this.model = config.model || 'claude-3-sonnet-20240229';
+        this.configured = true;
+        logger_1.logger.info(`Claude Provider initialized with model: ${this.model}`);
+    }
+    isConfigured() {
+        return this.configured;
+    }
+    async generateSQL(userQuery, schema) {
+        if (!this.configured) {
+            throw new Error('Claude Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating SQL with Claude...');
+            const schemaDescription = this.formatSchema(schema);
+            const prompt = this.buildSQLPrompt(userQuery, schemaDescription);
+            const message = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 500,
+                temperature: 0.2,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                system: 'You are an expert SQL query generator. Generate ONLY valid SQL queries without any explanation or markdown.'
+            });
+            const sqlQuery = message.content[0].type === 'text'
+                ? message.content[0].text.trim()
+                : '';
+            // Remove markdown code blocks
+            const cleanedSQL = sqlQuery
+                .replace(/```sql\n?/g, '')
+                .replace(/```\n?/g, '')
+                .trim();
+            logger_1.logger.debug_log('Generated SQL:', cleanedSQL);
+            return cleanedSQL;
+        }
+        catch (error) {
+            logger_1.logger.error('Claude SQL generation failed', error);
+            throw error;
+        }
+    }
+    async generateHumanResponse(userQuery, queryResult) {
+        if (!this.configured) {
+            throw new Error('Claude Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating human response with Claude...');
+            const prompt = `
+User asked: "${userQuery}"
+
+Database returned this result:
+${JSON.stringify(queryResult, null, 2)}
+
+Please provide a clear, conversational answer in Hindi/English mix (Hinglish) that explains this data to a business owner. Be specific with numbers.
+`;
+            const message = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 300,
+                temperature: 0.7,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                system: 'You are a helpful business analytics assistant. Explain data clearly in Hinglish (Hindi-English mix).'
+            });
+            const answer = message.content[0].type === 'text'
+                ? message.content[0].text.trim()
+                : 'Sorry, I could not generate a response.';
+            logger_1.logger.debug_log('Generated response:', answer);
+            return answer;
+        }
+        catch (error) {
+            logger_1.logger.error('Claude response generation failed', error);
+            throw error;
+        }
+    }
+    buildSQLPrompt(userQuery, schemaDescription) {
+        return `
+You are a SQL expert. Generate a SQL query based on the user's question.
+
+Database Schema:
+${schemaDescription}
+
+User Question: "${userQuery}"
+
+Rules:
+1. Return ONLY the SQL query, nothing else
+2. Use correct table and column names from the schema
+3. Add WHERE clauses for date filtering when needed
+4. Use SUM, COUNT, AVG for aggregations
+5. Handle both singular and plural forms
+6. Use CURRENT_DATE for time-based queries
+7. Make sure the query is syntactically correct
+
+SQL Query:
+`;
+    }
+    formatSchema(schema) {
+        let description = '';
+        for (const table of schema.tables) {
+            description += `\nTable: ${table.name}\n`;
+            description += 'Columns:\n';
+            for (const column of table.columns) {
+                description += `  - ${column.name} (${column.type})${column.nullable ? ' [nullable]' : ''}\n`;
+            }
+        }
+        return description;
+    }
+}
+exports.ClaudeProvider = ClaudeProvider;

package/dist/llm/providers/DeepInfraProvider.d.ts

@@ -0,0 +1,14 @@
+import { ILLMProvider, DeepInfraProviderConfig } from '../types';
+import { DatabaseSchema } from '../../types';
+export declare class DeepInfraProvider implements ILLMProvider {
+    private apiKey;
+    private model;
+    private configured;
+    private baseURL;
+    constructor(config: DeepInfraProviderConfig);
+    isConfigured(): boolean;
+    generateSQL(userQuery: string, schema: DatabaseSchema): Promise<string>;
+    generateHumanResponse(userQuery: string, queryResult: any): Promise<string>;
+    private buildSQLPrompt;
+    private formatSchema;
+}

package/dist/llm/providers/DeepInfraProvider.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepInfraProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../utils/logger");
+class DeepInfraProvider {
+    constructor(config) {
+        this.configured = false;
+        this.baseURL = 'https://api.deepinfra.com/v1/openai';
+        if (!config.apiKey) {
+            logger_1.logger.error('DeepInfra API key is required');
+            return;
+        }
+        this.apiKey = config.apiKey;
+        this.model = config.model || 'meta-llama/Meta-Llama-3-70B-Instruct';
+        this.configured = true;
+        logger_1.logger.info(`DeepInfra Provider initialized with model: ${this.model}`);
+    }
+    isConfigured() {
+        return this.configured;
+    }
+    async generateSQL(userQuery, schema) {
+        if (!this.configured) {
+            throw new Error('DeepInfra Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating SQL with DeepInfra...');
+            const schemaDescription = this.formatSchema(schema);
+            const prompt = this.buildSQLPrompt(userQuery, schemaDescription);
+            const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, {
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are an expert SQL query generator. Generate ONLY valid SQL queries without any explanation or markdown.'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                temperature: 0.2,
+                max_tokens: 500
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            const sqlQuery = response.data.choices[0]?.message?.content?.trim() || '';
+            // Remove markdown code blocks
+            const cleanedSQL = sqlQuery
+                .replace(/```sql\n?/g, '')
+                .replace(/```\n?/g, '')
+                .trim();
+            logger_1.logger.debug_log('Generated SQL:', cleanedSQL);
+            return cleanedSQL;
+        }
+        catch (error) {
+            logger_1.logger.error('DeepInfra SQL generation failed', error);
+            throw error;
+        }
+    }
+    async generateHumanResponse(userQuery, queryResult) {
+        if (!this.configured) {
+            throw new Error('DeepInfra Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating human response with DeepInfra...');
+            const prompt = `
+User asked: "${userQuery}"
+
+Database returned this result:
+${JSON.stringify(queryResult, null, 2)}
+
+Please provide a clear, conversational answer in Hindi/English mix (Hinglish) that explains this data to a business owner. Be specific with numbers.
+`;
+            const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, {
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are a helpful business analytics assistant. Explain data clearly in Hinglish (Hindi-English mix).'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                temperature: 0.7,
+                max_tokens: 300
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            const answer = response.data.choices[0]?.message?.content?.trim() ||
+                'Sorry, I could not generate a response.';
+            logger_1.logger.debug_log('Generated response:', answer);
+            return answer;
+        }
+        catch (error) {
+            logger_1.logger.error('DeepInfra response generation failed', error);
+            throw error;
+        }
+    }
+    buildSQLPrompt(userQuery, schemaDescription) {
+        return `
+You are a SQL expert. Generate a SQL query based on the user's question.
+
+Database Schema:
+${schemaDescription}
+
+User Question: "${userQuery}"
+
+Rules:
+1. Return ONLY the SQL query, nothing else
+2. Use correct table and column names from the schema
+3. Add WHERE clauses for date filtering when needed
+4. Use SUM, COUNT, AVG for aggregations
+5. Handle both singular and plural forms
+6. Use CURRENT_DATE for time-based queries
+7. Make sure the query is syntactically correct
+
+SQL Query:
+`;
+    }
+    formatSchema(schema) {
+        let description = '';
+        for (const table of schema.tables) {
+            description += `\nTable: ${table.name}\n`;
+            description += 'Columns:\n';
+            for (const column of table.columns) {
+                description += `  - ${column.name} (${column.type})${column.nullable ? ' [nullable]' : ''}\n`;
+            }
+        }
+        return description;
+    }
+}
+exports.DeepInfraProvider = DeepInfraProvider;

package/dist/llm/providers/GeminiProvider.d.ts

@@ -0,0 +1,13 @@
+import { ILLMProvider, GeminiProviderConfig } from '../types';
+import { DatabaseSchema } from '../../types';
+export declare class GeminiProvider implements ILLMProvider {
+    private client;
+    private model;
+    private configured;
+    constructor(config: GeminiProviderConfig);
+    isConfigured(): boolean;
+    generateSQL(userQuery: string, schema: DatabaseSchema): Promise<string>;
+    generateHumanResponse(userQuery: string, queryResult: any): Promise<string>;
+    private buildSQLPrompt;
+    private formatSchema;
+}