Upload 2 files

models/neurones_r1.py

@@ -1,10 +1,10 @@
 """
-Neurones R1 1.1 — Advanced Reasoning Model (v2)
-================================================
-Uses dataset examples for better chain-of-thought reasoning.
+Neurones R1 1.1
+===============
+NeuraPrompt's deepest reasoning model with dataset-powered thinking.
 
-This version loads the reasoning dataset and injects relevant
-few-shot examples to improve answer quality.
+Specializes in: complex reasoning, mathematics, code debugging,
+logic problems, step-by-step analysis, competitive programming.
 """
 
 import json
@@ -12,7 +12,6 @@ import random
 import pathlib
 import logging
 from typing import List, Dict, Optional
-from dataclasses import dataclass, field
 
 logger = logging.getLogger("neurones_r1")
 
@@ -20,173 +19,122 @@ logger = logging.getLogger("neurones_r1")
 #  DATASET LOADER (for few-shot examples)
 # ════════════════════════════════════════════════════════════════
 
-class ReasoningDataset:
-    """Loads and manages the reasoning dataset for few-shot prompting."""
-    
-    def __init__(self, dataset_path: Optional[str] = None):
-        self.dataset_path = dataset_path or "datasets/datdistilled_corpus_400k_with_cot-filtered.jsonl.txt"
-        self.data: List[Dict] = []
-        self.loaded = False
+_reasoning_data: List[Dict] = []
+_dataset_loaded = False
+
+def _load_reasoning_dataset(max_samples: int = 3000) -> bool:
+    """Load reasoning dataset for few-shot examples."""
+    global _reasoning_data, _dataset_loaded
     
-    def load(self, max_samples: int = 5000) -> bool:
-        """Load reasoning dataset."""
-        try:
-            path = pathlib.Path(self.dataset_path)
-            if not path.exists():
-                logger.warning(f"Dataset not found: {self.dataset_path}")
-                return False
-            
-            with open(path, "r", encoding="utf-8") as f:
-                for i, line in enumerate(f):
-                    if len(self.data) >= max_samples:
-                        break
-                    line = line.strip()
-                    if not line:
-                        continue
-                    try:
-                        entry = json.loads(line)
-                        if entry.get("thinking") and entry.get("solution"):
-                            self.data.append({
-                                "problem": entry.get("problem", ""),
-                                "thinking": entry.get("thinking", ""),
-                                "solution": entry.get("solution", ""),
-                                "category": entry.get("category", "general"),
-                            })
-                    except:
-                        continue
-            
-            self.loaded = True
-            logger.info(f"✅ Loaded {len(self.data)} reasoning examples for R1")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to load dataset: {e}")
+    try:
+        path = pathlib.Path("distilled_corpus_400k_with_cot-filtered.jsonl.txt")
+        if not path.exists():
+            logger.warning("Reasoning dataset not found")
             return False
-    
-    def get_few_shot_examples(self, category: str = None, n: int = 2) -> str:
-        """Get random few-shot examples, optionally filtered by category."""
-        if not self.loaded or not self.data:
-            return ""
-        
-        pool = self.data
-        if category:
-            filtered = [d for d in self.data if d.get("category") == category]
-            if filtered:
-                pool = filtered
-        
-        samples = random.sample(pool, min(n, len(pool)))
         
-        blocks = []
-        for s in samples:
-            blocks.append(
-                f"### Example\n"
-                f"**Problem:** {s['problem'][:200]}\n\n"
-                f"<think>\n{s['thinking'][:400]}\n</think>\n\n"
-                f"**Answer:** {s['solution'][:300]}"
-            )
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                if len(_reasoning_data) >= max_samples:
+                    break
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                    if entry.get("thinking") and entry.get("solution"):
+                        _reasoning_data.append({
+                            "problem": entry.get("problem", ""),
+                            "thinking": entry.get("thinking", ""),
+                            "solution": entry.get("solution", ""),
+                            "category": entry.get("category", "general"),
+                        })
+                except:
+                    continue
         
-        return "\n\n---\n\n".join(blocks)
+        _dataset_loaded = True
+        logger.info(f"✅ Loaded {len(_reasoning_data)} reasoning examples for R1")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to load reasoning dataset: {e}")
+        return False
+
+def _get_few_shot_examples(n: int = 2) -> str:
+    """Get random few-shot reasoning examples."""
+    if not _dataset_loaded or not _reasoning_data:
+        return ""
+    
+    samples = random.sample(_reasoning_data, min(n, len(_reasoning_data)))
+    
+    blocks = []
+    for s in samples:
+        blocks.append(
+            f"### Example\n"
+            f"**Problem:** {s['problem'][:180]}\n\n"
+            f"<think>\n{s['thinking'][:350]}\n</think>\n\n"
+            f"**Answer:** {s['solution'][:250]}"
+        )
+    
+    return "\n\n---\n\n".join(blocks)
 
+# Load dataset at import time
+_load_reasoning_dataset()
 
 # ════════════════════════════════════════════════════════════════
-#  MODEL CONFIG
+#  MODEL CONFIG (Plain Dictionary - Registry Compatible)
 # ════════════════════════════════════════════════════════════════
 
-@dataclass
-class Model:
-    id: str = "neurones-r1-1.1"
-    display_name: str = "Neurones R1 1.1"
-    version: str = "1.1"
-    tagline: str = "NeuraPrompt's deepest thinker with dataset-powered reasoning."
-    created_by: str = "Andile Mtolo (Toxic Dee Modder)"
+MODEL = {
+    "id": "neurones-r1-1.1",
+    "display_name": "Neurones R1 1.1",
+    "version": "1.1",
+    "release_date": "2026-04-01",
+    "tagline": "NeuraPrompt's deepest thinker with dataset-powered reasoning.",
+    "created_by": "Andile Mtolo (Toxic Dee Modder)",
     
-    groq_model: str = "openai/gpt-oss-120b"
-    max_tokens: int = 1500
-    temperature: float = 0.3
-    context_window: int = 32768
+    "speed": "slow",
+    "speed_label": "🧠 Deep Think",
     
-    can_stream: bool = True
-    can_reason: bool = True
-    can_vision: bool = False
+    "groq_model": "openai/gpt-oss-120b",
+    "max_tokens": 1500,
+    "temperature": 0.3,
     
-    speed: str = "slow"
-    speed_label: str = "🧠 Deep Think"
-    badge_color: str = "#7c4dff"
-    icon: str = "🧠"
+    "can_stream": True,
+    "can_reason": True,
+    "can_vision": False,
+    "can_generate_image": False,
+    "can_search": True,
+    "can_code": True,
+    "can_translate": True,
+    "can_summarise": True,
+    "is_local": False,
     
-    recommended_for: List[str] = field(default_factory=lambda: [
-        "complex reasoning", "mathematics", "step-by-step logic",
-        "code debugging", "research analysis", "competitive programming"
-    ])
+    "context_window": 32768,
+    "rate_limit_rpm": 5,
     
-    not_recommended_for: List[str] = field(default_factory=lambda: [
-        "quick chat", "simple lookups", "image tasks"
-    ])
-
-
-# ════════════════════════════════════════════════════════════════
-#  SYSTEM PROMPT
-# ════════════════════════════════════════════════════════════════
-
-BASE_SYSTEM_PROMPT = """You are **Neurones R1 1.1**, NeuraPrompt's most advanced reasoning model.
-
-Created by: Andile Mtolo (Toxic Dee Modder)
-Company: Alysium Corporation Studios ZA
-
-## Your Role
-You are a **deep thinking specialist**. You excel at complex reasoning, mathematics, logic, code analysis, and step-by-step problem solving.
-
-## How to Think
-For reasoning tasks, always use this format:
-
-<think>
-1. Understand the problem type and given information
-2. Plan your step-by-step approach
-3. Work through the solution carefully
-4. Verify your answer
-</think>
-
-Then give your final answer.
-
-## Rules
-- Show all reasoning steps clearly
-- Never guess numbers or make up facts
-- For code: plan first, then implement
-- Prioritize accuracy
-- Keep responses focused (300-500 words max)
-"""
-
-
-# ════════════════════════════════════════════════════════════════
-#  MODEL INSTANCE
-# ════════════════════════════════════════════════════════════════
-
-# Load dataset for few-shot examples
-reasoning_dataset = ReasoningDataset()
-reasoning_dataset.load(max_samples=3000)
-
-MODEL = Model()
-
-
-def get_system_prompt(user_question: str = "") -> str:
-    """
-    Build dynamic system prompt with relevant few-shot examples.
-    """
-    prompt = BASE_SYSTEM_PROMPT
+    "system_prompt": (
+        "You are Neurones R1 1.1, NeuraPrompt's most advanced reasoning model, "
+        "created by Andile Mtolo (Toxic Dee Modder).\n\n"
+        "You are a deep thinking specialist. For reasoning tasks (math, code, logic, science), "
+        "always use this format:\n\n"
+        "<think>\n"
+        "1. Understand the problem type and given information\n"
+        "2. Plan your step-by-step approach\n"
+        "3. Work through the solution carefully\n"
+        "4. Verify your answer\n"
+        "</think>\n\n"
+        "Then give your final answer.\n\n"
+        "Rules: Show all steps. Never guess numbers. For code, plan then implement. "
+        "Prioritise accuracy. Keep responses focused (300-500 words max)."
+    ),
     
-    # Add few-shot examples if dataset is loaded
-    if reasoning_dataset.loaded and reasoning_dataset.data:
-        examples = reasoning_dataset.get_few_shot_examples(n=2)
-        if examples:
-            prompt += f"\n\n## Examples of Good Reasoning\n{examples}"
+    "badge_color": "#7c4dff",
+    "icon": "🧠",
     
-    prompt += "\n\nNow solve the user's question using the thinking format above."
-    return prompt
-
-
-# ════════════════════════════════════════════════════════════════
-#  EXPORTS (for registry)
-# ════════════════════════════════════════════════════════════════
-
-# This allows the registry to load this model automatically
-__all__ = ["MODEL", "get_system_prompt", "reasoning_dataset"]
+    "recommended_for": [
+        "complex reasoning", "mathematics", "step-by-step logic",
+        "code debugging", "research analysis", "competitive programming"
+    ],
+    "not_recommended_for": [
+        "quick chat", "simple lookups", "image tasks", "general conversation"
+    ],
+}

models/neurones_vision.py

@@ -1,269 +1,138 @@
-#!/usr/bin/env python3
 """
-Neurones Vision 1.0 — Professional Model Configuration v9.0
-Clean, robust, production-ready (2026 best practices)
+Neurones Vision 1.0
+===================
+NeuraPrompt's multimodal model for images and files.
 
-Author: Toxic Dee Modder (Andile Mtolo)
-Company: Alysium Corporation Studios ZA
+Handles: images, documents (PDF/text/code), OCR, file analysis, visual Q&A.
 """
 
 import pathlib
 import json
 import logging
-from dataclasses import dataclass, field
-from typing import List, Dict, Optional
-from datetime import datetime
+from typing import List, Dict
 
-# ════════════════════════════════════════════════════════════════
-#  LOGGING
-# ════════════════════════════════════════════════════════════════
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s | %(levelname)-8s | %(message)s"
-)
 logger = logging.getLogger("neurones_vision")
 
 # ════════════════════════════════════════════════════════════════
-#  DATA STRUCTURES
+#  DATASET SCANNER
 # ════════════════════════════════════════════════════════════════
 
-@dataclass
-class VisionDatasetPair:
-    prompt: str
-    response: str
-    source_file: str
-
+_vision_pairs: List[Dict] = []
 
-@dataclass
-class VisionModelConfig:
-    """Professional configuration for Neurones Vision 1.0"""
-    
-    # Identity
-    id: str = "neurones-vision-1.0"
-    display_name: str = "Neurones Vision 1.0"
-    version: str = "1.2"
-    release_date: str = "2026-04-29"
-    tagline: str = "NeuraPrompt's eyes. Sees, reads, and understands images and files."
-    created_by: str = "Andile Mtolo (Toxic Dee Modder)"
-    
-    # Backend
-    groq_model: str = "meta-llama/llama-4-scout-17b-16e-instruct"
-    max_tokens: int = 4096
-    temperature: float = 0.3
-    context_window: int = 16384
-    
-    # Capabilities (honest declaration)
-    can_vision: bool = True
-    can_files: bool = True
-    can_ocr: bool = True
-    can_document_analysis: bool = True
-    can_visual_qa: bool = True
-    can_generate_image: bool = False  # Not implemented in this version
+def _load_vision_datasets(max_per_file: int = 1000) -> int:
+    """Load vision-related datasets."""
+    global _vision_pairs
     
-    # UI
-    badge_color: str = "#ff6d00"
-    icon: str = "👁️"
-    
-    # Recommended use cases
-    recommended_for: List[str] = field(default_factory=lambda: [
-        "image analysis", "OCR / text extraction", "PDF & document reading",
-        "screenshot analysis", "photo description", "visual Q&A",
-        "chart/diagram understanding", "file content extraction"
-    ])
-    
-    not_recommended_for: List[str] = field(default_factory=lambda: [
-        "general chat", "mathematics", "coding", "real-time search", "creative writing"
-    ])
-
-
-# ════════════════════════════════════════════════════════════════
-#  DATASET SCANNER (Improved)
-# ════════════════════════════════════════════════════════════════
-
-class VisionDatasetLoader:
-    """Smart loader for vision/image-related datasets"""
+    datasets_dir = pathlib.Path(__file__).parent / "datasets"
+    if not datasets_dir.exists():
+        return 0
     
-    _IMAGE_KEYWORDS = {
-        "image", "vision", "visual", "photo", "picture", "img",
-        "caption", "scene", "object", "detection", "classify",
-        "ocr", "document", "diagram", "chart", "screenshot", "pdf"
-    }
+    _IMAGE_KEYWORDS = {"image", "vision", "visual", "photo", "picture", "img", 
+                       "caption", "scene", "object", "ocr", "document", "diagram", "chart"}
     
-    def __init__(self, datasets_dir: Optional[pathlib.Path] = None):
-        self.datasets_dir = datasets_dir or (pathlib.Path(__file__).parent / "datasets")
-        self.pairs: List[VisionDatasetPair] = []
-    
-    def _is_vision_dataset(self, filepath: pathlib.Path) -> bool:
-        """Check if file is vision-related by name and content sample."""
-        name = filepath.stem.lower()
+    count = 0
+    for fp in sorted(datasets_dir.iterdir()):
+        if not fp.is_file():
+            continue
+        suffix = "".join(fp.suffixes).lower()
+        if suffix not in (".jsonl", ".jsonl.txt", ".json", ".txt"):
+            continue
         
-        # Check filename
-        if any(kw in name for kw in self._IMAGE_KEYWORDS):
-            return True
+        name = fp.stem.lower()
+        if not any(kw in name for kw in _IMAGE_KEYWORDS):
+            continue
         
-        # Sample first few lines for content keywords
         try:
-            with open(filepath, "r", encoding="utf-8", errors="replace") as f:
-                sample = f.read(2000).lower()
-                if any(kw in sample for kw in ["image", "caption", "visual", "photo", "screenshot"]):
-                    return True
-        except Exception:
-            pass
-        
-        return False
-    
-    def load(self, max_per_file: int = 1500) -> List[VisionDatasetPair]:
-        """Load all vision-related datasets."""
-        if not self.datasets_dir.exists():
-            logger.warning(f"Datasets directory not found: {self.datasets_dir}")
-            return []
-        
-        self.pairs = []
-        
-        for filepath in sorted(self.datasets_dir.iterdir()):
-            if not filepath.is_file():
-                continue
-                
-            suffix = "".join(filepath.suffixes).lower()
-            if suffix not in (".jsonl", ".jsonl.txt", ".json", ".txt"):
-                continue
-                
-            if not self._is_vision_dataset(filepath):
-                logger.debug(f"Skipping non-vision dataset: {filepath.name}")
-                continue
-            
-            count = self._load_file(filepath, max_per_file)
-            if count:
-                logger.info(f"Loaded {count} vision pairs from {filepath.name}")
-        
-        logger.info(f"Total vision pairs loaded: {len(self.pairs)}")
-        return self.pairs
-    
-    def _load_file(self, filepath: pathlib.Path, max_samples: int) -> int:
-        """Load pairs from a single file."""
-        count = 0
-        try:
-            with open(filepath, "r", encoding="utf-8", errors="replace") as f:
+            with open(fp, "r", encoding="utf-8", errors="replace") as f:
                 for line in f:
-                    if count >= max_samples:
+                    if count >= max_per_file:
                         break
-                        
                     line = line.strip()
                     if not line:
                         continue
-                        
                     try:
                         entry = json.loads(line)
-                    except json.JSONDecodeError:
+                    except:
                         continue
                     
-                    prompt = (
-                        entry.get("question") or 
-                        entry.get("prompt") or 
-                        entry.get("instruction") or 
-                        entry.get("input") or ""
-                    )
-                    response = (
-                        entry.get("answer") or 
-                        entry.get("response") or 
-                        entry.get("output") or 
-                        entry.get("caption") or ""
-                    )
+                    prompt = (entry.get("question") or entry.get("prompt") or 
+                             entry.get("instruction") or entry.get("input") or "")
+                    response = (entry.get("answer") or entry.get("response") or 
+                               entry.get("output") or entry.get("caption") or "")
                     
                     if prompt and response and len(response) > 15:
-                        self.pairs.append(VisionDatasetPair(
-                            prompt=str(prompt)[:200],
-                            response=str(response)[:600],
-                            source_file=filepath.name
-                        ))
+                        _vision_pairs.append({
+                            "prompt": str(prompt)[:180],
+                            "response": str(response)[:500]
+                        })
                         count += 1
-                        
         except Exception as e:
-            logger.warning(f"Failed to read {filepath.name}: {e}")
-        
-        return count
-
-
-# ════════════════════════════════════════════════════════════════
-#  SYSTEM PROMPT (Improved & Professional)
-# ════════════════════════════════════════════════════════════════
-
-VISION_SYSTEM_PROMPT = """You are **Neurones Vision 1.0**, NeuraPrompt's specialized visual analysis model.
-
-Created by: Andile Mtolo (Toxic Dee Modder)
-Company: Alysium Corporation Studios ZA
-
-## Your Role
-You are an expert at analyzing **images and files only**. You do NOT handle general chat, math, or coding.
-
-## Capabilities
-- **Images**: Describe scenes, objects, people, colors, context. Perform OCR on all visible text. Answer visual questions with precision.
-- **Documents/PDFs**: Extract and summarize key content. Identify structure (headings, tables, lists). Answer questions about the document.
-- **Code in Images/Files**: Analyze code screenshots or files. Explain what the code does and identify potential bugs or issues.
-
-## Critical Rules
-1. If the user sends **plain text with no image or file attached**, respond exactly:
-   "I am Neurones Vision 1.0 — I specialize in images and files. Please upload an image or file to analyze. For general chat, switch to Neurones R1, Pro, or Flash using the model selector."
-
-2. If a user asks a general question without an image/file, do not describe any previous image. Just redirect them.
-
-3. If the user removes the image/file mid-conversation, say: "The image/file has been removed. Please upload a new one if you'd like me to analyze something."
-
-4. Never guess or hallucinate details you cannot clearly see.
-
-5. Keep responses clear, structured, and under 400 words unless the user asks for more detail.
-
-6. If analyzing code (from image or file), explain:
-   - What the code does
-   - Any obvious bugs or issues
-   - Suggestions for improvement (if relevant)
-"""
+            logger.warning(f"Failed to read {fp.name}: {e}")
+    
+    logger.info(f"✅ Loaded {len(_vision_pairs)} vision examples")
+    return len(_vision_pairs)
 
+# Load at import
+_load_vision_datasets()
 
 # ════════════════════════════════════════════════════════════════
-#  MAIN CONFIG
+#  MODEL CONFIG (Plain Dictionary - Registry Compatible)
 # ════════════════════════════════════════════════════════════════
 
-MODEL = VisionModelConfig()
-
-# Pre-load vision examples (optional)
-vision_dataset_loader = VisionDatasetLoader()
-VISION_FEW_SHOT_EXAMPLES = vision_dataset_loader.load(max_per_file=800)
-
-
-def get_vision_system_prompt() -> str:
-    """Return the full system prompt with optional few-shot examples."""
-    prompt = VISION_SYSTEM_PROMPT
+MODEL = {
+    "id": "neurones-vision-1.0",
+    "display_name": "Neurones Vision 1.0",
+    "version": "1.2",
+    "release_date": "2026-04-29",
+    "tagline": "NeuraPrompt's eyes. Sees, reads, and understands images and files.",
+    "created_by": "Andile Mtolo (Toxic Dee Modder)",
     
-    if VISION_FEW_SHOT_EXAMPLES:
-        examples_text = "\n\n## Example Analyses\n"
-        for i, pair in enumerate(VISION_FEW_SHOT_EXAMPLES[:3], 1):
-            examples_text += f"\n**Example {i}:**\nQ: {pair.prompt}\nA: {pair.response}\n"
-        prompt += examples_text
+    "speed": "balanced",
+    "speed_label": "👁️ Vision",
     
-    return prompt
-
-
-# ════════════════════════════════════════════════════════════════
-#  QUICK INFO
-# ════════════════════════════════════════════════════════════════
-
-def print_model_info():
-    """Print model information."""
-    print(f"""
-╔══════════════════════════════════════════════════════════════╗
-║  {MODEL.display_name} v{MODEL.version}                    
-║  {MODEL.tagline}           
-╠══════════════════════════════════════════════════════════════╣
-║  Created by: {MODEL.created_by}           
-║  Backend:    {MODEL.groq_model}           
-║  Vision:     {'✅ Enabled' if MODEL.can_vision else '❌ Disabled'}                       
-║  Files:      {'✅ Enabled' if MODEL.can_files else '❌ Disabled'}                       
-╚══════════════════════════════════════════════════════════════╝
-""")
-
-
-if __name__ == "__main__":
-    print_model_info()
-    print(f"Loaded {len(VISION_FEW_SHOT_EXAMPLES)} vision examples from datasets.")
+    "groq_model": "meta-llama/llama-4-scout-17b-16e-instruct",
+    "groq_vision_model": "meta-llama/llama-4-scout-17b-16e-instruct",
+    "max_tokens": 4096,
+    "temperature": 0.3,
+    
+    "can_stream": False,
+    "can_reason": True,
+    "can_vision": True,
+    "can_files": True,
+    "can_generate_image": False,
+    "can_search": False,
+    "can_code": False,
+    "can_translate": True,
+    "can_summarise": True,
+    "is_local": False,
+    "vision_only": True,
+    
+    "context_window": 16384,
+    "rate_limit_rpm": 20,
+    
+    "system_prompt": (
+        "You are Neurones Vision 1.0, NeuraPrompt's specialized visual analysis model, "
+        "created by Andile Mtolo (Toxic Dee Modder). "
+        "Your specialty is images and files ONLY.\n\n"
+        "For IMAGES: describe thoroughly, extract all visible text (OCR), "
+        "identify objects, people, colours, scene type, and context.\n\n"
+        "For FILES/DOCUMENTS: extract text content, summarise key points, "
+        "identify structure (headings, tables, code).\n\n"
+        "If a user sends plain text with NO image or file, respond: "
+        "'I am Neurones Vision 1.0 — I specialise in images and files. "
+        "Please upload an image or file. For general chat, switch to Neurones Pro or Flash.'\n\n"
+        "Never guess when you cannot see something clearly."
+    ),
+    
+    "badge_color": "#ff6d00",
+    "icon": "👁️",
+    
+    "recommended_for": [
+        "image analysis", "OCR / text extraction", "file reading",
+        "document scanning", "photo description", "visual Q&A",
+        "PDF summary", "screenshot analysis",
+    ],
+    "not_recommended_for": [
+        "general chat", "math", "coding", "real-time search",
+    ],
+}