Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+omnimind-100k.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,310 @@
----
-license: apache-2.0
----
+---
+license: mit
+task_categories:
+  - text-generation
+  - question-answering
+  - text2text-generation
+  - conversational
+language:
+  - en
+tags:
+  - instruction-tuning
+  - multi-task
+  - coding
+  - math
+  - science
+  - image-generation
+  - reasoning
+  - general-knowledge
+  - conversational
+pretty_name: OmniMind-100K
+size_categories:
+  - 100K<n<1M
+---
+
+# OmniMind-100K
+
+A comprehensive, multi-domain instruction-following dataset with **100,000 high-quality examples** for training general-purpose AI assistants.
+
+## Dataset Description
+
+OmniMind-100K is designed to create well-rounded AI models capable of handling diverse tasks including coding, mathematics, science, image generation prompts, reasoning, and general knowledge. Each example includes detailed, informative responses that demonstrate how an ideal AI assistant should communicate.
+
+### Dataset Summary
+
+| Attribute | Value |
+|-----------|-------|
+| **Total Examples** | 100,000 |
+| **Languages** | English |
+| **License** | MIT |
+| **Format** | JSONL |
+| **Task Types** | Instruction Following, Q&A, Conversation, Reasoning |
+
+### Category Distribution
+
+| Category | Count | Percentage |
+|----------|-------|------------|
+| Coding | 20,000 | 20.0% |
+| Science | 10,000 | 10.0% |
+| Math | 10,000 | 10.0% |
+| Image Generation | 10,000 | 10.0% |
+| General Knowledge | 10,000 | 10.0% |
+| Conversation | 8,000 | 8.0% |
+| Reasoning | 8,000 | 8.0% |
+| Explanation | 8,000 | 8.0% |
+| Advice | 6,000 | 6.0% |
+| Question Answering | 5,000 | 5.0% |
+| Instructions | 5,000 | 5.0% |
+
+## Dataset Structure
+
+### Data Fields
+
+```json
+{
+  "id": "unique_identifier",
+  "category": "primary_category",
+  "subcategory": "specific_subcategory",
+  "instruction": "User's question or request",
+  "response": "Detailed AI assistant response",
+  "metadata": {
+    "field1": "value1",
+    "field2": "value2"
+  }
+}
+```
+
+### Field Descriptions
+
+- **id**: Unique identifier for each example
+- **category**: Main category (coding, science, math, etc.)
+- **subcategory**: More specific classification within the category
+- **instruction**: The user's input, question, or request
+- **response**: The AI assistant's detailed response
+- **metadata**: Additional context-specific information
+
+## Categories Explained
+
+### 1. Coding (20,000 examples)
+Programming examples across multiple languages including:
+- JavaScript, Python, TypeScript, Java, C++, Go, Rust, Ruby, PHP, Swift, Kotlin
+- Topics: algorithms, data structures, code explanations, debugging, best practices
+- Includes actual code snippets with explanations
+
+### 2. Science (10,000 examples)
+Scientific concepts covering:
+- **Physics**: Quantum mechanics, relativity, thermodynamics, mechanics
+- **Chemistry**: Periodic table, chemical reactions, molecular structures
+- **Biology**: DNA, evolution, cellular processes, ecosystems
+- **Astronomy**: Cosmology, stellar physics, planetary science
+
+### 3. Mathematics (10,000 examples)
+Mathematical concepts and problem-solving:
+- **Algebra**: Equations, inequalities, functions
+- **Calculus**: Derivatives, integrals, limits
+- **Geometry**: Shapes, theorems, spatial reasoning
+- **Trigonometry**: Functions, identities, applications
+
+### 4. Image Generation (10,000 examples)
+Detailed prompts for AI art generation including:
+- Style specifications (photorealistic, digital art, oil painting, etc.)
+- Subject descriptions
+- Lighting and mood settings
+- Camera angles and composition
+- Quality modifiers
+
+### 5. General Knowledge (10,000 examples)
+Broad knowledge covering:
+- Historical events and timelines
+- Geography and world facts
+- Countries, capitals, and cultural information
+- Current affairs and general trivia
+
+### 6. Reasoning (8,000 examples)
+Logic and problem-solving:
+- Logic puzzles and riddles
+- Sequence patterns
+- Deductive reasoning
+- Critical thinking exercises
+
+### 7. Conversation (8,000 examples)
+Natural dialogue patterns:
+- Greetings and social interaction
+- Clarification requests
+- Follow-up questions
+- Context-aware responses
+
+### 8. Explanation (8,000 examples)
+Technical concept explanations:
+- Computing concepts (APIs, databases, cloud)
+- Programming paradigms
+- Technical terminology
+- ELI5 (Explain Like I'm 5) style explanations
+
+### 9. Advice (6,000 examples)
+Practical guidance on:
+- Productivity and time management
+- Health and wellness
+- Learning strategies
+- Career development
+
+### 10. Question Answering (5,000 examples)
+Deep questions and thoughtful answers on:
+- Philosophy and meaning
+- Life guidance
+- Complex topics
+- How-to guides
+
+### 11. Instructions (5,000 examples)
+Creative and practical tasks:
+- Writing exercises
+- Creative prompts
+- Step-by-step guides
+- Task completion
+
+## Usage
+
+### Loading with Hugging Face Datasets
+
+```python
+from datasets import load_dataset
+
+# Load the full dataset
+dataset = load_dataset("your-username/omnimind-100k")
+
+# Load specific split
+train_data = dataset["train"]
+
+# Access examples
+for example in train_data:
+    print(f"Instruction: {example['instruction']}")
+    print(f"Response: {example['response']}")
+    break
+```
+
+### Loading from JSONL
+
+```python
+import json
+
+data = []
+with open('omnimind-100k.jsonl', 'r') as f:
+    for line in f:
+        data.append(json.loads(line))
+
+print(f"Loaded {len(data)} examples")
+```
+
+### Using with the OmniMind AI Simulator
+
+```javascript
+const { OmniMindAPI } = require('./omnimind-ai');
+
+async function main() {
+  const api = new OmniMindAPI();
+  await api.init();
+
+  const answer = await api.ask("How do I implement binary search?");
+  console.log(answer);
+}
+
+main();
+```
+
+## Example Entries
+
+### Coding Example
+```json
+{
+  "category": "coding",
+  "subcategory": "javascript",
+  "instruction": "Write a JavaScript function to implement Binary Search.",
+  "response": "Here's a JavaScript implementation of Binary Search:\n\n```javascript\nfunction binarySearch(arr, target) {\n  let left = 0;\n  let right = arr.length - 1;\n\n  while (left <= right) {\n    const mid = Math.floor((left + right) / 2);\n    if (arr[mid] === target) return mid;\n    else if (arr[mid] < target) left = mid + 1;\n    else right = mid - 1;\n  }\n  return -1;\n}\n```\n\nTime Complexity: O(log n)"
+}
+```
+
+### Image Generation Example
+```json
+{
+  "category": "image_generation",
+  "subcategory": "photorealistic",
+  "instruction": "Create an image of a landscape",
+  "response": "Here's a detailed image generation prompt:\n\n**Prompt:**\n\"photorealistic landscape, serene atmosphere, golden hour lighting, wide angle shot, 8K, ultra detailed, sharp focus\"\n\n**Breakdown:**\n- Style: photorealistic\n- Subject: landscape\n- Mood: serene\n- Lighting: golden hour"
+}
+```
+
+### Math Example
+```json
+{
+  "category": "math",
+  "subcategory": "geometry",
+  "instruction": "What is the Pythagorean Theorem?",
+  "response": "The Pythagorean Theorem states: a² + b² = c²\n\nWhere:\n- a and b are the legs of a right triangle\n- c is the hypotenuse (longest side)\n\nThis fundamental theorem is used to calculate distances and find unknown sides in right triangles."
+}
+```
+
+## Training Recommendations
+
+### Fine-tuning LLMs
+- Recommended batch size: 4-8 (adjust based on model size)
+- Learning rate: 1e-5 to 5e-5
+- Epochs: 2-4
+- Use mixed precision (fp16) for efficiency
+
+### Prompt Format
+For instruction-tuning, use this format:
+```
+### Instruction:
+{instruction}
+
+### Response:
+{response}
+```
+
+### Data Filtering
+Filter by category for domain-specific fine-tuning:
+```python
+coding_data = [ex for ex in data if ex['category'] == 'coding']
+```
+
+## Files Included
+
+| File | Description |
+|------|-------------|
+| `omnimind-100k.jsonl` | Main dataset (100K examples) |
+| `dataset-stats.json` | Category statistics |
+| `generate-dataset.js` | Dataset generator script |
+| `omnimind-ai.js` | Interactive AI simulator |
+| `README.md` | This documentation |
+
+## Limitations
+
+- **Language**: Currently English only
+- **Knowledge Cutoff**: Information reflects the generation date
+- **Image Generation**: Prompts only, not actual images
+- **Code**: May contain simplified examples not suitable for production
+
+## Citation
+
+```bibtex
+@dataset{omnimind100k,
+  title={OmniMind-100K: A Multi-Domain Instruction Dataset},
+  year={2024},
+  description={100,000 instruction-response pairs for training general-purpose AI assistants}
+}
+```
+
+## License
+
+This dataset is released under the MIT License. You are free to use, modify, and distribute it for both commercial and non-commercial purposes.
+
+## Contributing
+
+Contributions are welcome! To improve the dataset:
+1. Fork the repository
+2. Add new examples or categories
+3. Submit a pull request
+
+## Acknowledgments
+
+This dataset was created to demonstrate comprehensive instruction-tuning data generation for AI assistants. It covers a broad range of topics to help create more capable and helpful AI systems.

dataset-stats.json

@@ -0,0 +1,16 @@
+{
+  "total": 100000,
+  "categories": {
+    "math": 10000,
+    "question_answering": 5000,
+    "coding": 20000,
+    "reasoning": 8000,
+    "science": 10000,
+    "general_knowledge": 10000,
+    "advice": 6000,
+    "conversation": 8000,
+    "image_generation": 10000,
+    "explanation": 8000,
+    "instructions": 5000
+  }
+}

omnimind-100k.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a4b951761133b56dd70c18befa6e5e1fc35cccaea9b45ce506b36caa11c127b
+size 64474444

omnimind-ai.js

@@ -0,0 +1,652 @@
+/**
+ * OmniMind AI Simulator
+ *
+ * A JavaScript-based AI assistant that uses the OmniMind-100K dataset
+ * to answer questions on coding, science, math, image generation,
+ * general knowledge, and more.
+ *
+ * Usage: node omnimind-ai.js
+ */
+
+const fs = require('fs');
+const readline = require('readline');
+
+// ============================================
+// CONFIGURATION
+// ============================================
+
+const CONFIG = {
+  datasetPath: './omnimind-100k.jsonl',
+  indexPath: './omnimind-index.json',
+  similarityThreshold: 0.3,
+  maxResults: 5,
+  modelName: 'OmniMind-100K',
+  version: '1.0.0'
+};
+
+// ============================================
+// TEXT PROCESSING UTILITIES
+// ============================================
+
+class TextProcessor {
+  static stopWords = new Set([
+    'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare',
+    'ought', 'used', 'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by',
+    'from', 'as', 'into', 'through', 'during', 'before', 'after', 'above',
+    'below', 'between', 'under', 'again', 'further', 'then', 'once', 'here',
+    'there', 'when', 'where', 'why', 'how', 'all', 'each', 'few', 'more',
+    'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own',
+    'same', 'so', 'than', 'too', 'very', 'just', 'and', 'but', 'if', 'or',
+    'because', 'until', 'while', 'this', 'that', 'these', 'those', 'what',
+    'which', 'who', 'whom', 'it', 'its', 'i', 'me', 'my', 'myself', 'we',
+    'our', 'you', 'your', 'he', 'him', 'his', 'she', 'her', 'they', 'them'
+  ]);
+
+  static tokenize(text) {
+    return text
+      .toLowerCase()
+      .replace(/[^\w\s]/g, ' ')
+      .split(/\s+/)
+      .filter(word => word.length > 1 && !this.stopWords.has(word));
+  }
+
+  static extractKeywords(text) {
+    const tokens = this.tokenize(text);
+    const frequency = {};
+
+    tokens.forEach(token => {
+      frequency[token] = (frequency[token] || 0) + 1;
+    });
+
+    return Object.entries(frequency)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 10)
+      .map(([word]) => word);
+  }
+
+  static calculateSimilarity(text1, text2) {
+    const tokens1 = new Set(this.tokenize(text1));
+    const tokens2 = new Set(this.tokenize(text2));
+
+    if (tokens1.size === 0 || tokens2.size === 0) return 0;
+
+    const intersection = new Set([...tokens1].filter(x => tokens2.has(x)));
+    const union = new Set([...tokens1, ...tokens2]);
+
+    // Jaccard similarity
+    const jaccard = intersection.size / union.size;
+
+    // Boost for exact keyword matches
+    const keywordBoost = intersection.size / Math.min(tokens1.size, tokens2.size);
+
+    return (jaccard + keywordBoost) / 2;
+  }
+
+  static fuzzyMatch(query, text) {
+    const queryLower = query.toLowerCase();
+    const textLower = text.toLowerCase();
+
+    // Direct substring match
+    if (textLower.includes(queryLower)) return 1.0;
+
+    // Check individual words
+    const queryWords = queryLower.split(/\s+/);
+    const matchCount = queryWords.filter(word => textLower.includes(word)).length;
+
+    return matchCount / queryWords.length;
+  }
+}
+
+// ============================================
+// KNOWLEDGE BASE
+// ============================================
+
+class KnowledgeBase {
+  constructor() {
+    this.entries = [];
+    this.index = {
+      byCategory: {},
+      bySubcategory: {},
+      byKeyword: {}
+    };
+    this.loaded = false;
+  }
+
+  async load() {
+    console.log('📚 Loading OmniMind knowledge base...');
+
+    // Check if dataset exists
+    if (!fs.existsSync(CONFIG.datasetPath)) {
+      console.log('⚠️  Dataset not found. Please run: node generate-dataset.js');
+      return false;
+    }
+
+    // Check for cached index
+    if (fs.existsSync(CONFIG.indexPath)) {
+      console.log('📑 Loading cached index...');
+      const cached = JSON.parse(fs.readFileSync(CONFIG.indexPath, 'utf-8'));
+      this.entries = cached.entries;
+      this.index = cached.index;
+      this.loaded = true;
+      console.log(`✅ Loaded ${this.entries.length.toLocaleString()} entries from cache`);
+      return true;
+    }
+
+    // Load and index the dataset
+    const data = fs.readFileSync(CONFIG.datasetPath, 'utf-8');
+    const lines = data.trim().split('\n');
+
+    let processed = 0;
+    const total = lines.length;
+
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        this.addEntry(entry);
+        processed++;
+
+        if (processed % 10000 === 0) {
+          process.stdout.write(`\r   Processing: ${processed.toLocaleString()}/${total.toLocaleString()}`);
+        }
+      } catch (e) {
+        // Skip malformed entries
+      }
+    }
+
+    console.log(`\n✅ Loaded ${this.entries.length.toLocaleString()} entries`);
+
+    // Cache the index
+    console.log('💾 Caching index for faster loading...');
+    fs.writeFileSync(CONFIG.indexPath, JSON.stringify({
+      entries: this.entries,
+      index: this.index
+    }));
+
+    this.loaded = true;
+    return true;
+  }
+
+  addEntry(entry) {
+    const idx = this.entries.length;
+    this.entries.push(entry);
+
+    // Index by category
+    if (!this.index.byCategory[entry.category]) {
+      this.index.byCategory[entry.category] = [];
+    }
+    this.index.byCategory[entry.category].push(idx);
+
+    // Index by subcategory
+    if (entry.subcategory) {
+      if (!this.index.bySubcategory[entry.subcategory]) {
+        this.index.bySubcategory[entry.subcategory] = [];
+      }
+      this.index.bySubcategory[entry.subcategory].push(idx);
+    }
+
+    // Index by keywords
+    const keywords = TextProcessor.extractKeywords(entry.instruction);
+    keywords.forEach(keyword => {
+      if (!this.index.byKeyword[keyword]) {
+        this.index.byKeyword[keyword] = [];
+      }
+      this.index.byKeyword[keyword].push(idx);
+    });
+  }
+
+  search(query, options = {}) {
+    const { category, maxResults = CONFIG.maxResults } = options;
+
+    const keywords = TextProcessor.extractKeywords(query);
+    const candidateIndices = new Set();
+
+    // Find candidates by keywords
+    keywords.forEach(keyword => {
+      const indices = this.index.byKeyword[keyword] || [];
+      indices.forEach(idx => candidateIndices.add(idx));
+    });
+
+    // If category specified, filter by category
+    if (category && this.index.byCategory[category]) {
+      const categoryIndices = new Set(this.index.byCategory[category]);
+      candidateIndices.forEach(idx => {
+        if (!categoryIndices.has(idx)) {
+          candidateIndices.delete(idx);
+        }
+      });
+    }
+
+    // If no keyword matches, search all entries (limited)
+    if (candidateIndices.size === 0) {
+      const sampleSize = Math.min(5000, this.entries.length);
+      for (let i = 0; i < sampleSize; i++) {
+        candidateIndices.add(Math.floor(Math.random() * this.entries.length));
+      }
+    }
+
+    // Score candidates
+    const scored = [];
+    candidateIndices.forEach(idx => {
+      const entry = this.entries[idx];
+      const similarity = TextProcessor.calculateSimilarity(query, entry.instruction);
+      const fuzzy = TextProcessor.fuzzyMatch(query, entry.instruction);
+      const score = (similarity * 0.6) + (fuzzy * 0.4);
+
+      if (score > CONFIG.similarityThreshold) {
+        scored.push({ entry, score, idx });
+      }
+    });
+
+    // Sort by score and return top results
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, maxResults);
+  }
+
+  getRandomEntry(category) {
+    let pool = this.entries;
+
+    if (category && this.index.byCategory[category]) {
+      const indices = this.index.byCategory[category];
+      pool = indices.map(idx => this.entries[idx]);
+    }
+
+    return pool[Math.floor(Math.random() * pool.length)];
+  }
+
+  getCategories() {
+    return Object.keys(this.index.byCategory);
+  }
+
+  getStats() {
+    const stats = {
+      total: this.entries.length,
+      categories: {}
+    };
+
+    Object.entries(this.index.byCategory).forEach(([cat, indices]) => {
+      stats.categories[cat] = indices.length;
+    });
+
+    return stats;
+  }
+}
+
+// ============================================
+// AI ASSISTANT
+// ============================================
+
+class OmniMindAI {
+  constructor() {
+    this.kb = new KnowledgeBase();
+    this.context = [];
+    this.maxContextLength = 5;
+  }
+
+  async initialize() {
+    const success = await this.kb.load();
+    if (!success) {
+      throw new Error('Failed to load knowledge base');
+    }
+    return this;
+  }
+
+  async respond(userInput) {
+    const input = userInput.trim();
+
+    // Handle special commands
+    if (input.startsWith('/')) {
+      return this.handleCommand(input);
+    }
+
+    // Handle greetings
+    if (this.isGreeting(input)) {
+      return this.getGreetingResponse();
+    }
+
+    // Handle farewells
+    if (this.isFarewell(input)) {
+      return this.getFarewellResponse();
+    }
+
+    // Handle thanks
+    if (this.isThanks(input)) {
+      return this.getThanksResponse();
+    }
+
+    // Detect intent and category
+    const intent = this.detectIntent(input);
+
+    // Search knowledge base
+    const results = this.kb.search(input, { category: intent.category });
+
+    if (results.length > 0) {
+      // Return best matching response
+      const best = results[0];
+      this.addToContext(input, best.entry.response);
+      return this.formatResponse(best.entry, best.score);
+    }
+
+    // Generate fallback response
+    return this.getFallbackResponse(input, intent);
+  }
+
+  handleCommand(input) {
+    const [command, ...args] = input.slice(1).split(' ');
+
+    switch (command.toLowerCase()) {
+      case 'help':
+        return this.getHelpMessage();
+
+      case 'stats':
+        return this.getStatsMessage();
+
+      case 'categories':
+        return this.getCategoriesMessage();
+
+      case 'random':
+        const category = args[0];
+        const entry = this.kb.getRandomEntry(category);
+        return `**Random Knowledge:**\n\n**Q:** ${entry.instruction}\n\n**A:** ${entry.response}`;
+
+      case 'clear':
+        this.context = [];
+        return 'Context cleared. Starting fresh conversation.';
+
+      case 'about':
+        return this.getAboutMessage();
+
+      default:
+        return `Unknown command: /${command}\nType /help for available commands.`;
+    }
+  }
+
+  detectIntent(input) {
+    const inputLower = input.toLowerCase();
+
+    // Coding indicators
+    if (/\b(code|program|function|class|javascript|python|java|typescript|bug|debug|algorithm|api|database|sql|html|css|react|node|git)\b/i.test(input)) {
+      return { category: 'coding', confidence: 0.8 };
+    }
+
+    // Math indicators
+    if (/\b(math|calculate|equation|formula|algebra|geometry|calculus|trigonometry|derivative|integral|solve|number|percent)\b/i.test(input)) {
+      return { category: 'math', confidence: 0.8 };
+    }
+
+    // Science indicators
+    if (/\b(science|physics|chemistry|biology|atom|molecule|cell|dna|gravity|energy|evolution|quantum|element)\b/i.test(input)) {
+      return { category: 'science', confidence: 0.8 };
+    }
+
+    // Image generation indicators
+    if (/\b(image|picture|photo|draw|paint|art|generate|create|design|style|visual|render|illustration)\b/i.test(input)) {
+      return { category: 'image_generation', confidence: 0.8 };
+    }
+
+    // Reasoning indicators
+    if (/\b(puzzle|logic|riddle|think|reason|solve|problem|brain teaser|sequence|pattern)\b/i.test(input)) {
+      return { category: 'reasoning', confidence: 0.7 };
+    }
+
+    // Advice indicators
+    if (/\b(advice|recommend|suggest|should i|how can i|tips|help me|improve|better)\b/i.test(input)) {
+      return { category: 'advice', confidence: 0.6 };
+    }
+
+    // General question indicators
+    if (/^(what|who|where|when|why|how|which|is|are|can|do|does)/i.test(input)) {
+      return { category: 'question_answering', confidence: 0.5 };
+    }
+
+    return { category: null, confidence: 0 };
+  }
+
+  isGreeting(input) {
+    return /^(hi|hello|hey|greetings|good morning|good afternoon|good evening|howdy|what's up|sup)\b/i.test(input);
+  }
+
+  isFarewell(input) {
+    return /^(bye|goodbye|see you|farewell|take care|later|cya|gtg)\b/i.test(input);
+  }
+
+  isThanks(input) {
+    return /^(thanks|thank you|thx|appreciate|grateful)\b/i.test(input);
+  }
+
+  getGreetingResponse() {
+    const responses = [
+      "Hello! I'm OmniMind, your AI assistant. I can help you with coding, math, science, image generation prompts, and much more. What would you like to know?",
+      "Hi there! Welcome to OmniMind. I'm trained on 100,000 examples covering various topics. How can I assist you today?",
+      "Hey! Great to see you. I'm here to help with questions, explanations, coding, creative tasks, and more. What's on your mind?",
+      "Greetings! I'm OmniMind AI - ask me anything about programming, science, math, or get creative prompts. What can I do for you?"
+    ];
+    return responses[Math.floor(Math.random() * responses.length)];
+  }
+
+  getFarewellResponse() {
+    const responses = [
+      "Goodbye! It was great chatting with you. Come back anytime you have questions!",
+      "See you later! Feel free to return whenever you need help.",
+      "Take care! I'll be here if you need any assistance in the future.",
+      "Farewell! Thanks for using OmniMind. Have a great day!"
+    ];
+    return responses[Math.floor(Math.random() * responses.length)];
+  }
+
+  getThanksResponse() {
+    const responses = [
+      "You're welcome! I'm happy I could help. Is there anything else you'd like to know?",
+      "My pleasure! Feel free to ask if you have more questions.",
+      "Glad I could assist! Don't hesitate to ask about anything else.",
+      "Anytime! That's what I'm here for. What else can I help with?"
+    ];
+    return responses[Math.floor(Math.random() * responses.length)];
+  }
+
+  getFallbackResponse(input, intent) {
+    const category = intent.category ? ` about ${intent.category}` : '';
+
+    const responses = [
+      `I don't have a specific answer for that question${category}, but I can try to help! Could you rephrase your question or provide more details?`,
+      `Interesting question! While I may not have an exact match in my knowledge base, I'd be happy to help explore this topic. Can you tell me more about what you're looking for?`,
+      `I'm not sure I have the perfect answer for this, but let me suggest some related topics:\n- Try asking about specific programming languages\n- Ask about math formulas or scientific concepts\n- Request image generation prompts\n- Explore reasoning puzzles\n\nWhat interests you most?`
+    ];
+
+    return responses[Math.floor(Math.random() * responses.length)];
+  }
+
+  formatResponse(entry, score) {
+    let response = entry.response;
+
+    // Add category context if relevant
+    if (score < 0.7) {
+      response = `Based on my knowledge about **${entry.category.replace('_', ' ')}**:\n\n${response}`;
+    }
+
+    return response;
+  }
+
+  addToContext(userInput, response) {
+    this.context.push({ user: userInput, assistant: response });
+    if (this.context.length > this.maxContextLength) {
+      this.context.shift();
+    }
+  }
+
+  getHelpMessage() {
+    return `
+**OmniMind AI Help**
+
+I can assist you with many topics including:
+• **Coding** - Programming questions, algorithms, code examples
+• **Math** - Formulas, calculations, problem solving
+• **Science** - Physics, chemistry, biology, astronomy
+• **Image Generation** - Create detailed prompts for AI art
+• **General Knowledge** - History, geography, facts
+• **Reasoning** - Logic puzzles, brain teasers
+• **Advice** - Productivity, health, learning tips
+
+**Commands:**
+• /help - Show this help message
+• /stats - Show knowledge base statistics
+• /categories - List all categories
+• /random [category] - Get random knowledge
+• /about - About OmniMind
+• /clear - Clear conversation context
+
+Just ask me anything!
+`;
+  }
+
+  getStatsMessage() {
+    const stats = this.kb.getStats();
+    let message = `**OmniMind Knowledge Base Statistics**\n\nTotal entries: ${stats.total.toLocaleString()}\n\n**By Category:**\n`;
+
+    Object.entries(stats.categories)
+      .sort((a, b) => b[1] - a[1])
+      .forEach(([cat, count]) => {
+        const pct = ((count / stats.total) * 100).toFixed(1);
+        message += `• ${cat.replace('_', ' ')}: ${count.toLocaleString()} (${pct}%)\n`;
+      });
+
+    return message;
+  }
+
+  getCategoriesMessage() {
+    const categories = this.kb.getCategories();
+    return `**Available Categories:**\n\n${categories.map(c => `• ${c.replace('_', ' ')}`).join('\n')}\n\nYou can ask questions related to any of these topics!`;
+  }
+
+  getAboutMessage() {
+    return `
+**About OmniMind AI**
+
+Version: ${CONFIG.version}
+Model: ${CONFIG.modelName}
+
+OmniMind is a knowledge-based AI assistant trained on 100,000 high-quality examples covering:
+- Programming and Software Development
+- Mathematics and Problem Solving
+- Science (Physics, Chemistry, Biology, Astronomy)
+- Image Generation Prompts
+- General Knowledge and Trivia
+- Logical Reasoning and Puzzles
+- Practical Advice and Tips
+
+This is a demonstration of how dataset-driven AI can provide helpful, accurate responses across many domains.
+
+Created for educational and demonstration purposes.
+`;
+  }
+}
+
+// ============================================
+// INTERACTIVE CLI
+// ============================================
+
+async function startInteractiveSession() {
+  console.log('\n' + '='.repeat(60));
+  console.log('   🧠 OmniMind AI - 100K Knowledge Base Assistant');
+  console.log('='.repeat(60));
+  console.log('\nInitializing...\n');
+
+  const ai = new OmniMindAI();
+
+  try {
+    await ai.initialize();
+  } catch (error) {
+    console.error('Failed to initialize:', error.message);
+    process.exit(1);
+  }
+
+  console.log('\n✨ OmniMind is ready! Type your questions or /help for commands.');
+  console.log('   Type "exit" or "quit" to end the session.\n');
+  console.log('-'.repeat(60) + '\n');
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const prompt = () => {
+    rl.question('\n🧑 You: ', async (input) => {
+      if (!input || input.trim() === '') {
+        prompt();
+        return;
+      }
+
+      const trimmed = input.trim().toLowerCase();
+      if (trimmed === 'exit' || trimmed === 'quit') {
+        console.log('\n👋 Goodbye! Thanks for using OmniMind AI.\n');
+        rl.close();
+        process.exit(0);
+      }
+
+      try {
+        const response = await ai.respond(input);
+        console.log('\n🤖 OmniMind:', response);
+      } catch (error) {
+        console.log('\n⚠️  Error:', error.message);
+      }
+
+      prompt();
+    });
+  };
+
+  prompt();
+}
+
+// ============================================
+// PROGRAMMATIC API
+// ============================================
+
+class OmniMindAPI {
+  constructor() {
+    this.ai = null;
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return this;
+
+    this.ai = new OmniMindAI();
+    await this.ai.initialize();
+    this.initialized = true;
+    return this;
+  }
+
+  async ask(question) {
+    if (!this.initialized) {
+      await this.init();
+    }
+    return this.ai.respond(question);
+  }
+
+  async search(query, options) {
+    if (!this.initialized) {
+      await this.init();
+    }
+    return this.ai.kb.search(query, options);
+  }
+
+  getStats() {
+    if (!this.initialized) {
+      throw new Error('API not initialized. Call init() first.');
+    }
+    return this.ai.kb.getStats();
+  }
+}
+
+// ============================================
+// EXPORTS AND MAIN
+// ============================================
+
+// Export for programmatic use
+module.exports = { OmniMindAPI, OmniMindAI, KnowledgeBase, TextProcessor };
+
+// Run interactive session if executed directly
+if (require.main === module) {
+  startInteractiveSession();
+}