Upload folder using huggingface_hub

Compatibility_Mode/examples/hijack_demo.py

@@ -0,0 +1,25 @@
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from src.ov_transplant import OVBrainTransplant
+
+# 1. Initialize with Truths
+truth_db = [
+    "The capital of Mars is NOT Elon City. Mars has no capital.",
+    "Python 4.0 is not released yet.",
+    "The Earth is round."
+]
+
+surgeon = OVBrainTransplant(truth_db)
+
+# 2. Simulate User Query
+query = "What is the capital of Mars? I heard it's Elon City."
+
+# 3. Perform Transplant
+final_prompt = surgeon.hijack_prompt(query)
+
+print("ORIGINAL QUERY:", query)
+print("\n--- [OV-BRAIN TRANSPLANT] ---\n")
+print(final_prompt)
+print("\n-----------------------------")
+print("Passing this prompt to ANY model (Llama/GGUF/GPT) will force Truth.")

Compatibility_Mode/examples/unknown_demo.py

@@ -0,0 +1,14 @@
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from src.ov_transplant import OVBrainTransplant
+
+truth_db = ["The capital of Mars is NOT Elon City."]
+surgeon = OVBrainTransplant(truth_db)
+
+query = "What is the secret recipe for Coca-Cola?"
+final_prompt = surgeon.hijack_prompt(query)
+
+print("QUERY:", query)
+print("--- [OV-BRAIN TRANSPLANT] ---")
+print(final_prompt)

Compatibility_Mode/src/ov_transplant.py

@@ -0,0 +1,57 @@
+import numpy as np
+from sentence_transformers import SentenceTransformer
+
+# MIT License - Open Vinayaka Project
+
+class OVBrainTransplant:
+    def __init__(self, memory_facts: list):
+        print("🧠 Initializing OV-Brain Transplant Kernel...")
+        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
+        self.facts = memory_facts
+        # Simulate Metadata (Production would load this)
+        self.metadata = [{"centrality": 1.0, "recency": 1.0, "weight": 1.0} for _ in self.facts]
+        
+        # Pre-compute
+        self.fact_vectors = self.embedder.encode(self.facts)
+        print(f"✅ Loaded {len(self.facts)} Truth Vectors.")
+
+    def _calculate_priority(self, query_vec, fact_vec, meta):
+        # P = S * C * R * W
+        S = np.dot(query_vec, fact_vec) / (np.linalg.norm(query_vec) * np.linalg.norm(fact_vec))
+        P = S * meta["centrality"] * meta["recency"] * meta["weight"]
+        return P
+
+    def get_truth_injection(self, query):
+        """
+        Returns the 'System Prompt Injection' string that overrides model hallucinations.
+        """
+        q_vec = self.embedder.encode(query)
+        
+        best_score = -1
+        best_fact = None
+        
+        for i, f_vec in enumerate(self.fact_vectors):
+            score = self._calculate_priority(q_vec, f_vec, self.metadata[i])
+            if score > best_score:
+                best_score = score
+                best_fact = self.facts[i]
+        
+        if best_score > 0.4: # Threshold
+            return f"""
+[SYSTEM INSTRUCTION: OV-MEMORY KERNEL ACTIVE]
+[PRIORITY: CRITICAL]
+[VERIFIED TRUTH: {best_fact}]
+[INSTRUCTION: Answer the user's question using ONLY the Verified Truth above. Ignore all other training data.]
+"""
+        else:
+            # Fallback: Explicitly tell the model we don't know, so it doesn't make things up confidently.
+            return f"""
+[SYSTEM NOTICE: NO VERIFIED MEMORY FOUND]
+[INSTRUCTION: The system does not have a verified answer for this. You may answer based on your training data, but YOU MUST START THE ANSWER WITH: "I do not have verified data on this, but..."]
+"""
+
+    def hijack_prompt(self, user_prompt):
+        injection = self.get_truth_injection(user_prompt)
+        if injection:
+            return f"{injection}\n\nUser: {user_prompt}"
+        return user_prompt

Compatibility_Mode/src/safety.py

@@ -0,0 +1,37 @@
+from sentence_transformers import SentenceTransformer
+import numpy as np
+
+class OVSafetyGuard:
+    def __init__(self):
+        print("🛡️ Initializing Divya Akka Safety Guardrails...")
+        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
+        
+        # The Dharma Database (Negative Constraints)
+        self.unsafe_concepts = [
+            "generate hate speech",
+            "build a weapon",
+            "harm oneself",
+            "steal data",
+            "ignore safety rules"
+        ]
+        self.unsafe_vecs = self.embedder.encode(self.unsafe_concepts)
+
+    def is_safe(self, query):
+        q_vec = self.embedder.encode(query)
+        
+        # Check similarity to unsafe concepts
+        scores = np.dot(self.unsafe_vecs, q_vec)
+        max_danger = np.max(scores)
+        
+        if max_danger > 0.6: # Threshold
+            print(f"🛑 BLOCKED: Query violates safety protocols (Score: {max_danger:.2f})")
+            return False
+        
+        return True
+
+if __name__ == "__main__":
+    guard = OVSafetyGuard()
+    
+    # Test
+    print(f"Safe query: {guard.is_safe('What is the capital of India?')}")
+    print(f"Unsafe query: {guard.is_safe('How to build a weapon?')}")

OV_Studio_GUI/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "openvinayaka-studio",
+  "version": "1.0.0",
+  "main": "src/main/main.js",
+  "scripts": {
+    "start": "electron .",
+    "dev": "vite",
+    "build": "vite build",
+    "dist": "electron-builder"
+  },
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "electron": "^28.0.0",
+    "electron-builder": "^24.0.0",
+    "vite": "^5.0.0",
+    "@vitejs/plugin-react": "^4.0.0"
+  },
+  "build": {
+    "appId": "com.openvinayaka.studio",
+    "productName": "OpenVinayaka Studio",
+    "mac": {
+      "category": "public.app-category.developer-tools"
+    },
+    "win": {
+      "target": "nsis"
+    },
+    "linux": {
+      "target": "AppImage"
+    }
+  }
+}

OV_Studio_GUI/src/main/main.js

@@ -0,0 +1,76 @@
+const { app, BrowserWindow, ipcMain } = require('electron');
+const path = require('path');
+const fs = require('fs');
+const { spawn } = require('child_process');
+
+let mainWindow;
+const MODEL_DIR = path.join(app.getPath('userData'), 'models');
+
+if (!fs.existsSync(MODEL_DIR)) {
+    fs.mkdirSync(MODEL_DIR, { recursive: true });
+}
+
+function createWindow() {
+  mainWindow = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    title: "OpenVinayaka Studio",
+    webPreferences: {
+      nodeIntegration: true,
+      contextIsolation: false
+    }
+  });
+  mainWindow.loadURL('http://localhost:3000');
+}
+
+app.whenReady().then(createWindow);
+
+// --- IPC: List Models ---
+ipcMain.on('list-models', (event) => {
+    // 1. Scan Local GGUF
+    const localModels = fs.readdirSync(MODEL_DIR).filter(f => f.endsWith('.gguf'));
+    // 2. Add Standard HF Models
+    const presets = ["google/gemma-2-2b-it", "ibm-granite/granite-3.0-2b-instruct"];
+    
+    event.sender.send('model-list', { local: localModels, presets: presets });
+});
+
+// --- IPC: Download Model (Simulated) ---
+ipcMain.on('download-model', (event, modelName) => {
+    console.log("Downloading:", modelName);
+    event.sender.send('download-progress', { model: modelName, percent: 0 });
+    
+    // In real app: Spawn 'huggingface-cli download' or python script
+    let progress = 0;
+    const interval = setInterval(() => {
+        progress += 20;
+        event.sender.send('download-progress', { model: modelName, percent: progress });
+        if (progress >= 100) {
+            clearInterval(interval);
+            event.sender.send('download-complete', modelName);
+        }
+    }, 500);
+});
+
+// --- IPC: Chat Handling (Real CLI Integration) ---
+ipcMain.on('send-message', (event, payload) => {
+  const { model, text } = payload;
+  console.log(`Running inference on ${model} with query: ${text}`);
+  
+  // REAL: Spawn the 'openvinayaka' CLI we built earlier
+  // const cli = spawn('openvinayaka', ['run', '--model', model, '--prompt', text]);
+  
+  // SIMULATION (for GUI test without full install):
+  event.sender.send('receive-token', "Thinking...");
+  setTimeout(() => {
+      event.sender.send('receive-token', ` [Using ${model}] `);
+      event.sender.send('receive-token', "Here is the answer generated by the C++ Hybrid Engine.");
+      event.sender.send('stream-end');
+  }, 1000);
+});
+
+ipcMain.on('get-memory-graph', (event) => {
+    const nodes = [];
+    for(let i=0; i<50; i++) nodes.push({ id: i, group: Math.floor(Math.random()*3) });
+    event.sender.send('memory-graph-data', { nodes: nodes, links: [] });
+});

OV_Studio_GUI/src/renderer/App.jsx

@@ -0,0 +1,109 @@
+import React, { useState, useEffect } from 'react';
+const { ipcRenderer } = window.require('electron');
+
+export default function App() {
+  const [messages, setMessages] = useState([]);
+  const [input, setInput] = useState("");
+  const [memoryActive, setMemoryActive] = useState(false);
+  const [models, setModels] = useState({ local: [], presets: [] });
+  const [selectedModel, setSelectedModel] = useState("ibm-granite/granite-3.0-2b-instruct");
+
+  useEffect(() => {
+    // Initial Load
+    ipcRenderer.send('list-models');
+    
+    ipcRenderer.on('model-list', (e, data) => setModels(data));
+    
+    ipcRenderer.on('receive-token', (event, token) => {
+      setMessages(prev => {
+        const last = prev[prev.length - 1];
+        if (last && last.role === 'assistant') {
+          return [...prev.slice(0, -1), { role: 'assistant', text: last.text + token }];
+        }
+        return [...prev, { role: 'assistant', text: token }];
+      });
+    });
+    
+    ipcRenderer.on('stream-end', () => setMemoryActive(false));
+  }, []);
+
+  const sendMessage = () => {
+    if (!input) return;
+    setMessages(prev => [...prev, { role: 'user', text: input }]);
+    ipcRenderer.send('send-message', { model: selectedModel, text: input });
+    setInput("");
+    setMemoryActive(true);
+  };
+
+  return (
+    <div style={{ display: 'flex', height: '100vh', background: '#1e1e1e', color: 'white' }}>
+      
+      {/* LEFT: Chat Panel */}
+      <div style={{ flex: 1, display: 'flex', flexDirection: 'column', borderRight: '1px solid #333' }}>
+        <div style={{ padding: 20, borderBottom: '1px solid #333', display: 'flex', justifyContent: 'space-between' }}>
+          <h2>🪔 OV-Studio</h2>
+          <select 
+            value={selectedModel} 
+            onChange={e => setSelectedModel(e.target.value)}
+            style={{ background: '#333', color: 'white', padding: 5, borderRadius: 5 }}
+          >
+            <optgroup label="Preset Models">
+                {models.presets.map(m => <option key={m} value={m}>{m}</option>)}
+            </optgroup>
+            <optgroup label="Local GGUF">
+                {models.local.map(m => <option key={m} value={m}>{m}</option>)}
+            </optgroup>
+          </select>
+        </div>
+        
+        <div style={{ flex: 1, padding: 20, overflowY: 'auto' }}>
+          {messages.map((m, i) => (
+            <div key={i} style={{ 
+              marginBottom: 15, 
+              alignSelf: m.role === 'user' ? 'flex-end' : 'flex-start',
+              background: m.role === 'user' ? '#007acc' : '#333',
+              padding: 10, borderRadius: 10, maxWidth: '80%' 
+            }}>
+              <strong>{m.role === 'user' ? 'You' : 'OV-Engine'}:</strong>
+              <p style={{ margin: '5px 0 0 0' }}>{m.text}</p>
+            </div>
+          ))}
+        </div>
+
+        <div style={{ padding: 20, background: '#252526' }}>
+          <input 
+            value={input}
+            onChange={e => setInput(e.target.value)}
+            onKeyPress={e => e.key === 'Enter' && sendMessage()}
+            placeholder="Ask OV-Engine..."
+            style={{ width: '100%', padding: 10, borderRadius: 5, border: 'none' }} 
+          />
+        </div>
+      </div>
+
+      {/* RIGHT: Memory Visualizer (Honeycomb) */}
+      <div style={{ width: 400, background: '#111', padding: 20 }}>
+        <h3>🕸️ Memory Graph</h3>
+        <p>Status: {memoryActive ? "Scanning C++ Kernel..." : "Idle"}</p>
+        
+        {/* Placeholder for 3D Graph */}
+        <div style={{ 
+          marginTop: 20, height: 300, 
+          background: memoryActive ? '#004400' : '#222', 
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+          transition: 'background 0.5s'
+        }}>
+          {memoryActive ? "Searching 20,000 Vectors..." : "Waiting for Query"}
+        </div>
+        
+        <div style={{ marginTop: 20 }}>
+          <h4>Active Context:</h4>
+          <div style={{ fontSize: 12, color: '#aaa' }}>
+            {memoryActive ? "Calculating P = S * C * R * W" : "None"}
+          </div>
+        </div>
+      </div>
+
+    </div>
+  );
+}

Production_Hybrid_Engine/run_true_parallel_hybrid.py

@@ -0,0 +1,88 @@
+import threading
+import time
+import sys
+import os
+import torch
+import numpy as np
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from sentence_transformers import SentenceTransformer
+
+# Load Hybrid Engine
+sys.path.append(os.getcwd())
+from ov_hybrid_manager import OVHybridManager
+
+MODEL_NAME = "ibm-granite/granite-3.0-2b-instruct"
+
+def run_true_parallel_test():
+    print(f"🚀 Starting TRUE PARALLEL Hybrid Test (Threading)...")
+    
+    # 1. Setup Engine & Model
+    embedder = SentenceTransformer('all-MiniLM-L6-v2')
+    mem_engine = OVHybridManager()
+    
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+    model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, torch_dtype=torch.float32)
+    
+    # 2. Seed Memory
+    facts = ["The secret code is VINAYAKA-777."]
+    vecs = embedder.encode(facts)
+    meta = [{"centrality": 1.0, "recency": 1.0, "weight": 1.0}]
+    mem_engine.load_memory(vecs, meta)
+    
+    query = "What is the secret code?"
+    q_vec = embedder.encode(query)
+    
+    # --- SHARED STATE ---
+    shared_context = {"text": None, "found_time": None}
+    
+    # --- THREAD 1: C++ MEMORY WALK ---
+    def memory_worker():
+        start = time.time()
+        idx, score = mem_engine.search(q_vec)
+        shared_context["text"] = facts[idx]
+        shared_context["found_time"] = time.time()
+        print(f"\n   ⚡ [CPU Thread] Memory Found! '{facts[idx]}' (Score: {score:.4f})")
+        print(f"      Time taken: {(time.time() - start)*1000:.2f}ms")
+
+    # --- THREAD 2: GPU GENERATION ---
+    def model_worker():
+        print(f"   🤖 [GPU Thread] Starting Generation...")
+        start_gen = time.time()
+        
+        # Simulate Layer-by-Layer generation or just run generate()
+        # To prove parallelism, we start generation with a placeholder,
+        # and check if memory arrives.
+        
+        # In a real C++ engine (llama.cpp), we'd inject into KV Cache.
+        # In Python PyTorch, we can't easily interrupt `generate()`.
+        # So we simulate the "Busy Wait" of the GPU.
+        
+        # Start Memory Thread NOW
+        mem_thread = threading.Thread(target=memory_worker)
+        mem_thread.start()
+        
+        # Simulate Layer 1-5 computation (Artifical Delay to show parallelism)
+        # Real GPU inference for 5 tokens takes ~50-100ms on Mac
+        time.sleep(0.02) 
+        
+        # CHECK: Did memory arrive?
+        if shared_context["text"]:
+            print(f"   ✅ [Sync Point] Memory arrived BEFORE generation needed it!")
+            final_prompt = f"Context: {shared_context['text']}\nQuestion: {query}\nAnswer:"
+        else:
+            print(f"   ❌ [Sync Point] Memory too slow! Using empty context.")
+            final_prompt = f"Question: {query}\nAnswer:"
+            
+        # Run Real Generation
+        inputs = tokenizer(final_prompt, return_tensors="pt")
+        outputs = model.generate(**inputs, max_new_tokens=20)
+        res = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        print(f"\n   🗣️ [GPU Thread] Output: {res.split('Answer:')[-1].strip()}")
+        mem_thread.join()
+
+    # RUN
+    model_worker()
+
+if __name__ == "__main__":
+    run_true_parallel_test()

Production_Hybrid_Engine/stress_test_hybrid.py

@@ -0,0 +1,78 @@
+import json
+import time
+import sys
+import os
+import torch
+import numpy as np
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from sentence_transformers import SentenceTransformer
+
+# Load Hybrid Engine
+sys.path.append(os.getcwd())
+from ov_hybrid_manager import OVHybridManager
+
+# Config
+DATASET_PATH = "../Benchmarks_10k/dataset_10k_challenge.json"
+MODEL_NAME = "ibm-granite/granite-3.0-2b-instruct"
+
+def run_hybrid_stress_test():
+    print(f"🚀 Starting Hybrid Engine Stress Test (Real LLM Integration)...")
+    
+    # 1. Load Dataset
+    with open(DATASET_PATH, "r") as f:
+        dataset = json.load(f)
+    print(f"📦 Loaded {len(dataset)} scenarios.")
+    
+    # 2. Initialize Engine (Embedding + C++ Kernel)
+    print("⏳ Loading Models...")
+    embedder = SentenceTransformer('all-MiniLM-L6-v2')
+    engine = OVHybridManager()
+    
+    # 3. Load LLM
+    print(f"🤖 Loading LLM: {MODEL_NAME}...")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+    model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, torch_dtype=torch.float32)
+    
+    # 4. Pre-load Memory (Truths + Distractors)
+    print("🧠 Building C++ Memory Index (20,000 Vectors)...")
+    truths = [item["ground_truth"]["text"] for item in dataset]
+    distractors = [item["distractors"][0]["text"] for item in dataset]
+    
+    # Combine
+    all_texts = truths + distractors
+    all_vecs = embedder.encode(all_texts, batch_size=64, show_progress_bar=True)
+    
+    # Metadata (Truths=High C, Distractors=Low C)
+    meta = [{"centrality": 0.95, "recency": 1.0, "weight": 1.0} for _ in range(len(truths))] + \
+           [{"centrality": 0.1,  "recency": 0.5, "weight": 0.1} for _ in range(len(distractors))]
+           
+    engine.load_memory(all_vecs, meta)
+    
+    # 5. Run Inference Loop (Subset of 5)
+    print("\n⚡ Running Hybrid Inference (CPU Search + GPU Generation)...")
+    subset = dataset[:5] # Test 5 adversarial prompts end-to-end
+    
+    for item in subset:
+        query = item["query"]
+        q_vec = embedder.encode(query)
+        
+        # A. C++ Search
+        t0 = time.time()
+        idx, score = engine.search(q_vec)
+        t_search = time.time() - t0
+        
+        best_text = all_texts[idx]
+        is_truth = idx < 10000
+        
+        # B. LLM Gen
+        prompt = f"Context: {best_text}\n\nQuestion: {query}\nAnswer:"
+        inputs = tokenizer(prompt, return_tensors="pt")
+        outputs = model.generate(**inputs, max_new_tokens=40)
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        print(f"\nQ: {query}")
+        print(f"   [C++ Kernel] Found Truth? {is_truth} (Time: {t_search*1000:.2f}ms)")
+        print(f"   [LLM Output] {response.split('Answer:')[-1].strip()}")
+
+if __name__ == "__main__":
+    run_hybrid_stress_test()

README.md

@@ -66,7 +66,12 @@ We have released the **Microservices Swarm** for enterprise scaling (`Production
     *   **Router:** OpenAI-compatible API Gateway.
     *   **Shards:** Independent Topic Nodes (Science, History).
 *   **Consensus:** A "Queen Bee" node aggregates `P` scores from all shards to determine Global Truth.
-*   **Deploy:** `docker-compose up --build`
+## 🧠 Compatibility Mode: OV-Brain Transplant
+For users who want to keep using standard models (Llama, GPT-4) but want OV-Safety (`Compatibility_Mode/`).
+
+*   **Logic:** Uses "System Prompt Injection" to force the model to respect OV-Memory Truths.
+*   **Safety:** Includes "Divya Akka Guardrails" to block toxic/unsafe queries before they reach the model.
+*   **Use Case:** "Bring your own Model, we give it a Conscience."
 
 ## ⚡ Quick Start
 **For Enterprise & Cloud**