modelmix 4.2.4 → 4.2.8

package/demo/parallel-strategy.js

@@ -0,0 +1,479 @@
+/**
+ * RECURSIVE LANGUAGE MODELS (RLM) - Generic Parallel Strategy
+ * 
+ * Based on: https://arxiv.org/html/2512.24601v1
+ * 
+ * This implements the RLM paradigm where:
+ * - Long prompts/data are treated as VARIABLES in an environment (not fed to the model)
+ * - The model programmatically inspects and decomposes data
+ * - The model CONSTRUCTS its own prompts for parallel ModelMix calls
+ * - Recursive refinement allows iterative improvement based on partial results
+ * 
+ * ENVIRONMENT:
+ * - Variables can contain any data: text, structured data, arrays, etc.
+ * - The model uses tools to inspect and manipulate these variables
+ * - The model decides what prompts to create for parallel processing
+ * 
+ * TOOLS:
+ * - inspect_variables: See what's available in the environment
+ * - execute_code: Run JavaScript to analyze/transform data (returns result)
+ * - parallel_modelmix: Execute parallel ModelMix calls with custom prompts
+ * - recursive_call: Make recursive calls with updated context
+ * 
+ * This is GENERIC - works with any data structure, not hardcoded for specific use cases.
+ */
+
+process.loadEnvFile();
+import { ModelMix } from '../index.js';
+
+console.log('🧬 ModelMix - RLM (Recursive Language Models) Demo');
+console.log('🎯 Generic parallel strategy with environment variables\n');
+
+// Example 1: Book with chapters (variable in environment)
+const BOOK_DATA = {
+    title: "The Future of Artificial Intelligence",
+    type: "book",
+    chapters: [
+        {
+            id: 1,
+            title: "Introduction to AI",
+            content: `Artificial Intelligence represents one of the most transformative technologies of our time. 
+From its inception in the 1950s at Dartmouth College to today's large language models, AI has evolved 
+dramatically. Early symbolic AI systems could play chess and prove mathematical theorems, but struggled 
+with perception and common sense reasoning. The field went through multiple "AI winters" where progress 
+stalled and funding dried up. However, the advent of machine learning, particularly deep learning in the 
+2010s, revolutionized the field. Neural networks with millions or billions of parameters can now understand 
+natural language, generate images, and even write code. This chapter explores the historical context and 
+foundational concepts that make modern AI possible.`
+        },
+        {
+            id: 2,
+            title: "Machine Learning Fundamentals",
+            content: `Machine learning is the backbone of modern AI systems. Unlike traditional programming where 
+rules are explicitly coded, machine learning algorithms learn patterns from data. Supervised learning uses 
+labeled examples to train models that can make predictions on new data. Unsupervised learning finds hidden 
+patterns without labels. Reinforcement learning trains agents through trial and error with reward signals. 
+The key innovation of deep learning is the use of neural networks with multiple layers that can learn 
+hierarchical representations. Convolutional Neural Networks (CNNs) excel at visual tasks by learning 
+spatial hierarchies. Recurrent Neural Networks (RNNs) and their modern variant, Transformers, process 
+sequential data like text and speech.`
+        },
+        {
+            id: 3,
+            title: "Natural Language Processing",
+            content: `Natural Language Processing (NLP) enables computers to understand and generate human language. 
+Early NLP systems relied on hand-crafted rules and linguistic features. The statistical revolution in the 
+1990s brought probabilistic models that could learn from text corpora. Word embeddings like Word2Vec and 
+GloVe represented words as vectors, capturing semantic relationships. The transformer architecture, introduced 
+in 2017, revolutionized NLP with its attention mechanism. BERT pioneered bidirectional pretraining, while 
+GPT models showed the power of scaling and autoregressive generation. Today's large language models like 
+GPT-4 and Claude demonstrate remarkable capabilities in translation, summarization, and reasoning.`
+        },
+        {
+            id: 4,
+            title: "Computer Vision",
+            content: `Computer vision aims to give machines the ability to see and understand visual information. 
+Early systems used edge detection and template matching. The breakthrough came with Convolutional Neural 
+Networks (CNNs), particularly AlexNet's victory in ImageNet 2012. Object detection systems like YOLO can 
+identify and locate multiple objects in images. Segmentation models like U-Net precisely delineate object 
+boundaries. Recent advances include Vision Transformers and multimodal models like CLIP that connect vision 
+and language. Applications span autonomous vehicles, medical imaging, and facial recognition.`
+        },
+        {
+            id: 5,
+            title: "The Future",
+            content: `The trajectory of AI points toward increasingly capable and general systems. Artificial 
+General Intelligence (AGI) that matches human-level reasoning across all domains remains aspirational. 
+Scaling laws suggest that larger models with more data continue to improve. Multimodal AI that seamlessly 
+integrates text, vision, and audio is rapidly advancing. Few-shot and zero-shot learning reduce data 
+requirements. The convergence of AI with biotechnology and neuroscience could lead to transformative 
+breakthroughs. Society will need to adapt to increasingly automated work and AI-augmented capabilities.`
+        }
+    ]
+};
+
+// Example 2: Research papers dataset (variable in environment)
+const PAPERS_DATA = {
+    dataset: "AI Research Papers 2024",
+    type: "papers",
+    papers: [
+        { id: 1, title: "Attention Is All You Need", topic: "transformers", citations: 95000, year: 2017 },
+        { id: 2, title: "BERT: Pre-training of Deep Bidirectional Transformers", topic: "nlp", citations: 75000, year: 2018 },
+        { id: 3, title: "GPT-3: Language Models are Few-Shot Learners", topic: "llm", citations: 45000, year: 2020 },
+        { id: 4, title: "ResNet: Deep Residual Learning", topic: "vision", citations: 120000, year: 2015 },
+        { id: 5, title: "DALL-E: Zero-Shot Text-to-Image Generation", topic: "multimodal", citations: 8000, year: 2021 }
+    ]
+};
+
+async function genericRLMExample(variableName, variableData, task) {
+    console.log('=== RLM: Generic Parallel Processing ===\n');
+    console.log(`📊 Variable: ${variableName}`);
+    console.log(`📋 Task: ${task}\n`);
+
+    // Environment - data is stored here, NOT in the model's context
+    let environment = {
+        variables: {
+            [variableName]: variableData
+        },
+        execution_log: [],
+        iteration: 0
+    };
+
+    const mmix = ModelMix.new({ 
+        config: { 
+            debug: false, 
+            max_history: 50,
+            bottleneck: {
+                maxConcurrent: 10,
+                minTime: 100
+            }
+        } 
+    })
+        .gpt41nano()
+        .setSystem(`You are a Recursive Language Model (RLM) agent.
+
+Data is in the ENVIRONMENT as variables, not in your context. You work programmatically:
+- Inspect variables to understand what's available
+- Execute code to analyze and transform data
+- Construct prompts for parallel ModelMix calls
+- Make recursive calls to refine results
+
+You decide the strategy based on the data and task.`);
+
+    // Tool 1: Inspect environment variables
+    mmix.addTool({
+        name: "inspect_variables",
+        description: "Lists all variables in the environment with their types and basic info. Does not return the full content.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: []
+        }
+    }, async () => {
+        const info = {};
+        for (const [name, value] of Object.entries(environment.variables)) {
+            if (typeof value === 'object' && value !== null) {
+                if (Array.isArray(value)) {
+                    info[name] = {
+                        type: 'array',
+                        length: value.length,
+                        sample: value[0]
+                    };
+                } else {
+                    info[name] = {
+                        type: 'object',
+                        keys: Object.keys(value),
+                        structure: typeof value.chapters !== 'undefined' ? 'book' : 
+                                  typeof value.papers !== 'undefined' ? 'dataset' : 'generic'
+                    };
+                }
+            } else {
+                info[name] = {
+                    type: typeof value,
+                    value: value
+                };
+            }
+        }
+        
+        console.log('🔍 Environment variables:', JSON.stringify(info, null, 2));
+        return JSON.stringify(info);
+    });
+
+    // Tool 2: Execute code to analyze/transform data
+    mmix.addTool({
+        name: "execute_code",
+        description: "Executes JavaScript code in the environment. All variables are available. Return the result. Examples: 'return BOOK_DATA.chapters.length', 'return PAPERS_DATA.papers.map(p => ({title: p.title, content: p.content}))'",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "JavaScript code to execute. Should return a value. All environment variables are in scope."
+                },
+                description: {
+                    type: "string",
+                    description: "Brief description of what this code does"
+                }
+            },
+            required: ["code", "description"]
+        }
+    }, async ({ code, description }) => {
+        console.log(`\n💻 Executing code: ${description}`);
+        console.log('─'.repeat(60));
+        console.log(code);
+        console.log('─'.repeat(60));
+        
+        try {
+            // Create function with all environment variables in scope
+            const varNames = Object.keys(environment.variables);
+            const varValues = Object.values(environment.variables);
+            
+            const func = new Function(...varNames, `
+                ${code}
+            `);
+            
+            const result = func(...varValues);
+            
+            // Limit display output but return full result
+            const displayResult = JSON.stringify(result, null, 2);
+            const truncated = displayResult.length > 1000 ? displayResult.substring(0, 1000) + '...(truncated)' : displayResult;
+            console.log('✅ Result:', truncated);
+            
+            return JSON.stringify(result);
+        } catch (error) {
+            console.log('❌ Error:', error.message);
+            return JSON.stringify({ error: error.message });
+        }
+    });
+
+    // Tool 3: Parallel ModelMix calls with CUSTOM prompts
+    mmix.addTool({
+        name: "parallel_modelmix",
+        description: "Executes multiple ModelMix calls in parallel. YOU construct the prompt and context for each call. The model processes each item independently and returns results.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                calls: {
+                    type: "array",
+                    description: "Array of ModelMix calls to execute in parallel",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: {
+                                type: "string",
+                                description: "Unique identifier for this call"
+                            },
+                            system_prompt: {
+                                type: "string",
+                                description: "System prompt for this ModelMix instance (optional)"
+                            },
+                            user_prompt: {
+                                type: "string",
+                                description: "The main prompt/instruction for this call. YOU construct this."
+                            },
+                            context: {
+                                type: "string",
+                                description: "Additional context/data for this call. YOU provide the relevant data."
+                            }
+                        },
+                        required: ["id", "user_prompt"]
+                    }
+                }
+            },
+            required: ["calls"]
+        }
+    }, async ({ calls }) => {
+        console.log(`\n🚀 Parallel ModelMix execution: ${calls.length} calls`);
+        console.log('─'.repeat(70));
+        
+        const startTime = Date.now();
+        
+        const results = await Promise.all(
+            calls.map(async (call) => {
+                const taskStart = Date.now();
+                console.log(`📍 [${call.id}] Starting...`);
+                console.log(`   Prompt: ${call.user_prompt.substring(0, 80)}...`);
+                
+                // Create a new ModelMix instance for this call
+                const callMmix = ModelMix.new({ 
+                    config: { 
+                        debug: false,
+                        max_history: 5 
+                    } 
+                });
+                
+                callMmix.gpt41mini();
+                
+                if (call.system_prompt) {
+                    callMmix.setSystem(call.system_prompt);
+                }
+                
+                let fullPrompt = call.user_prompt;
+                if (call.context) {
+                    fullPrompt += `\n\nCONTEXT:\n${call.context}`;
+                }
+                
+                callMmix.addText(fullPrompt);
+                
+                try {
+                    const result = await callMmix.message();
+                    const duration = Date.now() - taskStart;
+                    
+                    console.log(`✅ [${call.id}] Completed in ${duration}ms`);
+                    
+                    environment.execution_log.push({
+                        type: 'parallel_call',
+                        id: call.id,
+                        duration,
+                        success: true
+                    });
+                    
+                    return {
+                        id: call.id,
+                        success: true,
+                        result: result
+                    };
+                } catch (error) {
+                    console.log(`❌ [${call.id}] Error: ${error.message}`);
+                    
+                    environment.execution_log.push({
+                        type: 'parallel_call',
+                        id: call.id,
+                        duration: Date.now() - taskStart,
+                        success: false,
+                        error: error.message
+                    });
+                    
+                    return {
+                        id: call.id,
+                        success: false,
+                        error: error.message
+                    };
+                }
+            })
+        );
+        
+        const totalDuration = Date.now() - startTime;
+        console.log('─'.repeat(70));
+        console.log(`⚡ Total: ${totalDuration}ms for ${calls.length} calls`);
+        console.log(`📊 Average: ${Math.round(totalDuration / calls.length)}ms per call\n`);
+        
+        return JSON.stringify(results, null, 2);
+    });
+
+    // Tool 4: Recursive call for refinement
+    mmix.addTool({
+        name: "recursive_call",
+        description: "Makes a recursive ModelMix call to refine, synthesize, or further process results. Use this to combine partial results or iterate on the solution.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: {
+                    type: "string",
+                    description: "The task for the recursive call"
+                },
+                context: {
+                    type: "string",
+                    description: "Context or data for the recursive call"
+                },
+                system_prompt: {
+                    type: "string",
+                    description: "Optional system prompt for this recursive call"
+                }
+            },
+            required: ["task", "context"]
+        }
+    }, async ({ task, context, system_prompt }) => {
+        environment.iteration++;
+        
+        console.log(`\n🔄 Recursive call (iteration ${environment.iteration})`);
+        console.log(`📝 Task: ${task.substring(0, 100)}...`);
+        console.log('─'.repeat(70));
+        
+        const recursiveMmix = ModelMix.new({ 
+            config: { 
+                debug: false,
+                max_history: 10
+            } 
+        })
+            .gpt41nano();
+        
+        if (system_prompt) {
+            recursiveMmix.setSystem(system_prompt);
+        } else {
+            recursiveMmix.setSystem('You are a synthesis and analysis assistant. Be clear and concise.');
+        }
+        
+        recursiveMmix.addText(`${task}\n\n${context}`);
+        
+        try {
+            const result = await recursiveMmix.message();
+            console.log(`✅ Recursive call completed\n`);
+            
+            environment.execution_log.push({
+                type: 'recursive_call',
+                iteration: environment.iteration,
+                task: task
+            });
+            
+            return result;
+        } catch (error) {
+            console.log(`❌ Recursive call error: ${error.message}\n`);
+            return `Error: ${error.message}`;
+        }
+    });
+
+    // Set the task for the agent
+    mmix.addText(`
+ENVIRONMENT VARIABLE: ${variableName}
+
+TASK: ${task}
+
+STRATEGY (RLM paradigm):
+1. Use inspect_variables to see what's available
+2. Use execute_code to analyze the data structure and extract information
+3. Design your approach - decide what needs parallel processing
+4. Use parallel_modelmix to execute multiple ModelMix calls
+   - YOU construct the prompts for each call
+   - YOU provide the relevant context/data for each call
+5. Use recursive_call if you need to synthesize results
+
+The data is in the ENVIRONMENT. Work programmatically. Be strategic and efficient.
+`);
+
+    console.log('🤔 RLM agent analyzing task...\n');
+    const result = await mmix.message();
+    
+    console.log('\n' + '='.repeat(70));
+    console.log('📊 FINAL RESULT:');
+    console.log('='.repeat(70));
+    console.log(result);
+    
+    console.log('\n' + '='.repeat(70));
+    console.log('📈 EXECUTION STATISTICS:');
+    console.log('='.repeat(70));
+    console.log(`Total iterations: ${environment.iteration}`);
+    console.log(`Execution log entries: ${environment.execution_log.length}`);
+    
+    const parallelCalls = environment.execution_log.filter(e => e.type === 'parallel_call');
+    if (parallelCalls.length > 0) {
+        const successful = parallelCalls.filter(e => e.success).length;
+        const avgDuration = parallelCalls.reduce((sum, e) => sum + (e.duration || 0), 0) / parallelCalls.length;
+        console.log(`Parallel ModelMix calls: ${successful}/${parallelCalls.length} successful`);
+        console.log(`Average call duration: ${Math.round(avgDuration)}ms`);
+    }
+    
+    const recursiveCalls = environment.execution_log.filter(e => e.type === 'recursive_call');
+    if (recursiveCalls.length > 0) {
+        console.log(`Recursive calls: ${recursiveCalls.length}`);
+    }
+}
+
+// Run examples
+(async () => {
+    try {
+        // Example 1: Book summarization
+        await genericRLMExample(
+            'BOOK_DATA',
+            BOOK_DATA,
+            'Provide a comprehensive summary of the book, focusing on key concepts in each chapter and overall themes.'
+        );
+        
+        console.log('\n\n' + '='.repeat(70));
+        console.log('\n');
+        
+        // Example 2: Research papers analysis
+        await genericRLMExample(
+            'PAPERS_DATA',
+            PAPERS_DATA,
+            'Analyze the research papers dataset. Identify trends, compare topics, and highlight the most influential papers.'
+        );
+        
+        console.log('\n✅ RLM Demo completed');
+        process.exit(0);
+    } catch (error) {
+        console.error('❌ Error:', error);
+        console.error(error.stack);
+        process.exit(1);
+    }
+})();

package/demo/rlm-basic.js

@@ -0,0 +1,183 @@
+process.loadEnvFile();
+import { ModelMix } from '../index.js';
+
+console.log('🧬 RLM Basic Demo - Recursive Language Model');
+console.log('📖 Inspired by: https://arxiv.org/html/2512.24601v1\n');
+
+/**
+ * RLM Concept: Instead of passing a huge prompt directly to the LLM,
+ * we treat it as an external "environment" that the LLM can:
+ * 1. Inspect programmatically (peek into parts)
+ * 2. Decompose into sub-tasks
+ * 3. Process recursively
+ */
+
+// Simulamos un documento muy largo (en RLM real, esto podría ser millones de tokens)
+const LARGE_DATASET = {
+    total_length: '1.5M tokens (simulated)',
+    data: [
+        { id: 1, name: 'Alice', dept: 'Engineering', score: 9.2, skills: ['JavaScript', 'Python', 'React'] },
+        { id: 2, name: 'Bob', dept: 'Analytics', score: 8.7, skills: ['Python', 'R', 'SQL'] },
+        { id: 3, name: 'Carol', dept: 'Product', score: 9.5, skills: ['Agile', 'SQL'] },
+        { id: 4, name: 'David', dept: 'Engineering', score: 7.8, skills: ['JavaScript', 'Git'] },
+        { id: 5, name: 'Emma', dept: 'Analytics', score: 9.0, skills: ['Python', 'ML', 'AWS'] },
+        { id: 6, name: 'Frank', dept: 'Engineering', score: 8.9, skills: ['Docker', 'Kubernetes'] },
+        { id: 7, name: 'Grace', dept: 'Design', score: 9.3, skills: ['Figma', 'CSS'] },
+        { id: 8, name: 'Henry', dept: 'Analytics', score: 7.5, skills: ['SQL', 'Python'] },
+    ]
+};
+
+let recursionCount = 0;
+
+async function basicRLM() {
+    console.log('=== RLM: Procesamiento de Dataset Grande ===\n');
+    console.log(`📊 Dataset: ${LARGE_DATASET.total_length}`);
+    console.log(`👥 Records: ${LARGE_DATASET.data.length}`);
+    console.log('🎯 Query: "Find top Engineering talents with Python skills"\n');
+
+    const mmix = ModelMix.new({ config: { debug: false, max_history: 20 } })
+        .gpt41nano()
+        .setSystem(`You are an RLM (Recursive Language Model). 
+        
+Instead of reading all data at once, you:
+1. INSPECT: Use 'query_data' to explore the dataset programmatically
+2. DECOMPOSE: Break complex queries into simpler sub-queries
+3. RECURSE: Use 'solve_subtask' for focused sub-problems
+
+Be strategic: think about what information you need and query only that.`);
+
+    // Tool 1: Query the data environment (instead of loading all into context)
+    mmix.addTool({
+        name: "query_data",
+        description: "Query the large dataset without loading it entirely. You can filter, aggregate, or inspect specific fields.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                operation: {
+                    type: "string",
+                    enum: ["filter", "count", "get_fields", "get_unique_values"],
+                    description: "Operation to perform"
+                },
+                field: {
+                    type: "string",
+                    description: "Field name to query (e.g., 'dept', 'score', 'skills')"
+                },
+                condition: {
+                    type: "object",
+                    description: "Condition for filtering (e.g., {field: 'dept', value: 'Engineering'})"
+                }
+            },
+            required: ["operation"]
+        }
+    }, async ({ operation, field, condition }) => {
+        console.log(`🔍 Query: ${operation}${field ? ` on "${field}"` : ''}${condition ? ` where ${JSON.stringify(condition)}` : ''}`);
+
+        switch (operation) {
+            case "count":
+                return JSON.stringify({ count: LARGE_DATASET.data.length });
+            
+            case "get_fields":
+                const fields = Object.keys(LARGE_DATASET.data[0]);
+                return JSON.stringify({ fields });
+            
+            case "get_unique_values":
+                if (!field) return JSON.stringify({ error: "field required" });
+                const unique = [...new Set(LARGE_DATASET.data.map(d => d[field]))];
+                return JSON.stringify({ field, unique_values: unique });
+            
+            case "filter":
+                let filtered = LARGE_DATASET.data;
+                if (condition) {
+                    filtered = filtered.filter(item => {
+                        if (condition.operator === 'gt') {
+                            return item[condition.field] > condition.value;
+                        } else if (condition.operator === 'contains') {
+                            return item[condition.field]?.includes(condition.value);
+                        } else {
+                            return item[condition.field] === condition.value;
+                        }
+                    });
+                }
+                console.log(`   → Found ${filtered.length} records`);
+                return JSON.stringify({ count: filtered.length, data: filtered });
+            
+            default:
+                return JSON.stringify({ error: "Unknown operation" });
+        }
+    });
+
+    // Tool 2: Recursive sub-task solver
+    mmix.addTool({
+        name: "solve_subtask",
+        description: "Recursively solve a focused sub-task. Use this to decompose complex queries.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: {
+                    type: "string",
+                    description: "The sub-task to solve"
+                },
+                context: {
+                    type: "string",
+                    description: "Relevant context/data for this sub-task"
+                }
+            },
+            required: ["task", "context"]
+        }
+    }, async ({ task, context }) => {
+        recursionCount++;
+        console.log(`\n🔄 Recursion ${recursionCount}: ${task.substring(0, 60)}...`);
+
+        if (recursionCount > 3) {
+            recursionCount--;
+            return "Max recursion depth reached. Please solve directly.";
+        }
+
+        // Create a focused recursive call
+        const subMmix = ModelMix.new({ config: { debug: false } })
+            .gpt41nano()
+            .setSystem(`Solve this focused sub-task concisely. Recursion level: ${recursionCount}`);
+
+        subMmix.addText(`Context: ${context}\n\nTask: ${task}`);
+        
+        const result = await subMmix.message();
+        recursionCount--;
+        
+        console.log(`   ✅ Sub-result: ${result.substring(0, 80)}...`);
+        return result;
+    });
+
+    // Main query
+    mmix.addText(`Find the top Engineering employees who have Python skills and score above 8.5.
+
+Use the RLM approach:
+1. First explore what fields are available
+2. Filter by department
+3. Check for Python skills
+4. Apply score threshold
+5. Summarize the results
+
+Be efficient - only query what you need!`);
+
+    console.log('🤖 LLM Processing with RLM tools...\n');
+    const result = await mmix.message();
+    
+    console.log('\n' + '═'.repeat(70));
+    console.log('💡 FINAL ANSWER:');
+    console.log('═'.repeat(70));
+    console.log(result);
+    console.log('═'.repeat(70));
+    
+    console.log(`\n📈 Statistics:`);
+    console.log(`   - Total recursive calls: ${recursionCount}`);
+    console.log(`   - Dataset never fully loaded into context ✓`);
+    console.log(`   - Programmatic exploration used ✓`);
+}
+
+try {
+    await basicRLM();
+    console.log('\n✅ RLM Basic example completed successfully!');
+} catch (error) {
+    console.error('❌ Error:', error);
+    console.error(error.stack);
+}