multimind-sdk/dist/index.js

This SDK gives JavaScript/TypeScript developers full access to advanced AI features like agent orchestration, RAG, and fine-tuning — without needing to manage backend code.

// Bridge exports
export * from './bridge/multimind-bridge.js';
// Core functionality exports
export * from './agent.js';
export * from './fineTune.js';
export * from './rag.js';
export * from './adapters.js';
export * from './evaluation.js';
export * from './models.js';
// Advanced functionality exports (explicit, to avoid type conflicts)
export { advancedFineTune, createAdvancedTuner } from './advancedFineTuning.js';
export { AdvancedRAGClient } from './advancedRAG.js';
export { ModelConverter, pytorchToONNX, tensorflowToTFLite, pytorchToGGUF } from './modelConversion.js';
export { ComplianceMonitor } from './compliance.js';
export { AdvancedAgent, builtInTools } from './advancedAgent.js';
export { LSTMModelClient, MoEModelClient, MultiModalClient, FederatedRouter, createLoadBalancedRouter, createIntelligentRouter } from './modelClientSystem.js';
export { MultiMindGateway, RequestMiddleware, ResponseMiddleware } from './gateway.js';
// Context Transfer exports
export { ContextTransferManager, ContextTransferAPI, quickTransfer, getAllModels, validateConversation } from './contextTransfer.js';
// Main SDK class for easier usage
import { initBridge, closeBridge } from './bridge/multimind-bridge.js';
import { generateWithAgent, createAgent } from './agent.js';
import { fineTuneModel, createFineTuner } from './fineTune.js';
import { queryRAG, createRAGEngine } from './rag.js';
import { loadAdapter, listAdapters, removeAdapter } from './adapters.js';
import { evaluateModel, compareModels } from './evaluation.js';
import { loadModel, routeModel, listAvailableModels } from './models.js';
// Advanced imports
import { advancedFineTune, createAdvancedTuner } from './advancedFineTuning.js';
import { AdvancedRAGClient } from './advancedRAG.js';
import { ModelConverter, pytorchToONNX, tensorflowToTFLite, pytorchToGGUF } from './modelConversion.js';
import { ComplianceMonitor } from './compliance.js';
import { AdvancedAgent, builtInTools } from './advancedAgent.js';
import { LSTMModelClient, MoEModelClient, MultiModalClient, FederatedRouter } from './modelClientSystem.js';
import { MultiMindGateway } from './gateway.js';
// Context Transfer imports
import { ContextTransferManager, ContextTransferAPI, quickTransfer } from './contextTransfer.js';
export class MultiMindSDK {
    constructor() {
        this.initialized = false;
    }
    async initialize() {
        if (!this.initialized) {
            await initBridge();
            this.initialized = true;
        }
    }
    async close() {
        if (this.initialized) {
            await closeBridge();
            this.initialized = false;
        }
    }
    // ===== BASIC FUNCTIONALITY =====
    // Agent methods
    async generateWithAgent(prompt, config = {}) {
        await this.initialize();
        return generateWithAgent(prompt, config);
    }
    async createAgent(config = {}) {
        await this.initialize();
        return createAgent(config);
    }
    // Fine-tuning methods
    async fineTuneModel(config) {
        await this.initialize();
        return fineTuneModel(config);
    }
    async createFineTuner(config) {
        await this.initialize();
        return createFineTuner(config);
    }
    // RAG methods
    async queryRAG(prompt, config) {
        await this.initialize();
        return queryRAG(prompt, config);
    }
    async createRAGEngine(config) {
        await this.initialize();
        return createRAGEngine(config);
    }
    // Adapter methods
    async loadAdapter(config) {
        await this.initialize();
        return loadAdapter(config);
    }
    async listAdapters(model) {
        await this.initialize();
        return listAdapters(model);
    }
    async removeAdapter(model, adapterPath) {
        await this.initialize();
        return removeAdapter(model, adapterPath);
    }
    // Evaluation methods
    async evaluateModel(config) {
        await this.initialize();
        return evaluateModel(config);
    }
    async compareModels(models, task, dataset) {
        await this.initialize();
        return compareModels(models, task, dataset);
    }
    // Model methods
    async loadModel(config) {
        await this.initialize();
        return loadModel(config);
    }
    async routeModel(input, availableModels) {
        await this.initialize();
        return routeModel(input, availableModels);
    }
    async listAvailableModels() {
        await this.initialize();
        return listAvailableModels();
    }
    // ===== ADVANCED FUNCTIONALITY =====
    // Advanced Fine-tuning
    async advancedFineTune(config) {
        await this.initialize();
        return advancedFineTune(config);
    }
    async createAdvancedTuner(config) {
        await this.initialize();
        return createAdvancedTuner(config);
    }
    // Advanced RAG
    async createAdvancedRAG(config = {}) {
        await this.initialize();
        if (!this.advancedRAG) {
            this.advancedRAG = new AdvancedRAGClient(config);
            await this.advancedRAG.initialize();
        }
        return this.advancedRAG;
    }
    async addDocumentsToRAG(documents) {
        const rag = await this.createAdvancedRAG();
        return rag.addDocuments(documents);
    }
    async queryAdvancedRAG(config) {
        const rag = await this.createAdvancedRAG();
        return rag.query(config);
    }
    // Model Conversion
    async createModelConverter() {
        await this.initialize();
        if (!this.modelConverter) {
            this.modelConverter = new ModelConverter();
            await this.modelConverter.initialize();
        }
        return this.modelConverter;
    }
    async convertModel(config) {
        const converter = await this.createModelConverter();
        return converter.convert(config);
    }
    async pytorchToONNX(inputPath, outputPath, config) {
        await this.initialize();
        return pytorchToONNX(inputPath, outputPath, config);
    }
    async tensorflowToTFLite(inputPath, outputPath, config) {
        await this.initialize();
        return tensorflowToTFLite(inputPath, outputPath, config);
    }
    async pytorchToGGUF(inputPath, outputPath, config) {
        await this.initialize();
        return pytorchToGGUF(inputPath, outputPath, config);
    }
    // Compliance
    async createComplianceMonitor(config) {
        await this.initialize();
        if (!this.complianceMonitor) {
            this.complianceMonitor = new ComplianceMonitor(config);
            await this.complianceMonitor.initialize();
        }
        return this.complianceMonitor;
    }
    async checkCompliance(check) {
        const monitor = await this.createComplianceMonitor({
            organizationId: 'default',
            enabledRegulations: ['GDPR', 'HIPAA'],
            privacyLevel: 'basic',
            auditEnabled: true,
            realTimeMonitoring: false
        });
        return monitor.checkCompliance(check);
    }
    // Advanced Agent
    async createAdvancedAgent(config) {
        await this.initialize();
        if (!this.advancedAgent) {
            this.advancedAgent = new AdvancedAgent(config);
            await this.advancedAgent.initialize();
        }
        return this.advancedAgent;
    }
    async runAdvancedAgent(input, context) {
        const agent = await this.createAdvancedAgent({
            name: 'DefaultAgent',
            model: 'gpt-3.5-turbo',
            tools: [builtInTools.calculator, builtInTools.search]
        });
        return agent.run(input, context);
    }
    // Model Client System
    async createLSTMModelClient(config) {
        await this.initialize();
        const client = new LSTMModelClient(config);
        await client.initialize();
        return client;
    }
    async createMoEModelClient(config) {
        await this.initialize();
        const client = new MoEModelClient(config);
        await client.initialize();
        return client;
    }
    async createMultiModalClient(config) {
        await this.initialize();
        const client = new MultiModalClient(config);
        await client.initialize();
        return client;
    }
    async createFederatedRouter(config) {
        await this.initialize();
        const router = new FederatedRouter(config);
        await router.initialize();
        return router;
    }
    // Gateway
    async createGateway(config = {}) {
        await this.initialize();
        if (!this.gateway) {
            this.gateway = new MultiMindGateway(config);
            await this.gateway.initialize();
        }
        return this.gateway;
    }
    async startGateway(config = {}) {
        const gateway = await this.createGateway(config);
        return gateway.start();
    }
    async stopGateway() {
        if (this.gateway) {
            return this.gateway.stop();
        }
        return { success: true, message: 'No gateway running' };
    }
    // Context Transfer Methods
    async createContextTransferManager(config) {
        await this.initialize();
        return new ContextTransferManager(config);
    }
    async createContextTransferAPI() {
        await this.initialize();
        return new ContextTransferAPI();
    }
    async transferContext(sourceModel, targetModel, conversationData, options) {
        const api = await this.createContextTransferAPI();
        return api.transferContextAPI(sourceModel, targetModel, conversationData, options);
    }
    async quickTransfer(sourceModel, targetModel, conversationData, options) {
        return quickTransfer(sourceModel, targetModel, conversationData, options);
    }
    async getSupportedModels() {
        const api = await this.createContextTransferAPI();
        return api.getSupportedModels();
    }
    async validateConversationFormat(data) {
        const api = await this.createContextTransferAPI();
        return api.validateConversationFormat(data);
    }
    async batchTransfer(transfers) {
        const api = await this.createContextTransferAPI();
        return api.batchTransfer(transfers);
    }
    async createChromeExtensionConfig() {
        const api = await this.createContextTransferAPI();
        return api.createChromeExtensionConfig();
    }
    // ===== UTILITY METHODS =====
    async getSDKInfo() {
        return {
            version: '0.1.0',
            features: [
                'Basic Agent Generation',
                'Advanced Fine-tuning (LoRA, Adapters, Prefix, Meta-Learning)',
                'Advanced RAG with Document Management',
                'Model Conversion (PyTorch, TensorFlow, ONNX, GGUF, TFLite)',
                'Compliance Monitoring (GDPR, HIPAA)',
                'Advanced Agents with Tools and Memory',
                'Model Client System (LSTM, MoE, MultiModal, Federated)',
                'Gateway API',
                'Evaluation and Comparison'
            ],
            initialized: this.initialized
        };
    }
    async healthCheck() {
        try {
            await this.initialize();
            return { status: 'healthy', message: 'MultiMind SDK is ready' };
        }
        catch (error) {
            return { status: 'unhealthy', message: error.message };
        }
    }
}
// Default export
export default MultiMindSDK;
//# sourceMappingURL=index.js.map