multimind-sdk/dist/src/modelClientSystem.d.ts

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.

export interface ModelClientConfig {
    modelPath?: string;
    modelName?: string;
    tokenizer?: any;
    device?: 'cpu' | 'gpu' | 'auto';
    maxLength?: number;
    temperature?: number;
}
export interface MoEConfig {
    experts: Record<string, ModelClientConfig>;
    router: (input: string) => string;
    loadBalancing?: boolean;
    fallbackExpert?: string;
}
export interface MultiModalConfig {
    textClient?: any;
    imageClient?: any;
    audioClient?: any;
    videoClient?: any;
    codeClient?: any;
    fusionStrategy?: 'concat' | 'attention' | 'cross_modal';
}
export interface FederatedConfig {
    localClient: any;
    cloudClient: any;
    routingStrategy: 'local_first' | 'cloud_first' | 'load_balanced' | 'cost_optimized';
    fallbackStrategy?: 'local' | 'cloud' | 'hybrid';
    costThreshold?: number;
}
export declare class LSTMModelClient {
    private client;
    private config;
    constructor(config: ModelClientConfig);
    initialize(): Promise<{
        success: boolean;
        message: string;
    }>;
    generate(input: string, config?: Partial<ModelClientConfig>): Promise<any>;
    encode(input: string): Promise<any>;
}
export declare class MoEModelClient {
    private client;
    private config;
    private experts;
    constructor(config: MoEConfig);
    initialize(): Promise<{
        success: boolean;
        message: string;
    }>;
    generate(input: string): Promise<any>;
    getExpertUsage(): Promise<any>;
    addExpert(name: string, config: ModelClientConfig): Promise<{
        success: boolean;
        message: string;
    }>;
}
export declare class MultiModalClient {
    private client;
    private config;
    private clients;
    constructor(config: MultiModalConfig);
    initialize(): Promise<{
        success: boolean;
        message: string;
    }>;
    generate(input: any, inputType: 'text' | 'image' | 'audio' | 'video' | 'code' | 'multimodal'): Promise<any>;
    processMultimodal(inputs: Record<string, any>): Promise<any>;
    getSupportedModalities(): Promise<any>;
}
export declare class FederatedRouter {
    private router;
    private config;
    constructor(config: FederatedConfig);
    initialize(): Promise<{
        success: boolean;
        message: string;
    }>;
    route(input: string): Promise<any>;
    generate(input: string): Promise<any>;
    getRoutingStats(): Promise<any>;
    updateRoutingStrategy(strategy: string): Promise<{
        success: boolean;
        message: string;
    }>;
}
export declare function createLoadBalancedRouter(clients: any[], weights?: number[]): (input: string) => any;
export declare function createIntelligentRouter(clients: any[], routingRules: Record<string, any>): (input: string) => any;
//# sourceMappingURL=modelClientSystem.d.ts.map