Upload 4 files

Dockerfile (1).txt

@@ -0,0 +1,17 @@
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY . .
+
+# Expose port (HuggingFace Spaces uses 7860)
+EXPOSE 7860
+
+# Run application
+CMD ["python", "app.py"]

README.md

@@ -1,12 +1,115 @@
----
-title: Continuumlearner
-emoji: 🌍
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# 🧠 ContinuumLearner - Model Copy Training Pipeline
+
+## Overview
+ContinuumLearner trains ContinuumGPT by copying the behavior of top AI models through Puter.js. Instead of storing user conversations, it focuses on **model-to-model learning** - teaching your AI by having it learn from the best responses.
+
+## How It Works
+
+1. **Select a top AI model** (GPT-5, Claude, Gemini, Llama, etc.)
+2. **Enter a training prompt** (questions, scenarios, topics)
+3. **AI generates response** using Puter.js (free & unlimited)
+4. **Response saved as training data** → Stored in `Sahil5112/ContinuumGPT`
+5. **ContinuumGPT learns** → Reads this dataset to improve responses
+
+## Training Philosophy
+
+**Model Copy Learning** - Your AI learns by observing how other AI models respond:
+- ✅ No user data collection
+- ✅ Pure model behavior training
+- ✅ Privacy-focused approach
+- ✅ Continuous improvement
+
+## Features
+
+✅ **8 Top AI Models** - GPT-5, Claude Sonnet 4, Gemini 2.5, Llama 4, DeepSeek, Liquid AI  
+✅ **100% Free** - Powered by Puter.js, no API keys needed  
+✅ **Auto-save Buffer** - Saves 10 examples at a time to HuggingFace  
+✅ **Real-time Stats** - Track dataset growth live  
+✅ **Manual Control** - Flush buffer anytime  
+✅ **No User Data** - Only model responses are saved
+
+## Deployment to HuggingFace Spaces
+
+1. Create a new Space on HuggingFace
+2. Select "Docker" as SDK
+3. Upload all files from `continuumlearner/` folder
+4. Add secret: `HF_TOKEN` (with write access to `Sahil5112/ContinuumGPT`)
+5. Space will start automatically
+
+## Environment Variables
+
+Required:
+- `HF_TOKEN` - Your HuggingFace token (for dataset write access)
+
+Optional:
+- `PORT` - Default: 7860
+
+## Training Data Structure
+
+Each training example is saved as:
+```json
+{
+  "input": "training prompt",
+  "output": "ai model response",
+  "model_used": "puter:gpt-5-nano",
+  "timestamp": "2025-10-30T12:00:00",
+  "training_id": "unique-id",
+  "learning_score": 1.0,
+  "is_new_learning": true,
+  "context": {
+    "query_length": 100,
+    "response_length": 500,
+    "training_mode": "model_copy",
+    "source": "puter_ai_models"
+  }
+}
+```
+
+## How ContinuumGPT Uses This
+
+Your main ContinuumGPT (in `app.py`) reads from `Sahil5112/ContinuumGPT` to:
+- Learn response patterns from top AI models
+- Improve answer quality over time
+- Build knowledge base from model behaviors
+- No user privacy concerns
+
+## Training Strategy
+
+**Recommended Approach:**
+1. Use diverse prompts (questions, coding, creative writing, analysis)
+2. Try different models to get varied perspectives
+3. Train on topics you want ContinuumGPT to excel at
+4. Regularly flush buffer to update dataset
+5. Monitor stats to track progress
+
+## Available Models
+
+All via Puter.js (no API keys needed):
+- **OpenAI**: GPT-5 Nano
+- **Anthropic**: Claude Sonnet 4
+- **Google**: Gemini 2.5 Flash
+- **Meta**: Llama 4 Scout
+- **DeepSeek**: DeepSeek Chat
+- **Liquid AI**: LFM-7B
+
+## Usage
+
+1. **Select AI model** from the grid
+2. **Enter training prompt** (what you want ContinuumGPT to learn)
+3. **Click "Train Model"** - AI generates response
+4. **Response auto-saves** to buffer
+5. **Manual flush** or auto-save when buffer full (10 examples)
+6. **Refresh stats** to see dataset growth
+
+## Privacy & Data
+
+- ✅ NO user conversations stored
+- ✅ Only AI model responses saved
+- ✅ All data is training examples
+- ✅ Dataset publicly accessible on HuggingFace
+- ✅ Full transparency
+
+## License
+
+MIT License - Free to use and modify

app.py

@@ -0,0 +1,172 @@
+
+import os
+import json
+import time
+from datetime import datetime
+from flask import Flask, request, jsonify, send_from_directory
+from flask_cors import CORS
+from datasets import load_dataset, Dataset
+import requests
+
+app = Flask(__name__, static_folder=".", static_url_path="")
+CORS(app, supports_credentials=True)
+
+# HuggingFace Configuration
+HF_TOKEN = os.getenv("HF_TOKEN")
+TRAINING_DATASET = "Sahil5112/ContinuumGPT"  # Main training dataset for ContinuumGPT
+CONVERSATION_BUFFER = []
+MAX_BUFFER_SIZE = 10  # Save to HF after 10 training examples
+
+def load_training_dataset():
+    """Load existing training data from HuggingFace"""
+    try:
+        if HF_TOKEN:
+            dataset = load_dataset(TRAINING_DATASET, split="train", token=HF_TOKEN)
+            return [dict(row) for row in dataset]
+        else:
+            print("⚠️ No HF_TOKEN - using local storage only")
+            return []
+    except Exception as e:
+        print(f"Could not load training dataset: {e}")
+        return []
+
+def save_to_training_dataset(training_examples):
+    """Save training examples to HuggingFace dataset"""
+    if not HF_TOKEN:
+        print("❌ No HF_TOKEN - cannot save to HuggingFace")
+        return False
+    
+    try:
+        # Load existing data
+        existing_data = load_training_dataset()
+        
+        # Add new training examples
+        existing_data.extend(training_examples)
+        
+        # Create dataset and push to HF
+        dataset = Dataset.from_list(existing_data)
+        dataset.push_to_hub(TRAINING_DATASET, token=HF_TOKEN, private=False)
+        
+        print(f"✅ Saved {len(training_examples)} training examples to {TRAINING_DATASET}")
+        print(f"📊 Total dataset size: {len(existing_data)} examples")
+        return True
+    except Exception as e:
+        print(f"❌ Error saving to dataset: {e}")
+        return False
+
+@app.route("/")
+def index():
+    return send_from_directory(".", "index.html")
+
+@app.route("/api/train", methods=["POST"])
+def train_model():
+    """Process AI model response and save as training data"""
+    global CONVERSATION_BUFFER
+    
+    data = request.get_json()
+    user_input = data.get("user_input", "").strip()
+    ai_response = data.get("ai_response", "").strip()
+    model_used = data.get("model_used", "puter.js")
+    
+    if not user_input or not ai_response:
+        return jsonify({"error": "Missing user_input or ai_response"}), 400
+    
+    # Create training entry (model learns from this interaction)
+    training_entry = {
+        "input": user_input,
+        "output": ai_response,
+        "model_used": model_used,
+        "timestamp": datetime.now().isoformat(),
+        "training_id": str(time.time()),
+        "learning_score": 1.0,
+        "is_new_learning": True,
+        "context": {
+            "query_length": len(user_input),
+            "response_length": len(ai_response),
+            "training_mode": "model_copy",
+            "source": "puter_ai_models"
+        }
+    }
+    
+    # Add to buffer
+    CONVERSATION_BUFFER.append(training_entry)
+    
+    # Auto-save when buffer is full
+    if len(CONVERSATION_BUFFER) >= MAX_BUFFER_SIZE:
+        save_to_training_dataset(CONVERSATION_BUFFER.copy())
+        CONVERSATION_BUFFER.clear()
+    
+    return jsonify({
+        "success": True,
+        "buffered": len(CONVERSATION_BUFFER),
+        "message": f"Training example buffered ({len(CONVERSATION_BUFFER)}/{MAX_BUFFER_SIZE})"
+    })
+
+@app.route("/api/dataset-stats", methods=["GET"])
+def dataset_stats():
+    """Get statistics about the training dataset"""
+    try:
+        training_data = load_training_dataset()
+        
+        # Calculate stats
+        total_examples = len(training_data)
+        total_tokens = sum(len(d.get("input", "")) + len(d.get("output", "")) for d in training_data)
+        models_used = {}
+        
+        for example in training_data:
+            model = example.get("model_used", "unknown")
+            models_used[model] = models_used.get(model, 0) + 1
+        
+        return jsonify({
+            "success": True,
+            "total_examples": total_examples,
+            "total_tokens": total_tokens,
+            "models_used": models_used,
+            "buffered": len(CONVERSATION_BUFFER),
+            "dataset_url": f"https://huggingface.co/datasets/{TRAINING_DATASET}"
+        })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/api/flush-buffer", methods=["POST"])
+def flush_buffer():
+    """Manually flush the training buffer to HuggingFace"""
+    global CONVERSATION_BUFFER
+    
+    if not CONVERSATION_BUFFER:
+        return jsonify({"message": "Buffer is empty, nothing to flush"})
+    
+    success = save_to_training_dataset(CONVERSATION_BUFFER.copy())
+    count = len(CONVERSATION_BUFFER)
+    CONVERSATION_BUFFER.clear()
+    
+    if success:
+        return jsonify({
+            "success": True,
+            "message": f"Flushed {count} training examples to HuggingFace"
+        })
+    else:
+        return jsonify({"error": "Failed to flush buffer"}), 500
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 7860))
+    
+    print("🚀 Starting ContinuumLearner Training Server...")
+    print(f"📊 Training Dataset: {TRAINING_DATASET}")
+    print(f"🎓 Dataset URL: https://huggingface.co/datasets/{TRAINING_DATASET}")
+    print("")
+    print("🤖 Training Mode: Model Copy Learning")
+    print("   - AI models respond to prompts")
+    print("   - Responses are saved as training data")
+    print("   - ContinuumGPT learns from these patterns")
+    print("   - NO user data is stored")
+    print("")
+    
+    if HF_TOKEN:
+        print("✅ HuggingFace Integration Active")
+        training_data = load_training_dataset()
+        print(f"📚 Current dataset size: {len(training_data)} training examples")
+    else:
+        print("⚠️ HuggingFace Integration Disabled - Add HF_TOKEN to enable")
+    
+    app.run(host="0.0.0.0", port=port, debug=False, threaded=True)

index.html

@@ -0,0 +1,386 @@
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ContinuumLearner - AI Training Pipeline</title>
+    <script src="https://js.puter.com/v2/"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        .header {
+            background: white;
+            padding: 30px;
+            border-radius: 20px;
+            box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+            margin-bottom: 30px;
+            text-align: center;
+        }
+
+        .header h1 {
+            font-size: 36px;
+            background: linear-gradient(135deg, #667eea, #764ba2);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            margin-bottom: 10px;
+        }
+
+        .stats {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+
+        .stat-card {
+            background: white;
+            padding: 20px;
+            border-radius: 15px;
+            box-shadow: 0 5px 20px rgba(0, 0, 0, 0.1);
+            text-align: center;
+        }
+
+        .stat-card h3 {
+            color: #667eea;
+            font-size: 32px;
+            margin-bottom: 5px;
+        }
+
+        .stat-card p {
+            color: #666;
+            font-size: 14px;
+        }
+
+        .training-area {
+            background: white;
+            padding: 30px;
+            border-radius: 20px;
+            box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+            margin-bottom: 30px;
+        }
+
+        .model-selector {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+            gap: 10px;
+            margin-bottom: 20px;
+        }
+
+        .model-btn {
+            padding: 15px;
+            background: linear-gradient(135deg, #667eea, #764ba2);
+            color: white;
+            border: none;
+            border-radius: 10px;
+            cursor: pointer;
+            font-size: 14px;
+            transition: transform 0.2s;
+        }
+
+        .model-btn:hover {
+            transform: translateY(-2px);
+        }
+
+        .model-btn.active {
+            background: linear-gradient(135deg, #f093fb, #f5576c);
+        }
+
+        .input-area {
+            margin-bottom: 20px;
+        }
+
+        textarea {
+            width: 100%;
+            padding: 15px;
+            border: 2px solid #e0e0e0;
+            border-radius: 10px;
+            font-size: 16px;
+            resize: vertical;
+            min-height: 100px;
+        }
+
+        .btn {
+            padding: 15px 30px;
+            background: linear-gradient(135deg, #667eea, #764ba2);
+            color: white;
+            border: none;
+            border-radius: 10px;
+            cursor: pointer;
+            font-size: 16px;
+            font-weight: bold;
+            margin-right: 10px;
+            transition: transform 0.2s;
+        }
+
+        .btn:hover {
+            transform: translateY(-2px);
+        }
+
+        .btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        .response-area {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 10px;
+            margin-top: 20px;
+            min-height: 150px;
+        }
+
+        .response-area h3 {
+            color: #667eea;
+            margin-bottom: 10px;
+        }
+
+        .log {
+            background: white;
+            padding: 20px;
+            border-radius: 15px;
+            box-shadow: 0 5px 20px rgba(0, 0, 0, 0.1);
+            max-height: 400px;
+            overflow-y: auto;
+        }
+
+        .log-entry {
+            padding: 10px;
+            border-bottom: 1px solid #e0e0e0;
+            font-size: 14px;
+        }
+
+        .log-entry:last-child {
+            border-bottom: none;
+        }
+
+        .success {
+            color: #28a745;
+        }
+
+        .error {
+            color: #dc3545;
+        }
+
+        .loading {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 2px solid rgba(255, 255, 255, 0.3);
+            border-radius: 50%;
+            border-top-color: white;
+            animation: spin 1s linear infinite;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🧠 ContinuumLearner</h1>
+            <p>Model Training Pipeline - Copy AI Behavior</p>
+            <p style="margin-top: 10px; color: #666;">
+                Training dataset: <a href="https://huggingface.co/datasets/Sahil5112/ContinuumGPT" target="_blank" style="color: #667eea;">Sahil5112/ContinuumGPT</a>
+            </p>
+            <p style="margin-top: 5px; color: #999; font-size: 13px;">
+                🎓 Train ContinuumGPT by copying responses from top AI models
+            </p>
+        </div>
+
+        <div class="stats">
+            <div class="stat-card">
+                <h3 id="totalConversations">0</h3>
+                <p>Training Examples</p>
+            </div>
+            <div class="stat-card">
+                <h3 id="totalTokens">0</h3>
+                <p>Total Tokens</p>
+            </div>
+            <div class="stat-card">
+                <h3 id="bufferedCount">0</h3>
+                <p>Buffered (Unsaved)</p>
+            </div>
+            <div class="stat-card">
+                <h3 id="sessionCount">0</h3>
+                <p>This Session</p>
+            </div>
+        </div>
+
+        <div class="training-area">
+            <h2 style="margin-bottom: 20px; color: #667eea;">Select AI Model</h2>
+            <div class="model-selector" id="modelSelector">
+                <button class="model-btn active" data-model="puter:gpt-5-nano">GPT-5 Nano</button>
+                <button class="model-btn" data-model="puter:claude-sonnet-4">Claude Sonnet 4</button>
+                <button class="model-btn" data-model="puter:google/gemini-2.5-flash">Gemini 2.5 Flash</button>
+                <button class="model-btn" data-model="puter:meta-llama/llama-4-scout">Llama 4 Scout</button>
+                <button class="model-btn" data-model="puter:deepseek-chat">DeepSeek Chat</button>
+                <button class="model-btn" data-model="puter:liquid/lfm-7b">Liquid LFM-7B</button>
+            </div>
+
+            <div class="input-area">
+                <h3 style="margin-bottom: 10px; color: #667eea;">Training Input</h3>
+                <textarea id="userInput" placeholder="Enter a message to train the AI..."></textarea>
+            </div>
+
+            <button class="btn" onclick="trainModel()">🚀 Train Model</button>
+            <button class="btn" onclick="flushBuffer()">💾 Save to HuggingFace</button>
+            <button class="btn" onclick="refreshStats()">🔄 Refresh Stats</button>
+
+            <div class="response-area">
+                <h3>AI Response</h3>
+                <div id="responseText" style="white-space: pre-wrap;"></div>
+            </div>
+        </div>
+
+        <div class="log">
+            <h2 style="margin-bottom: 15px; color: #667eea;">Training Log</h2>
+            <div id="trainingLog"></div>
+        </div>
+    </div>
+
+    <script>
+        let selectedModel = "puter:gpt-5-nano";
+        let sessionCount = 0;
+
+        // Model selector
+        document.querySelectorAll('.model-btn').forEach(btn => {
+            btn.addEventListener('click', function() {
+                document.querySelectorAll('.model-btn').forEach(b => b.classList.remove('active'));
+                this.classList.add('active');
+                selectedModel = this.dataset.model;
+                addLog(`Selected model: ${selectedModel}`, 'success');
+            });
+        });
+
+        async function trainModel() {
+            const userInput = document.getElementById('userInput').value.trim();
+            if (!userInput) {
+                alert('Please enter a message');
+                return;
+            }
+
+            const responseText = document.getElementById('responseText');
+            responseText.innerHTML = '<div class="loading"></div> Generating response...';
+
+            try {
+                // Get AI response using Puter.js
+                const response = await puter.ai.chat(userInput, { model: selectedModel });
+                
+                responseText.textContent = response;
+                addLog(`✅ Generated response using ${selectedModel}`, 'success');
+
+                // Send to backend for training
+                const trainResponse = await fetch('/api/train', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        user_input: userInput,
+                        ai_response: response,
+                        model_used: selectedModel
+                    })
+                });
+
+                const trainData = await trainResponse.json();
+                
+                if (trainData.success) {
+                    sessionCount++;
+                    document.getElementById('sessionCount').textContent = sessionCount;
+                    document.getElementById('bufferedCount').textContent = trainData.buffered;
+                    addLog(trainData.message, 'success');
+                    
+                    // Clear input
+                    document.getElementById('userInput').value = '';
+                    
+                    // Auto-save when buffer is full
+                    if (trainData.buffered >= 10) {
+                        addLog('Buffer full! Auto-saving to HuggingFace...', 'success');
+                        await flushBuffer();
+                    }
+                } else {
+                    addLog('❌ Failed to save training data', 'error');
+                }
+
+            } catch (error) {
+                responseText.textContent = `Error: ${error.message}`;
+                addLog(`❌ Error: ${error.message}`, 'error');
+            }
+        }
+
+        async function flushBuffer() {
+            try {
+                const response = await fetch('/api/flush-buffer', { method: 'POST' });
+                const data = await response.json();
+                
+                if (data.success) {
+                    addLog(`💾 ${data.message}`, 'success');
+                    await refreshStats();
+                } else {
+                    addLog(data.message || 'Buffer empty', 'success');
+                }
+            } catch (error) {
+                addLog(`❌ Error flushing buffer: ${error.message}`, 'error');
+            }
+        }
+
+        async function refreshStats() {
+            try {
+                const response = await fetch('/api/dataset-stats');
+                const data = await response.json();
+                
+                if (data.success) {
+                    document.getElementById('totalConversations').textContent = data.total_examples;
+                    document.getElementById('totalTokens').textContent = data.total_tokens.toLocaleString();
+                    document.getElementById('bufferedCount').textContent = data.buffered;
+                    addLog('📊 Stats refreshed', 'success');
+                }
+            } catch (error) {
+                addLog(`❌ Error refreshing stats: ${error.message}`, 'error');
+            }
+        }
+
+        function addLog(message, type = '') {
+            const log = document.getElementById('trainingLog');
+            const entry = document.createElement('div');
+            entry.className = `log-entry ${type}`;
+            entry.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
+            log.insertBefore(entry, log.firstChild);
+            
+            // Keep only last 50 entries
+            while (log.children.length > 50) {
+                log.removeChild(log.lastChild);
+            }
+        }
+
+        // Initialize stats on load
+        refreshStats();
+        addLog('🚀 ContinuumLearner initialized', 'success');
+        addLog('💡 Select a model and start training!', 'success');
+
+        // Enter key to submit
+        document.getElementById('userInput').addEventListener('keydown', function(e) {
+            if (e.key === 'Enter' && e.ctrlKey) {
+                trainModel();
+            }
+        });
+    </script>
+</body>
+</html>