Upload folder using huggingface_hub

README.md

@@ -18,12 +18,32 @@ tags:
 pretty_name: OmniMind-100K
 size_categories:
   - 100K<n<1M
+dataset_info:
+  features:
+    - name: id
+      dtype: string
+    - name: category
+      dtype: string
+    - name: subcategory
+      dtype: string
+    - name: instruction
+      dtype: string
+    - name: response
+      dtype: string
+    - name: metadata
+      dtype: string
+  splits:
+    - name: train
+      num_examples: 100000
 ---
 
 # OmniMind-100K
 
 A comprehensive, multi-domain instruction-following dataset with **100,000 high-quality examples** for training general-purpose AI assistants.
 
+[![Dataset on HuggingFace](https://img.shields.io/badge/HuggingFace-Dataset-yellow)](https://huggingface.co/datasets/orbisAI/OmniMind)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
 ## 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.
@@ -35,8 +55,9 @@ OmniMind-100K is designed to create well-rounded AI models capable of handling d
 | **Total Examples** | 100,000 |
 | **Languages** | English |
 | **License** | MIT |
-| **Format** | JSONL |
+| **Format** | JSONL / Parquet |
 | **Task Types** | Instruction Following, Q&A, Conversation, Reasoning |
+| **Created By** | [orbisAI](https://huggingface.co/orbisAI) |
 
 ### Category Distribution
 
@@ -54,40 +75,77 @@ OmniMind-100K is designed to create well-rounded AI models capable of handling d
 | Question Answering | 5,000 | 5.0% |
 | Instructions | 5,000 | 5.0% |
 
+## Quick Start
+
+### Loading with Hugging Face Datasets
+
+```python
+from datasets import load_dataset
+
+# Load the dataset
+dataset = load_dataset("orbisAI/OmniMind")
+
+# Access the training split
+train_data = dataset["train"]
+
+# View an example
+print(train_data[0])
+
+# Filter by category
+coding_examples = train_data.filter(lambda x: x['category'] == 'coding')
+```
+
+### Streaming (Memory Efficient)
+
+```python
+from datasets import load_dataset
+
+# Stream without downloading entire dataset
+dataset = load_dataset("orbisAI/OmniMind", streaming=True)
+
+for example in dataset["train"]:
+    print(example["instruction"])
+    print(example["response"])
+    break
+```
+
 ## 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",
+  "id": "abc123xyz",
+  "category": "coding",
+  "subcategory": "python",
+  "instruction": "Write a function to reverse a string",
+  "response": "Here's a Python function to reverse a string:\n\n```python\ndef reverse_string(s):\n    return s[::-1]\n```",
   "metadata": {
-    "field1": "value1",
-    "field2": "value2"
+    "language": "Python",
+    "algorithm": "String Manipulation",
+    "complexity": "O(n)"
   }
 }
 ```
 
 ### 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
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | string | Unique identifier for each example |
+| `category` | string | Main category (11 categories) |
+| `subcategory` | string | Specific classification (52 subcategories) |
+| `instruction` | string | User's question or request |
+| `response` | string | Detailed AI assistant response |
+| `metadata` | dict | Context-specific information (varies by category) |
 
 ## 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
+Programming examples across multiple languages:
+- **Languages**: JavaScript, Python, TypeScript, Java, C++, C#, Go, Rust, Ruby, PHP, Swift, Kotlin
+- **Topics**: Algorithms, data structures, code explanations, debugging, best practices
+- **Includes**: Actual code snippets with detailed explanations
 
 ### 2. Science (10,000 examples)
 Scientific concepts covering:
@@ -104,19 +162,19 @@ Mathematical concepts and problem-solving:
 - **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
+Detailed prompts for AI art generation:
+- Style specifications (photorealistic, digital art, oil painting, anime, etc.)
+- Subject descriptions with rich details
 - Lighting and mood settings
 - Camera angles and composition
-- Quality modifiers
+- Quality modifiers (8K, ultra detailed, etc.)
 
 ### 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
+- General trivia
 
 ### 6. Reasoning (8,000 examples)
 Logic and problem-solving:
@@ -147,7 +205,7 @@ Practical guidance on:
 - Career development
 
 ### 10. Question Answering (5,000 examples)
-Deep questions and thoughtful answers on:
+Deep questions and thoughtful answers:
 - Philosophy and meaning
 - Life guidance
 - Complex topics
@@ -160,55 +218,6 @@ Creative and practical tasks:
 - 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
@@ -244,13 +253,28 @@ main();
 ## 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
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
+from datasets import load_dataset
+
+# Load dataset
+dataset = load_dataset("orbisAI/OmniMind")
+
+# Recommended hyperparameters
+training_args = TrainingArguments(
+    per_device_train_batch_size=4,  # Adjust based on GPU memory
+    learning_rate=2e-5,
+    num_train_epochs=3,
+    fp16=True,  # Mixed precision for efficiency
+    gradient_accumulation_steps=4,
+    warmup_ratio=0.1,
+)
+```
 
 ### Prompt Format
 For instruction-tuning, use this format:
+
 ```
 ### Instruction:
 {instruction}
@@ -259,50 +283,64 @@ For instruction-tuning, use this format:
 {response}
 ```
 
+### ChatML Format
+```
+<|im_start|>user
+{instruction}<|im_end|>
+<|im_start|>assistant
+{response}<|im_end|>
+```
+
 ### Data Filtering
 Filter by category for domain-specific fine-tuning:
+
 ```python
-coding_data = [ex for ex in data if ex['category'] == 'coding']
+# Get only coding examples
+coding_data = dataset["train"].filter(lambda x: x['category'] == 'coding')
+
+# Get multiple categories
+selected = dataset["train"].filter(
+    lambda x: x['category'] in ['coding', 'math', 'science']
+)
 ```
 
-## Files Included
+## Use Cases
 
-| 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 |
+- **Fine-tuning LLMs**: Train instruction-following models
+- **Chatbot Development**: Build conversational AI assistants
+- **Domain-Specific Models**: Filter by category for specialized training
+- **Evaluation**: Benchmark model capabilities across domains
+- **Data Augmentation**: Combine with other datasets for improved coverage
 
 ## 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
+- **Image Generation**: Contains prompts only, not actual images
+- **Code Examples**: Some examples are simplified for educational purposes
 
 ## 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}
+@dataset{omnimind2025,
+  author = {orbisAI},
+  title = {OmniMind-100K: A Multi-Domain Instruction Dataset},
+  year = {2025},
+  publisher = {Hugging Face},
+  url = {https://huggingface.co/datasets/orbisAI/OmniMind},
+  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.
+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
+## Links
 
-Contributions are welcome! To improve the dataset:
-1. Fork the repository
-2. Add new examples or categories
-3. Submit a pull request
+- **Dataset**: [huggingface.co/datasets/orbisAI/OmniMind](https://huggingface.co/datasets/orbisAI/OmniMind)
+- **Organization**: [huggingface.co/orbisAI](https://huggingface.co/orbisAI)
 
 ## 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.
+This dataset was created to provide comprehensive instruction-tuning data for AI assistants. It covers a broad range of topics to help create more capable and helpful AI systems.

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();
+}