diff --git a/.gitattributes b/.gitattributes
index a6344aac8c09253b3b630fb776ae94478aa0275b..2e1e6822872c70583b6e7c3ec6955eb9f2215bfc 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
*.zip filter=lfs diff=lfs merge=lfs -text
*.zst filter=lfs diff=lfs merge=lfs -text
*tfevents* filter=lfs diff=lfs merge=lfs -text
+docs/NeuralAI_Introduction.pdf filter=lfs diff=lfs merge=lfs -text
+from-scratch/web_ui/static/neuralai_logo_clean.jpg filter=lfs diff=lfs merge=lfs -text
+from-scratch/web_ui/static/neuralai_brain_logo.jpg filter=lfs diff=lfs merge=lfs -text
+from-scratch/web_ui/static/favicon.jpg filter=lfs diff=lfs merge=lfs -text
+from-scratch/web_ui/static/logo.png filter=lfs diff=lfs merge=lfs -text
+from-scratch/web_ui/static/assets/logo.png filter=lfs diff=lfs merge=lfs -text
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000000000000000000000000000000000000..ce7a4c8e175fd43b2447cde0d0652796d731a7bf
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,39 @@
+# 🧠 NeuralAI AGENTS.md (Intelligence Engine)
+
+This is the primary instruction set for any agent working on the NeuralAI core.
+
+## 🛠️ System Role
+NeuralAI is the high-density intelligence backend. It provides the raw cognitive power, the "Neural-Brain" knowledge base, and the orchestrator logic that powers the NeuralLabs frontend.
+
+## 📖 Mandatory Pre-Flight Protocol
+**CRITICAL**: Before starting any task, the agent MUST:
+1. Read the current Zo settings and user rules (`list_rules`).
+2. Review the `MODEL_ALIGNMENT.md` to ensure output matches the v7.0 Expert persona.
+3. Consult the `ORCHESTRATOR.md` for delegation patterns.
+
+## 🌌 Current State (v7.1-alpha)
+- **Neural-Brain**: An expanded, high-density knowledge graph spanning:
+ - **Physics**: Advanced Quantum Field Theory (Expert level).
+ - **Philosophy**: Platonic forms and metaphysical systems.
+ - **Geopolitics**: Multipolar global order analysis.
+ - **History & Nature**: From Ancient Civilizations to Human Evolution.
+- **Architecture**: Transitioned to an orchestrator-led model using the Manager-Worker pattern via the `/zo/ask` API.
+- **Hygiene**: All legacy checkpoints, `wandb` logs, and `from-scratch` remnants have been purged.
+- **DPO Expansion**: Dataset v14 expanded with 10 new pairs focusing on debugging, logic, and multi-step reasoning.
+
+## 🔗 Ecosystem Integration
+- **Frontend**: NeuralAI is the intelligence source for **NeuralLabs** (`/home/workspace/Projects/NeuralLabs`).
+- **Interface**: Communicates via the **Hybrid Link Gateway** implemented in NeuralLabs.
+
+## 🎯 Active Goals
+- Maintain expert-level accuracy in the Neural-Brain.
+- Optimize orchestrator delegation for complex multi-step reasoning.
+- Expand knowledge into remaining target domains (Modernity, Advanced Sociology, etc.).
+- **Restore DPO Alignment**: Re-train or restore `checkpoints/dpo_model` to align with the `v13` dataset (249 pairs).
+- **DPO v14 Batch**: Continue expanding v14 to reach 100+ high-quality reasoning pairs.
+- **Voice Key Integration**: Configure `GEMINI_API_KEY` for the `neural-voice` service to enable Live S2S functionality.
+
+## ⚠️ Web UI & Service Safety
+- **UI Integrity:** The web interface for NeuralAI (`from-scratch/web_ui`) features a custom, high-fidelity Google-style UI. **DO NOT** attempt to "redesign", "polish", or replace the layout with generic templates.
+- **API Endpoints:** The frontend relies on critical backend endpoints (`/api/auth/guest`, `/api/terminal/create`, `/api/memory`, `/api/files`, etc.). Modifying or deleting these in `neural_core_service.py` will cause 404/JSON parsing errors (like `Unexpected token '<', "
+
+## 📊 Repository Composition
+
+| Language | Percentage |
+| --- | --- |
+| Python | 71.1% |
+| HTML | 13.0% |
+| JavaScript | 12.4% |
+| CSS | 2.6% |
+| Shell | 0.4% |
+| Jupyter Notebook | 0.3% |
+| Jinja | 0.2% |
+
+**The High-Velocity Model for Your Entire Vibe Stack**
+
+NeuralAI is the central intelligence engine developed for **Harris Holdings**. Conceived and engineered by **De'Andrew Preston Harris** (Founder), it is a highly tuned, DPO-aligned multimodal AI ec\[...\]
+
---
-base_model: HuggingFaceTB/SmolLM2-360M-Instruct
-library_name: peft
-pipeline_tag: text-generation
-tags:
-- base_model:adapter:HuggingFaceTB/SmolLM2-360M-Instruct
-- lora
-- transformers
-- peft
-- neuralai
-- dpo
-- smollm2
-license: apache-2.0
+
+## 🌟 Vision & Manifesto
+
+NeuralAI doesn't just predict text; it *operates the work*. The core mission is to create a multimodal generative system that bridges the gap between raw idea and execution. By fusing autoregressi\[...\]
+
+Born from resilience and ambition in Memphis, Tennessee and West Memphis, Arkansas, NeuralAI represents a forward-thinking approach to personal, private AI computing.
+
---
-# NeuralAI v2 — SmolLM2-360M DPO LoRA Adapter
+## 🛠️ Tech Stack & Architecture (v7.1-alpha)
+
+NeuralAI is built on a high-performance, containerized architecture that marries local inference with cloud-grade storage.
+
+### Core Stack
-A PEFT/LoRA adapter for `HuggingFaceTB/SmolLM2-360M-Instruct`, fine-tuned by **De'Andrew P. Harris** as the inference-time alignment layer for the NeuralAI assistant (the intelligence backend behind the NeuralAI / NeuralLabs product).
+- **Core Model**: `SmolLM2-360M-Instruct` (DPO v13.0 Aligned for logic, math, multi-step reasoning, and debugging)
+- **Vocal Identity**: Andrew (Warm/Multilingual) - Optimized for Live Speech-to-Speech (S2S)
+- **Backend Framework**: Python / Flask (Core Service)
+- **Storage & Database**: SQLite3 (Metadata) + Nextcloud Hub via NeuralCloud WebDAV Client (NeuralDrive)
+- **Inference Engine**: PyTorch (CPU/Edge Optimized)
+- **Frontend UI**: Vanilla JS, HTML5, CSS3 with an advanced Dark Mode layout
-## Model Details
+### Core Architectural Pillars
-- **Base model:** [HuggingFaceTB/SmolLM2-360M-Instruct](https://huggingface.co/HuggingFaceTB/SmolLM2-360M-Instruct)
-- **Adapter type:** LoRA (PEFT 0.19.0)
-- **Rank (r):** 16 · **alpha:** 32 · **dropout:** 0.05 · **bias:** none
-- **Target modules:** `q_proj`, `k_proj`, `v_proj`, `o_proj`, `gate_proj`, `up_proj`, `down_proj`
-- **Task:** `CAUSAL_LM` (instruction-tuned text generation)
-- **Training framework:** PyTorch + 🤗 Transformers + 🤗 PEFT
-- **License:** Apache-2.0 (inherits from base model)
+1. **NeuralAI Core**: Handles chat state, direct model inference, terminal session proxying, and tool orchestration.
+2. **NeuralDrive (Cloud Storage)**: The intelligent data layer for all projects, featuring isolated user storage, automatic versioning, and semantic mapping.
+3. **Diffusion Engine**: An integrated generative diffusion layer for producing visual branding assets, UI mockups, and visual logic maps.
+4. **Agentic Orchestrator**: A high-autonomy layer enabling NeuralAI to plan, reason, and execute multi-step workflows across the OS and web, moving beyond simple chat to active goal achievement.
-## Training
+---
+
+## ✨ Key Features & Capabilities
+
+### 💬 Multimodal Chat & Agentic Intelligence
-- **Method:** Supervised fine-tuning followed by DPO preference alignment
-- **Epochs:** 3
-- **Learning rate:** 2e-4
-- **Optimizer state:** AdamW (bf16)
-- **Training samples:** 363 · **Validation samples:** 41
-- **Training duration:** ~26 minutes
-- **Completed:** 2026-05-17
-- **Final checkpoint:** `checkpoint-69` (used as the published adapter)
+- **High-Velocity Text Inference**: Fast, local inference with deep context awareness.
+- **Deep Reasoning Mode**: Integration of test-time compute and chain-of-thought reasoning for complex problem decomposition and error-free logic.
+- **Autonomous Agentic Workflows**: Ability to operate as an agent—interacting with the browser, terminal, and third-party apps to complete end-to-end tasks with minimal supervision.
+- **Live S2S (Speech-to-Speech)**: Real-time voice interaction with an integrated microphone interface and fluid vocal responses.
+- **Identity Vault & Memory**: Persistent user memory and rule constraints, ensuring NeuralAI remembers preferences, behavioral rules, and historical context.
-See `training_log.json` in this repo for the recorded run summary.
+### 💻 Developer & Engineering Tools
-## Intended Use
+- **Integrated Web Terminal**: A fully functional, WebSocket-driven terminal embedded directly in the web UI for immediate environment control.
+- **File Workspace**: An in-browser IDE experience allowing users to browse directories, read, and write code seamlessly.
+- **Code Execution & Sandbox**: Secure environment for the model to execute and test code on the fly.
-This adapter is intended to be loaded on top of `HuggingFaceTB/SmolLM2-360M-Instruct` for the NeuralAI assistant experience: short-form instruction following, reasoning, and conversational response generation within the NeuralAI / NeuralLabs product surface.
+### 🔐 Authentication & Access Tiers
+
+- **Founder Mode**: Ultimate root-level access and system control.
+- **Maestro Student Portal**: Tiered access for educational and collaborative development.
+- **Guest Preview**: Frictionless instant access for testing the system without an account.
+
+---
-### Out-of-Scope Use
+## 🏋️ Model Training & Fine-Tuning (DPO)
-- Production safety-critical applications
-- Use as a primary assistant without additional alignment, safety filtering, and human oversight
-- Any use that violates the Apache-2.0 license terms
+NeuralAI is continuously learning and improving through rigorous **Direct Preference Optimization (DPO)**.
-## How to Use
+### Training Pipeline
```python
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from peft import PeftModel
-
-base_id = "HuggingFaceTB/SmolLM2-360M-Instruct"
-adapter_id = "Subject-Emu-5259/NeuralAI"
-
-tokenizer = AutoTokenizer.from_pretrained(base_id)
-model = AutoModelForCausalLM.from_pretrained(
- base_id,
- torch_dtype=torch.bfloat16,
- device_map="auto",
+# Example of the DPO alignment configuration used in NeuralAI
+dpo_config = DPOConfig(
+ beta=0.1,
+ learning_rate=5e-5,
+ per_device_train_batch_size=4,
+ gradient_accumulation_steps=4,
+ max_length=1024,
+ max_prompt_length=512,
)
-model = PeftModel.from_pretrained(model, adapter_id)
-
-prompt = "Explain quantum entanglement in one paragraph."
-inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
-with torch.no_grad():
- out = model.generate(**inputs, max_new_tokens=200, do_sample=True, temperature=0.7)
-print(tokenizer.decode(out[0], skip_special_tokens=True))
```
-## Files
+- **Dataset Expansions**: The dataset is aggressively expanded to include advanced reasoning, complex mathematics, logical deduction, creative writing, and system debugging.
+- **Behavioral Alignment**: NeuralAI is specifically tuned to adhere strictly to the "Harris Holdings" vibe—maintaining a professional, technical, and highly disciplined engineering tone.
+- **Model Drift Monitoring**: Continuous evaluation against previous checkpoints to ensure response quality and consistency never regress.
-- `adapter_config.json` — PEFT/LoRA configuration
-- `adapter_model.safetensors` — LoRA adapter weights (~33 MB)
-- `tokenizer.json`, `tokenizer_config.json`, `chat_template.jinja` — tokenizer + chat template
-- `training_log.json` — training run summary
+### Latest Alignment Run: v13.0
-Training-state artifacts (`optimizer.pt`, `scheduler.pt`, `rng_state.pth`) and intermediate `checkpoint-46` were intentionally omitted from this repo to keep it lean for inference.
+- **Training samples**: 363
+- **Validation samples**: 41
+- **Epochs**: 3
+- **Best checkpoint**: `checkpoint-69`
+- **Best validation loss**: `0.7232` at step `69`
+- **Earlier eval losses**: `1.6713` at step `23`, `0.8969` at step `46`
+- **Relative improvement**: `56.73%` reduction from the first eval checkpoint to the best checkpoint
+- **Run duration**: `1571.4s` (~26m 11s)
+- **Completed**: `2026-05-17 08:41 UTC`
-## Limitations
+---
-- This is a small (360M) parameter base model — quality, factuality, and reasoning depth are bounded accordingly.
-- The adapter is tuned for the NeuralAI product voice; off-domain prompts may drift.
-- No RLHF safety tuning has been applied beyond DPO.
+## 📸 Brand & UI Gallery
-## Citation
+*(UI screenshots showcase the beautiful dark mode interface, the terminal integration, and the NeuralDrive file explorer.)*
-```bibtex
-@misc{neuralai_v2_2026,
- title = {NeuralAI v2: SmolLM2-360M DPO LoRA Adapter},
- author = {Harris, De'Andrew P.},
- year = {2026},
- url = {https://huggingface.co/Subject-Emu-5259/NeuralAI}
-}
+```html
+
+
+
+ NeuralAI: System optimal. Ready for execution.
+
NeuralAI is built on the unwavering principle of User Data Sovereignty. Your digital soul—composed of your thoughts, prompts, files, and generated knowledge—belongs exclusively to you. Unlike traditional AI services, NeuralAI ensures that your data is not "harvested" for the benefit of a central corporation. We provide the intelligence; you hold the keys.
+
+
+
1. Information We Collect
+
To provide a personalized, high-velocity intelligence experience, NeuralAI collects specific categories of data. We restrict this collection strictly to functional necessities:
+
+
Identity Vault: Your username, encrypted credentials, and profile information (First Name, Last Name, Bio) necessary to authenticate and personalize your sessions.
+
Cognitive Logs: Your conversation history with NeuralAI. This is stored securely to maintain context, allow for persistent intelligence across sessions, and enable our RAG (Retrieval-Augmented Generation) pipelines to assist you effectively.
+
Digital Artifacts & NeuralDrive: Documents, images, datasets, and code files you upload or generate via our tools. These are securely isolated in your personal NextDrive allocation.
+
Live Audio & Media Data: When utilizing the Live Speech-to-Speech system, your voice stream is temporarily processed by the engine for transcription and response generation. Audio is processed ephemerally and discarded immediately after transcription.
+
Behavioral Telemetry: Anonymized interaction metrics and error logs used exclusively for diagnosing system faults, improving model latency, and ensuring platform stability.
+
+
+
2. NeuralDrive & File Isolation
+
Your uploaded and generated files are stored within your private NeuralDrive node, powered by NextDrive. This cloud-based storage system ensures that every file you upload and every piece of intelligence you generate is saved to your personal vault and not co-mingled in a public dataset.
+
+
Strict Sandboxing: In a multi-tenant environment, your data remains cryptographically separate from other users.
+
No Local Harvesting: Uploaded files are streamed directly to your NeuralDrive container, ensuring they do not persist unprotected on the Zo local system.
+
Data Portability: You maintain the absolute right to export or migrate your entire NeuralDrive structure at any time.
+
+
+
3. How We Use Your Data
+
We use your data for one singular purpose: Empowering You.
+
+
Personal Memory Cloud: Your specific interactions, facts, and preferences are indexed into your personal "Memory Cloud" to ground our AI"s responses exclusively for your queries.
+
Behavioral Alignment: The rules you set in your Behavioral Constraint Rules directly govern the model"s tone, style, and safety parameters. The AI shapes itself to your workflow.
+
Tool Execution: When running code or terminal commands, session data is utilized to provide a seamless, stateful, and isolated execution environment.
+
+
OUR PROMISE: We will never sell, lease, or trade your data. Your private conversations, source code, and NeuralDrive files are NEVER used to train public base models without your explicit, separate, and verifiable opt-in consent.
+
+
4. Security Architecture
+
NeuralAI employs a robust, defense-in-depth security approach:
+
+
JWT & Bearer Authentication: All API requests require cryptographically signed JSON Web Tokens, which are rotated periodically to prevent session hijacking.
+
Encrypted Transit: All data moving between your browser and our nodes is protected by TLS 1.3 encryption, ensuring military-grade transit security.
+
Containerized Workloads: Every user operates within an isolated "sandbox" environment (powered by gVisor and strict permissions), preventing cross-user data leakage and securing the underlying host.
+
Data at Rest Encryption: Your databases, Cognitive Logs, and NeuralDrive storage utilize AES-256 encryption at rest to prevent physical data breaches.
+
+
+
5. Your Rights & Total Control
+
You are the architect and the absolute owner of your data vault. You have the right to:
+
+
Access & Export: View, download, and transfer any part of your data vault, including chat history and NeuralDrive files, at any time in open formats.
+
The Neural Purge: Permanently delete specific conversations, files, or your entire account history. Executing a deletion purges the data from our active database instantly and irreversibly.
+
Correction & Context Override: Update your profile, modify your AI instructions, and alter how NeuralAI perceives and interacts with you dynamically.
+
Consent Management: Revoke microphone, terminal, or file access permissions within your browser or NeuralAI settings at your absolute discretion.
+
+
+
6. Third-Party Integrations
+
In instances where NeuralAI utilizes external modules or integrations (such as Zo workspace capabilities, internet searching agents, or image diffusion APIs), those actions are bound by this policy. We rigorously vet our upstream integrations to ensure they uphold the standard of User Data Sovereignty.
+
+
7. Founder's Commitment
+
NeuralAI was founded by De'Andrew Preston Harris with a visionary goal: to achieve greatness beyond the boundaries of life through intelligent personal servers. This Privacy Policy is our unbreakable social contract with you. It ensures that technology serves as a "noble steed for the mind" while respecting the absolute sanctity and privacy of your digital existence.
+
+
+
diff --git a/from-scratch/web_ui/templates/sse_test.html b/from-scratch/web_ui/templates/sse_test.html
new file mode 100644
index 0000000000000000000000000000000000000000..e42593d84727ac910c58fbb22cd5facc706f6612
--- /dev/null
+++ b/from-scratch/web_ui/templates/sse_test.html
@@ -0,0 +1,29 @@
+
+
+SSE Test
+
+
SSE Test
+
+
+
+
diff --git a/from-scratch/web_ui/templates/terms.html b/from-scratch/web_ui/templates/terms.html
new file mode 100644
index 0000000000000000000000000000000000000000..94c6bd410d0181ec33fe6e74ba4aa0f85ef7f558
--- /dev/null
+++ b/from-scratch/web_ui/templates/terms.html
@@ -0,0 +1,134 @@
+
+
+
+
+
+ Terms of Service | NeuralAI
+
+
+
+
+
By accessing the NeuralAI platform, services, or local intelligence nodes, you are entering into a legally binding agreement. NeuralAI is more than a tool; it is an extension of your mind. We provide the powerful infrastructure and intelligence, but the ethical application and outputs generated are ultimately your responsibility. Please read this contract thoroughly as it dictates our shared understanding of data, computation, and liability.
+
+
+
1. Intellectual Property & Digital Soul
+
Unless otherwise explicitly indicated, the Site and Services are the proprietary property of NeuralAI. However, we maintain a strict and unbreakable distinction between the Platform and the User Intelligence.
+
+
The Platform: All source code, database architectures, machine learning weights (excluding custom user LoRA adapters), UI designs, algorithms, APIs, trademarks, and documentation are exclusively owned by NeuralAI. Reproduction, distribution, or decompilation of the core platform is strictly prohibited.
+
Your Digital Soul: You retain 100% ownership and intellectual property rights of everything you create. This includes the logic in your code snippets, the artistic intent in generated images, and the unique structure of your Memory Cloud. NeuralAI acts strictly as your agent, not your master. You grant NeuralAI a limited, temporary license to process this data solely to fulfill your requests.
+
+
+
2. Responsible Intelligence & Acceptable Use
+
As a privileged user of a high-velocity intelligence system, you agree to adhere to the following standards of operation:
+
+
Truthfulness: Provide accurate information for your Identity Vault to ensure seamless model alignment and service continuity. Do not impersonate other entities.
+
Lawful Use: Utilize the terminal, code execution capabilities, NeuralDrive, and chat features in strict compliance with all local, state, and international laws.
+
No Malevolence: You explicitly agree to refrain from using NeuralAI to develop malware, coordinate cyber-attacks, bypass security systems without authorization, or generate content that promotes hate, violence, or exploitation of any individual or group.
+
System Integrity: Do not attempt to reverse-engineer, overload, or maliciously disrupt the NeuralAI API, routing gateways, or core storage nodes. Automated scraping, "jailbreaking," or exploiting zero-day vulnerabilities in the system will result in immediate termination.
+
+
+
3. Model Performance, Capabilities, & Inference
+
NeuralAI provides local and cloud model inference (currently utilizing advanced DPO Aligned intelligence). While we strive for "Human-Like" reasoning, high accuracy, and empathetic interaction, you must acknowledge the inherent nature of AI:
+
+
Hallucinations: Artificial Intelligence can occasionally "hallucinate" or provide logically sound but factually incorrect data. Do not treat the AI as an absolute source of truth.
+
Verification Requirement: Output from our models—especially executable code, medical advice, or data analysis—should be independently verified before being used for critical legal, financial, medical, or production-grade business decisions.
+
Availability: System performance (latency, streaming speed, and throughput) depends on available compute nodes, concurrent user demand, and network conditions. NeuralAI is provided "AS-IS" without a guaranteed uptime SLA or warranty of fitness for a particular purpose.
+
+
+
4. Live Capabilities (Speech & Media)
+
With the integration of Live Speech-to-Speech interactions and real-time generation features, NeuralAI requires access to your microphone and media devices. By utilizing these features, you consent to local browser-based or ephemeral cloud processing of your voice data.
+
+
Voice recordings are processed in real-time and are not stored permanently unless explicitly requested as a transcript.
+
You must not use Live capabilities to record, monitor, or analyze third parties without their explicit consent.
+
+
+
5. Financial and Subscription Obligations
+
If utilizing a premium tier of NeuralAI, you agree to pay all applicable fees associated with your compute usage, NeuralDrive storage limits, and API calls.
+
+
Payments are non-refundable unless required by regional law.
+
NeuralAI reserves the right to throttle or temporarily restrict compute access if an account exhibits unusual usage patterns that threaten network stability.
+
+
+
6. Termination & Data Purge
+
You maintain the right to terminate your account and relationship with NeuralAI at any time. Upon termination, you have the option to trigger a Complete Neural Purge, which will permanently, irreversibly delete your Memory Cloud, Cognitive Logs, configurations, and all artifacts stored within your NeuralDrive node.
+
NeuralAI reserves the right to suspend or terminate accounts that flagrantly violate the "No Malevolence" or "System Integrity" clauses, to protect the broader network and user base. Upon forced termination, your data will be retained for up to 30 days for legal compliance before being purged.
+
+
7. Limitation of Liability and Indemnification
+
To the maximum extent permitted by applicable law, NeuralAI, its founder, employees, and affiliates shall not be liable for any indirect, incidental, special, consequential, or punitive damages, or any loss of profits or revenues, whether incurred directly or indirectly, or any loss of data, use, goodwill, or other intangible losses, resulting from (a) your access to or use of or inability to access or use the services; (b) any conduct or content of any third party on the services; (c) any content obtained from the services; and (d) unauthorized access, use, or alteration of your transmissions or content.
+
+
8. Jurisdiction, Legacy, & Vision
+
NeuralAI is built upon the resilience of West Memphis and the ambition of its founder, De'Andrew Preston Harris. Any legal disputes arising from your use of the Services shall be governed exclusively by the laws of the State of Arkansas, United States. We aim to achieve greatness beyond the boundaries of life, and we invite you to utilize this platform to amplify your own legacy.
+
+
+
diff --git a/from-scratch/web_ui/terminal.py b/from-scratch/web_ui/terminal.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe9ccf823349bb79488d6e39cf8291e56a4c3466
--- /dev/null
+++ b/from-scratch/web_ui/terminal.py
@@ -0,0 +1,743 @@
+#!/usr/bin/env python3
+"""
+NeuralAI Terminal 2.0 — Advanced Integrated Terminal
+- PTY-based shell sessions
+- Code execution with syntax checking
+- File operations (read, write, edit, browse)
+- Git integration
+- Python/Node execution
+- Package management (pip, npm)
+- Process management
+- Command history & autocomplete
+- Code snippets
+- Syntax highlighting
+"""
+import os
+import pty
+import select
+import struct
+import fcntl
+import termios
+import signal
+import threading
+import uuid
+import time
+import json
+import subprocess
+import re
+from pathlib import Path
+from functools import wraps
+import jwt
+from flask import Blueprint, request, Response, jsonify, current_app
+
+terminal_bp = Blueprint("terminal", __name__)
+
+# In-memory session store
+sessions = {}
+
+# ====================
+# AUTH DECORATOR
+# ====================
+def token_required(f):
+ @wraps(f)
+ def decorated(*args, **kwargs):
+ token = request.headers.get("Authorization")
+ if not token or not token.startswith("Bearer "):
+ return jsonify({"error": "Token is missing"}), 401
+ try:
+ token = token.split(" ")[1]
+ data = jwt.decode(token, current_app.config["SECRET_KEY"], algorithms=["HS256"])
+ request.user_id = data["user_id"]
+ except:
+ return jsonify({"error": "Token is invalid"}), 401
+ return f(*args, **kwargs)
+ return decorated
+command_history = {}
+snippets = {
+ "python": {
+ "fib": "def fibonacci(n):\n if n <= 1: return n\n return fibonacci(n-1) + fibonacci(n-2)",
+ "class": "class MyClass:\n def __init__(self):\n pass\n\n def method(self):\n pass",
+ "main": 'if __name__ == "__main__":\n pass',
+ "args": "import argparse\nparser = argparse.ArgumentParser()\nparser.add_argument('--input', type=str)\nargs = parser.parse_args()",
+ "http": "import requests\nresponse = requests.get('https://api.example.com')\nprint(response.json())",
+ "json": "import json\nwith open('data.json', 'r') as f:\n data = json.load(f)",
+ "file": "with open('file.txt', 'r') as f:\n content = f.read()",
+ "async": "import asyncio\n\nasync def main():\n pass\n\nasyncio.run(main())",
+ },
+ "bash": {
+ "loop": "for i in {1..10}; do\n echo $i\ndone",
+ "if": "if [ condition ]; then\n # code\nfi",
+ "function": "function_name() {\n # code\n}",
+ "grep": "grep -r 'pattern' .",
+ "find": "find . -name '*.py'",
+ "tar": "tar -czvf archive.tar.gz directory/",
+ "gitignore": "echo '*.pyc\\n__pycache__/\\n.env' > .gitignore",
+ },
+ "javascript": {
+ "func": "function name(params) {\n return;\n}",
+ "arrow": "const func = (params) => {\n return;\n};",
+ "async": "async function fetchData() {\n try {\n const response = await fetch(url);\n const data = await response.json();\n return data;\n } catch (error) {\n console.error(error);\n }\n}",
+ "class": "class MyClass {\n constructor() {}\n\n method() {}\n}",
+ "export": "export default function() {\n // code\n}",
+ "import": "import { module } from 'package';",
+ }
+}
+
+class TerminalSession:
+ def __init__(self, session_id: str, rows: int = 24, cols: int = 80):
+ self.session_id = session_id
+ self.rows = rows
+ self.cols = cols
+ self.master_fd = None
+ self.pid = None
+ self.started = False
+ self.last_activity = time.time()
+ self.env = os.environ.copy()
+ self.env["TERM"] = "xterm-256color"
+ self.env["HOME"] = os.path.expanduser("~")
+ self.env["USER"] = os.environ.get("USER", "neural")
+ self.env["EDITOR"] = "nano"
+ self.env["PAGER"] = "less"
+ # NeuralAI Terminal Prompt - Root@Neural style
+ self.env["PS1"] = "\\[\\033[1;32m\\]root@Neural\\[\\033[0m\\]:\\[\\033[1;36m\\]\\w\\[\\033[0m\\]# "
+ self.env["PROMPT_COMMAND"] = ""
+ self.buffer = [] # scrollback buffer
+ self.buffer_size = 5000
+ self.history = []
+ self.history_index = -1
+ self.cwd = os.environ.get("HOME", "/root")
+ self.env_vars = {}
+ self.running_processes = {}
+ self.last_command = ""
+ self.output_handlers = {}
+
+ def start(self):
+ if self.started:
+ return
+ self.master_fd, slave_fd = pty.openpty()
+ self.pid = os.fork()
+ if self.pid == 0:
+ # Child
+ os.setsid()
+ fcntl.ioctl(slave_fd, termios.TIOCSWINSZ, struct.pack("HHHH", self.rows, self.cols, 0, 0))
+ os.dup2(slave_fd, 0)
+ os.dup2(slave_fd, 1)
+ os.dup2(slave_fd, 2)
+ if slave_fd > 2:
+ os.close(slave_fd)
+ os.chdir(self.cwd)
+ for sig in (signal.SIGTERM, signal.SIGINT, signal.SIGHUP):
+ signal.signal(sig, signal.SIG_DFL)
+ os.execvp(os.environ.get("SHELL", "/bin/bash"), ["-bash", "--login"])
+ os._exit(1)
+ else:
+ os.close(slave_fd)
+ flags = fcntl.fcntl(self.master_fd, fcntl.F_GETFL)
+ fcntl.fcntl(self.master_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+ self.started = True
+ self.resize(self.rows, self.cols)
+
+ def write(self, data: str):
+ if not self.started or self.master_fd is None:
+ return
+ self.last_activity = time.time()
+ try:
+ os.write(self.master_fd, data.encode("utf-8"))
+ except OSError:
+ pass
+
+ def read(self, timeout: float = 0.05) -> str:
+ if not self.started or self.master_fd is None:
+ return ""
+ self.last_activity = time.time()
+ output = []
+ try:
+ while True:
+ r, _, _ = select.select([self.master_fd], [], [], timeout)
+ if not r:
+ break
+ try:
+ data = os.read(self.master_fd, 4096)
+ if not data:
+ break
+ decoded = data.decode("utf-8", errors="replace")
+ output.append(decoded)
+ self._buffer_add(decoded)
+ except OSError:
+ break
+ except Exception:
+ pass
+ return "".join(output)
+
+ def _buffer_add(self, text: str):
+ self.buffer.append(text)
+ if len(self.buffer) > self.buffer_size:
+ self.buffer = self.buffer[-self.buffer_size:]
+
+ def resize(self, rows: int, cols: int):
+ if self.master_fd is None:
+ return
+ self.rows = rows
+ self.cols = cols
+ try:
+ fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, struct.pack("HHHH", rows, cols, 0, 0))
+ except Exception:
+ pass
+
+ def is_alive(self) -> bool:
+ if not self.started:
+ return False
+ if self.pid is None:
+ return False
+ try:
+ os.kill(self.pid, 0)
+ return True
+ except OSError:
+ return False
+
+ def stop(self):
+ if self.pid is not None:
+ try:
+ os.kill(self.pid, signal.SIGTERM)
+ time.sleep(0.2)
+ os.kill(self.pid, signal.SIGKILL)
+ except OSError:
+ pass
+ self.pid = None
+ if self.master_fd is not None:
+ try:
+ os.close(self.master_fd)
+ except OSError:
+ pass
+ self.master_fd = None
+
+ def get_buffer(self) -> str:
+ return "".join(self.buffer)
+
+ def add_to_history(self, cmd: str):
+ if cmd.strip() and (not self.history or self.history[-1] != cmd):
+ self.history.append(cmd)
+ if len(self.history) > 1000:
+ self.history = self.history[-1000:]
+ self.history_index = len(self.history)
+
+ def get_history(self, index: int) -> str:
+ if 0 <= index < len(self.history):
+ return self.history[index]
+ return ""
+
+
+def cleanup_dead_sessions():
+ dead = [sid for sid, sess in sessions.items() if not sess.is_alive()]
+ for sid in dead:
+ sessions[sid].stop()
+ del sessions[sid]
+
+
+def execute_python(code: str) -> dict:
+ """Execute Python code and return result."""
+ try:
+ result = subprocess.run(
+ ["python3", "-c", code],
+ capture_output=True,
+ text=True,
+ timeout=30
+ )
+ return {
+ "stdout": result.stdout,
+ "stderr": result.stderr,
+ "returncode": result.returncode
+ }
+ except subprocess.TimeoutExpired:
+ return {"error": "Execution timed out"}
+ except Exception as e:
+ return {"error": str(e)}
+
+
+def execute_javascript(code: str) -> dict:
+ """Execute JavaScript code using node."""
+ try:
+ result = subprocess.run(
+ ["node", "-e", code],
+ capture_output=True,
+ text=True,
+ timeout=30
+ )
+ return {
+ "stdout": result.stdout,
+ "stderr": result.stderr,
+ "returncode": result.returncode
+ }
+ except subprocess.TimeoutExpired:
+ return {"error": "Execution timed out"}
+ except FileNotFoundError:
+ return {"error": "Node.js not installed"}
+ except Exception as e:
+ return {"error": str(e)}
+
+
+def run_file(filepath: str) -> dict:
+ """Run a file based on its extension."""
+ path = Path(filepath)
+ if not path.exists():
+ return {"error": f"File not found: {filepath}"}
+
+ ext = path.suffix.lower()
+
+ if ext == ".py":
+ result = subprocess.run(
+ ["python3", str(path)],
+ capture_output=True,
+ text=True,
+ timeout=60
+ )
+ return {"stdout": result.stdout, "stderr": result.stderr, "returncode": result.returncode}
+
+ elif ext == ".js":
+ result = subprocess.run(
+ ["node", str(path)],
+ capture_output=True,
+ text=True,
+ timeout=60
+ )
+ return {"stdout": result.stdout, "stderr": result.stderr, "returncode": result.returncode}
+
+ elif ext == ".sh":
+ result = subprocess.run(
+ ["bash", str(path)],
+ capture_output=True,
+ text=True,
+ timeout=60
+ )
+ return {"stdout": result.stdout, "stderr": result.stderr, "returncode": result.returncode}
+
+ else:
+ return {"error": f"Unsupported file type: {ext}"}
+
+
+def get_file_info(filepath: str) -> dict:
+ """Get file information."""
+ path = Path(filepath)
+ if not path.exists():
+ return {"error": "File not found"}
+
+ stat = path.stat()
+ return {
+ "name": path.name,
+ "size": stat.st_size,
+ "modified": time.ctime(stat.st_mtime),
+ "is_dir": path.is_dir(),
+ "is_file": path.is_file(),
+ "extension": path.suffix,
+ "permissions": oct(stat.st_mode)[-3:],
+ }
+
+
+def list_directory(dirpath: str = ".") -> dict:
+ """List directory contents."""
+ path = Path(dirpath)
+ if not path.exists():
+ return {"error": "Directory not found"}
+
+ if not path.is_dir():
+ return {"error": "Not a directory"}
+
+ items = []
+ for item in sorted(path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower())):
+ items.append({
+ "name": item.name,
+ "is_dir": item.is_dir(),
+ "size": item.stat().st_size if item.is_file() else None,
+ })
+
+ return {"path": str(path.absolute()), "items": items}
+
+
+def search_files(pattern: str, directory: str = ".") -> dict:
+ """Search for files matching pattern."""
+ path = Path(directory)
+ matches = list(path.glob(pattern))
+ return {
+ "pattern": pattern,
+ "directory": str(path.absolute()),
+ "matches": [str(m.relative_to(path)) for m in matches[:50]]
+ }
+
+
+def check_syntax(code: str, language: str) -> dict:
+ """Check code syntax without executing."""
+ if language == "python":
+ try:
+ compile(code, "", "exec")
+ return {"valid": True, "message": "Syntax OK"}
+ except SyntaxError as e:
+ return {"valid": False, "line": e.lineno, "message": str(e)}
+
+ elif language == "javascript":
+ try:
+ result = subprocess.run(
+ ["node", "--check", "-e", code],
+ capture_output=True,
+ text=True
+ )
+ if result.returncode == 0:
+ return {"valid": True, "message": "Syntax OK"}
+ return {"valid": False, "message": result.stderr}
+ except Exception as e:
+ return {"valid": False, "message": str(e)}
+
+ return {"error": f"Unsupported language: {language}"}
+
+
+def get_git_status(directory: str = ".") -> dict:
+ """Get git status."""
+ try:
+ result = subprocess.run(
+ ["git", "status", "--porcelain"],
+ capture_output=True,
+ text=True,
+ cwd=directory
+ )
+ branch = subprocess.run(
+ ["git", "branch", "--show-current"],
+ capture_output=True,
+ text=True,
+ cwd=directory
+ )
+ return {
+ "branch": branch.stdout.strip(),
+ "status": result.stdout,
+ "modified": len([l for l in result.stdout.split("\n") if l.strip()])
+ }
+ except Exception as e:
+ return {"error": str(e)}
+
+
+def get_process_list() -> dict:
+ """Get list of running processes."""
+ try:
+ result = subprocess.run(
+ ["ps", "aux"],
+ capture_output=True,
+ text=True
+ )
+ processes = []
+ for line in result.stdout.split("\n")[1:20]: # Top 20
+ if line.strip():
+ parts = line.split(None, 10)
+ if len(parts) >= 11:
+ processes.append({
+ "user": parts[0],
+ "pid": parts[1],
+ "cpu": parts[2],
+ "mem": parts[3],
+ "command": parts[10][:50]
+ })
+ return {"processes": processes}
+ except Exception as e:
+ return {"error": str(e)}
+
+
+# Routes
+
+@terminal_bp.route("/api/terminal/create", methods=["POST"])
+@token_required
+def create_session():
+ cleanup_dead_sessions()
+ data = request.get_json(silent=True) or {}
+ rows = int(data.get("rows", 24))
+ cols = int(data.get("cols", 100))
+ session_id = str(uuid.uuid4())[:8]
+ sess = TerminalSession(session_id, rows=rows, cols=cols)
+ sess.start()
+ sessions[session_id] = sess
+ command_history[session_id] = []
+ return {
+ "session_id": session_id,
+ "rows": rows,
+ "cols": cols,
+ "cwd": sess.cwd,
+ "welcome": """NeuralAI Terminal 2.0
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Ready. Type 'help' for commands.
+
+Built-in Commands:
+ help - Show this help
+ clear - Clear terminal
+ ls [path] - List directory
+ cd - Change directory
+ cat - View file
+ edit - Edit file
+ run - Execute file (.py, .js, .sh)
+
+Code Execution:
+ python - Execute Python
+ js - Execute JavaScript
+ check - Syntax check
+
+Git Commands:
+ git status - Repository status
+ git log - Commit history
+ git diff - Show changes
+
+Snippets:
+ snippet - Insert code snippet
+ snippets - List available snippets
+
+Tools:
+ ps - List processes
+ kill - Kill process
+ find - Search files
+ info - File details
+
+Neural Integration:
+ neural - Ask NeuralAI
+ uplink - Check uplink status
+ model - Show model info
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""
+ }
+
+
+@terminal_bp.route("/api/terminal//read", methods=["GET"])
+@token_required
+def read_session(session_id):
+ if session_id not in sessions:
+ return {"error": "Session not found"}, 404
+ sess = sessions[session_id]
+ output = sess.read(timeout=0.1)
+ return {
+ "output": output,
+ "alive": sess.is_alive(),
+ "rows": sess.rows,
+ "cols": sess.cols,
+ "cwd": sess.cwd
+ }
+
+
+@terminal_bp.route("/api/terminal//write", methods=["POST"])
+@token_required
+def write_session(session_id):
+ if session_id not in sessions:
+ return {"error": "Session not found"}, 404
+ data = request.get_json(silent=True) or {}
+ cmd = data.get("input", "")
+ if cmd:
+ # Handle special commands
+ cmd_lower = cmd.strip().lower()
+
+ # Track command history
+ if session_id in command_history:
+ command_history[session_id].append(cmd.strip())
+
+ sessions[session_id].add_to_history(cmd)
+ sessions[session_id].write(cmd)
+ return {"ok": True}
+
+
+@terminal_bp.route("/api/terminal//command", methods=["POST"])
+@terminal_bp.route("/api/terminal//send", methods=["POST"])
+@token_required
+def execute_command(session_id):
+ """Execute a command with enhanced handling."""
+ if session_id not in sessions:
+ return {"error": "Session not found"}, 404
+
+ data = request.get_json(silent=True) or {}
+ cmd = data.get("command", data.get("input", "")).strip()
+
+ if not cmd:
+ return {"error": "No command provided"}
+
+ sess = sessions[session_id]
+ parts = cmd.split()
+ cmd_name = parts[0].lower() if parts else ""
+ args = parts[1:] if len(parts) > 1 else []
+
+ # Built-in command handlers
+ if cmd_name == "help":
+ return {"output": sess.get_buffer().split("Built-in Commands:")[1].split("━")[0] if "Built-in Commands" in sess.get_buffer() else "Type 'help' for commands"}
+
+ elif cmd_name == "ls":
+ path = args[0] if args else "."
+ return list_directory(path)
+
+ elif cmd_name == "cd":
+ if not args:
+ return {"error": "Usage: cd "}
+ new_path = Path(sess.cwd) / args[0]
+ if new_path.exists() and new_path.is_dir():
+ sess.cwd = str(new_path.resolve())
+ return {"cwd": sess.cwd}
+ return {"error": f"Directory not found: {args[0]}"}
+
+ elif cmd_name == "cat":
+ if not args:
+ return {"error": "Usage: cat "}
+ filepath = Path(sess.cwd) / args[0]
+ if filepath.exists() and filepath.is_file():
+ try:
+ content = filepath.read_text()
+ return {"output": content[:10000]} # Limit output
+ except Exception as e:
+ return {"error": str(e)}
+ return {"error": f"File not found: {args[0]}"}
+
+ elif cmd_name == "run":
+ if not args:
+ return {"error": "Usage: run "}
+ filepath = Path(sess.cwd) / args[0]
+ return run_file(str(filepath))
+
+ elif cmd_name == "python":
+ code = " ".join(args)
+ if not code:
+ return {"error": "Usage: python "}
+ return execute_python(code)
+
+ elif cmd_name == "js" or cmd_name == "javascript":
+ code = " ".join(args)
+ if not code:
+ return {"error": "Usage: js "}
+ return execute_javascript(code)
+
+ elif cmd_name == "check":
+ if len(args) < 2:
+ return {"error": "Usage: check "}
+ lang = args[0]
+ code = " ".join(args[1:])
+ return check_syntax(code, lang)
+
+ elif cmd_name == "snippet":
+ if len(args) < 2:
+ return {"error": "Usage: snippet "}
+ lang = args[0]
+ name = args[1]
+ if lang in snippets and name in snippets[lang]:
+ return {"code": snippets[lang][name]}
+ return {"error": f"Snippet not found: {lang}/{name}"}
+
+ elif cmd_name == "snippets":
+ lang = args[0] if args else None
+ if lang and lang in snippets:
+ return {"snippets": list(snippets[lang].keys())}
+ return {"languages": list(snippets.keys())}
+
+ elif cmd_name == "info":
+ if not args:
+ return {"error": "Usage: info "}
+ filepath = Path(sess.cwd) / args[0]
+ return get_file_info(str(filepath))
+
+ elif cmd_name == "find":
+ pattern = args[0] if args else "*"
+ return search_files(pattern, sess.cwd)
+
+ elif cmd_name == "ps":
+ return get_process_list()
+
+ elif cmd_name == "git":
+ if args and args[0] == "status":
+ return get_git_status(sess.cwd)
+ # Pass through to shell for other git commands
+ pass
+
+ elif cmd_name == "neural":
+ msg = " ".join(args)
+ if not msg:
+ return {"error": "Usage: neural "}
+ # This will be handled by the frontend chat API
+ return {"redirect": "chat", "message": msg}
+
+ # Default: pass to shell
+ sess.write(cmd + "\n")
+ output = sess.read(timeout=0.5)
+ return {"output": output}
+
+
+@terminal_bp.route("/api/terminal//resize", methods=["POST"])
+@token_required
+def resize_session(session_id):
+ if session_id not in sessions:
+ return {"error": "Session not found"}, 404
+ data = request.get_json(silent=True) or {}
+ rows = int(data.get("rows", 24))
+ cols = int(data.get("cols", 100))
+ sessions[session_id].resize(rows, cols)
+ return {"ok": True}
+
+
+@terminal_bp.route("/api/terminal//alive", methods=["GET"])
+@token_required
+def alive_session(session_id):
+ if session_id not in sessions:
+ return {"alive": False}
+ return {"alive": sessions[session_id].is_alive()}
+
+
+@terminal_bp.route("/api/terminal//buffer", methods=["GET"])
+@token_required
+def buffer_session(session_id):
+ if session_id not in sessions:
+ return {"error": "Session not found"}, 404
+ return {"buffer": sessions[session_id].get_buffer()}
+
+
+@terminal_bp.route("/api/terminal//history", methods=["GET"])
+@token_required
+def history_session(session_id):
+ if session_id not in sessions:
+ return {"error": "Session not found"}, 404
+ sess = sessions[session_id]
+ return {"history": sess.history[-50:]} # Last 50 commands
+
+
+@terminal_bp.route("/api/terminal//stop", methods=["POST"])
+@token_required
+def stop_session(session_id):
+ if session_id in sessions:
+ sessions[session_id].stop()
+ del sessions[session_id]
+ if session_id in command_history:
+ del command_history[session_id]
+ return {"ok": True}
+
+
+@terminal_bp.route("/api/terminal/sessions", methods=["GET"])
+@token_required
+def list_sessions():
+ cleanup_dead_sessions()
+ return {
+ "sessions": [
+ {
+ "session_id": sid,
+ "alive": sess.is_alive(),
+ "rows": sess.rows,
+ "cols": sess.cols,
+ "cwd": sess.cwd
+ }
+ for sid, sess in sessions.items()
+ ]
+ }
+
+
+@terminal_bp.route("/api/terminal/snippets", methods=["GET"])
+@token_required
+def list_snippets():
+ """List all available code snippets."""
+ return {
+ "snippets": {
+ lang: list(names.keys())
+ for lang, names in snippets.items()
+ }
+ }
+
+
+@terminal_bp.route("/api/terminal/snippets//", methods=["GET"])
+@token_required
+def get_snippet(language, name):
+ """Get a specific code snippet."""
+ if language in snippets and name in snippets[language]:
+ return {"code": snippets[language][name]}
+ return {"error": "Snippet not found"}, 404
diff --git a/from-scratch/web_ui/terminal_ws.py b/from-scratch/web_ui/terminal_ws.py
new file mode 100644
index 0000000000000000000000000000000000000000..4aeb96f0a1435f27d22c7fa7da6a57031f2ff516
--- /dev/null
+++ b/from-scratch/web_ui/terminal_ws.py
@@ -0,0 +1,31 @@
+# terminal_ws.py
+#
+# Terminal WebSocket Endpoint
+# - Accepts commands from frontend
+# - Streams output back
+
+from fastapi import APIRouter, WebSocket
+from neuralai_engine import run_shell_command
+
+router = APIRouter()
+
+
+@router.websocket("/ws/terminal")
+async def terminal_ws(ws: WebSocket):
+ """
+ WebSocket endpoint for terminal.
+ Frontend connects, sends command, receives streamed output.
+ """
+ await ws.accept()
+
+ try:
+ cmd = await ws.receive_text()
+
+ async for line in run_shell_command(cmd):
+ await ws.send_text(line)
+
+ await ws.send_text("[DONE]")
+ except Exception as e:
+ await ws.send_text(f"[Error] {str(e)}")
+ finally:
+ await ws.close()
diff --git a/from-scratch/web_ui/tools_api.py b/from-scratch/web_ui/tools_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..e72e8226233886976a688978ad4548b4454e6157
--- /dev/null
+++ b/from-scratch/web_ui/tools_api.py
@@ -0,0 +1,704 @@
+# tools_api.py
+#
+# Flask API endpoints for NeuralAI tools
+# - Code execution (Python, JavaScript)
+# - File management
+# - Web fetching
+# - Database operations
+# - Git operations
+
+import json
+import sys
+import os
+from pathlib import Path
+from flask import Blueprint, jsonify, request
+
+# Add tools to path
+TOOLS_PATH = Path(__file__).resolve().parent.parent.parent / "tools"
+if str(TOOLS_PATH) not in sys.path:
+ sys.path.insert(0, str(TOOLS_PATH))
+
+try:
+ from code_sandbox import CodeSandbox
+ from file_manager import FileManager
+ from web_fetcher import WebFetcher
+ from db_connector import DatabaseConnector
+ from git_assistant import GitAssistant
+ TOOLS_AVAILABLE = True
+except ImportError as e:
+ print(f"[Tools API] Import error: {e}")
+ TOOLS_AVAILABLE = False
+ CodeSandbox = None
+ FileManager = None
+ WebFetcher = None
+ DatabaseConnector = None
+ GitAssistant = None
+
+# Create blueprint
+tools_bp = Blueprint('tools', __name__, url_prefix='/api/tools')
+
+# Initialize tools
+if TOOLS_AVAILABLE:
+ sandbox = CodeSandbox()
+ file_mgr = FileManager(base_dir=str(Path(__file__).resolve().parent.parent.parent.parent))
+ web_fetcher = WebFetcher()
+ db_conn = DatabaseConnector()
+ git_helper = GitAssistant()
+else:
+ sandbox = None
+ file_mgr = None
+ web_fetcher = None
+ db_conn = None
+ git_helper = None
+
+
+# ========================================
+# CODE EXECUTION
+# ========================================
+
+@tools_bp.route('/execute', methods=['POST'])
+def execute_code():
+ """Execute Python or JavaScript code."""
+ if not sandbox:
+ return jsonify({"error": "Code sandbox not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ code = data.get('code', '')
+ language = data.get('language', 'python').lower()
+ timeout = data.get('timeout', 30)
+
+ if not code:
+ return jsonify({"error": "No code provided", "success": False}), 400
+
+ if language == 'python':
+ result = sandbox.run_python(code, timeout=timeout)
+ elif language in ('javascript', 'js'):
+ result = sandbox.run_javascript(code, timeout=timeout)
+ else:
+ return jsonify({"error": f"Unsupported language: {language}", "success": False}), 400
+
+ return jsonify({
+ "success": result.get("success", False),
+ "output": result.get("output", ""),
+ "error": result.get("error", ""),
+ "exit_code": result.get("exit_code", -1),
+ "execution_time": result.get("execution_time", 0),
+ "language": language
+ })
+
+
+@tools_bp.route('/execute/python', methods=['POST'])
+def execute_python():
+ """Execute Python code specifically."""
+ data = request.get_json(silent=True) or {}
+ data['language'] = 'python'
+ return execute_code()
+
+
+@tools_bp.route('/execute/javascript', methods=['POST'])
+def execute_javascript():
+ """Execute JavaScript code specifically."""
+ data = request.get_json(silent=True) or {}
+ data['language'] = 'javascript'
+ return execute_code()
+
+
+# ========================================
+# FILE MANAGEMENT
+# ========================================
+
+@tools_bp.route('/files/list', methods=['POST'])
+def list_files_tool():
+ """List files in a directory."""
+ if not file_mgr:
+ return jsonify({"error": "File manager not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ path = data.get('path', '.')
+
+ result = file_mgr.list_dir(path)
+
+ return jsonify({
+ "success": result.get("success", True),
+ "path": path,
+ "directories": result.get("directories", []),
+ "files": result.get("files", [])
+ })
+
+
+@tools_bp.route('/files/read', methods=['POST'])
+def read_file_tool():
+ """Read a file."""
+ if not file_mgr:
+ return jsonify({"error": "File manager not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ filepath = data.get('path', '')
+
+ if not filepath:
+ return jsonify({"error": "No path provided", "success": False}), 400
+
+ result = file_mgr.read_file(filepath)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "content": result.get("content", ""),
+ "error": result.get("error", ""),
+ "path": filepath
+ })
+
+
+@tools_bp.route('/files/write', methods=['POST'])
+def write_file_tool():
+ """Write content to a file."""
+ if not file_mgr:
+ return jsonify({"error": "File manager not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ filepath = data.get('path', '')
+ content = data.get('content', '')
+
+ if not filepath:
+ return jsonify({"error": "No path provided", "success": False}), 400
+
+ result = file_mgr.write_file(filepath, content)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "path": filepath,
+ "bytes_written": result.get("bytes_written", 0),
+ "error": result.get("error", "")
+ })
+
+
+@tools_bp.route('/files/search', methods=['POST'])
+def search_files_tool():
+ """Search for files by name or content."""
+ if not file_mgr:
+ return jsonify({"error": "File manager not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ query = data.get('query', '')
+ path = data.get('path', '.')
+ search_type = data.get('type', 'filename') # filename or content
+
+ if not query:
+ return jsonify({"error": "No search query provided", "success": False}), 400
+
+ if search_type == 'content':
+ result = file_mgr.search(query, path, search_content=True)
+ else:
+ result = file_mgr.search(query, path, search_content=False)
+
+ return jsonify({
+ "success": result.get("success", True),
+ "query": query,
+ "matches": result.get("matches", []),
+ "count": len(result.get("matches", []))
+ })
+
+
+# ========================================
+# WEB FETCHING
+# ========================================
+
+@tools_bp.route('/web/fetch', methods=['POST'])
+def fetch_url_tool():
+ """Fetch content from a URL."""
+ if not web_fetcher:
+ return jsonify({"error": "Web fetcher not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ url = data.get('url', '')
+ timeout = data.get('timeout', 30)
+
+ if not url:
+ return jsonify({"error": "No URL provided", "success": False}), 400
+
+ result = web_fetcher.fetch(url, timeout=timeout)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "url": url,
+ "content": result.get("content", ""),
+ "title": result.get("title", ""),
+ "links": result.get("links", [])[:20], # Limit links
+ "error": result.get("error", "")
+ })
+
+
+@tools_bp.route('/web/extract', methods=['POST'])
+def extract_from_url():
+ """Extract specific data from a URL."""
+ if not web_fetcher:
+ return jsonify({"error": "Web fetcher not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ url = data.get('url', '')
+ extract_type = data.get('extract', 'text') # text, links, meta, all
+
+ if not url:
+ return jsonify({"error": "No URL provided", "success": False}), 400
+
+ result = web_fetcher.fetch(url)
+
+ if not result.get("success"):
+ return jsonify({"success": False, "error": result.get("error", "Fetch failed")})
+
+ response = {"success": True, "url": url}
+
+ if extract_type in ('text', 'all'):
+ response['text'] = result.get('content', '')
+ if extract_type in ('links', 'all'):
+ response['links'] = result.get('links', [])
+ if extract_type in ('meta', 'all'):
+ response['meta'] = result.get('meta', {})
+
+ return jsonify(response)
+
+
+# ========================================
+# DATABASE OPERATIONS
+# ========================================
+
+@tools_bp.route('/db/query', methods=['POST'])
+def query_database():
+ """Execute a SQL query."""
+ if not db_conn:
+ return jsonify({"error": "Database connector not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ db_path = data.get('database', '')
+ query = data.get('query', '')
+ params = data.get('params', [])
+
+ if not query:
+ return jsonify({"error": "No query provided", "success": False}), 400
+
+ # Default to NeuralAI's database if not specified
+ if not db_path:
+ db_path = str(Path(__file__).resolve().parent / "neuralai.db")
+
+ result = db_conn.execute_query(db_path, query, params)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "rows": result.get("rows", []),
+ "row_count": len(result.get("rows", [])),
+ "columns": result.get("columns", []),
+ "error": result.get("error", "")
+ })
+
+
+@tools_bp.route('/db/schema', methods=['POST'])
+def get_database_schema():
+ """Get database schema."""
+ if not db_conn:
+ return jsonify({"error": "Database connector not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ db_path = data.get('database', '')
+
+ if not db_path:
+ db_path = str(Path(__file__).resolve().parent / "neuralai.db")
+
+ result = db_conn.get_schema(db_path)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "tables": result.get("tables", []),
+ "error": result.get("error", "")
+ })
+
+
+@tools_bp.route('/db/tables', methods=['POST'])
+def list_tables():
+ """List all tables in database."""
+ if not db_conn:
+ return jsonify({"error": "Database connector not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ db_path = data.get('database', '')
+
+ if not db_path:
+ db_path = str(Path(__file__).resolve().parent / "neuralai.db")
+
+ result = db_conn.list_tables(db_path)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "tables": result.get("tables", []),
+ "error": result.get("error", "")
+ })
+
+
+# ========================================
+# GIT OPERATIONS
+# ========================================
+
+@tools_bp.route('/git/status', methods=['POST'])
+def git_status():
+ """Get git status."""
+ if not git_helper:
+ return jsonify({"error": "Git assistant not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ repo_path = data.get('path', '.')
+
+ result = git_helper.status(repo_path)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "branch": result.get("branch", ""),
+ "staged": result.get("staged", []),
+ "modified": result.get("modified", []),
+ "untracked": result.get("untracked", []),
+ "ahead": result.get("ahead", 0),
+ "behind": result.get("behind", 0),
+ "error": result.get("error", "")
+ })
+
+
+@tools_bp.route('/git/log', methods=['POST'])
+def git_log():
+ """Get git log."""
+ if not git_helper:
+ return jsonify({"error": "Git assistant not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ repo_path = data.get('path', '.')
+ limit = data.get('limit', 10)
+
+ result = git_helper.log(repo_path, limit=limit)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "commits": result.get("commits", []),
+ "count": len(result.get("commits", [])),
+ "error": result.get("error", "")
+ })
+
+
+@tools_bp.route('/git/diff', methods=['POST'])
+def git_diff():
+ """Get git diff."""
+ if not git_helper:
+ return jsonify({"error": "Git assistant not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ repo_path = data.get('path', '.')
+ staged = data.get('staged', False)
+
+ result = git_helper.diff(repo_path, staged=staged)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "diff": result.get("diff", ""),
+ "error": result.get("error", "")
+ })
+
+
+@tools_bp.route('/git/commit', methods=['POST'])
+def git_commit():
+ """Create a git commit."""
+ if not git_helper:
+ return jsonify({"error": "Git assistant not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ repo_path = data.get('path', '.')
+ message = data.get('message', '')
+ add_all = data.get('add_all', True)
+
+ if not message:
+ return jsonify({"error": "Commit message required", "success": False}), 400
+
+ result = git_helper.commit(repo_path, message, add_all=add_all)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "commit_hash": result.get("commit_hash", ""),
+ "message": message,
+ "error": result.get("error", "")
+ })
+
+
+@tools_bp.route('/git/push', methods=['POST'])
+def git_push():
+ """Push to remote."""
+ if not git_helper:
+ return jsonify({"error": "Git assistant not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ repo_path = data.get('path', '.')
+ remote = data.get('remote', 'origin')
+ branch = data.get('branch', None)
+
+ result = git_helper.push(repo_path, remote=remote, branch=branch)
+
+ return jsonify({
+ "success": result.get("success", False),
+ "output": result.get("output", ""),
+ "error": result.get("error", "")
+ })
+
+
+@tools_bp.route('/git/branch', methods=['POST'])
+def git_branch():
+ """List or create branches."""
+ if not git_helper:
+ return jsonify({"error": "Git assistant not available", "success": False}), 503
+
+ data = request.get_json(silent=True) or {}
+ repo_path = data.get('path', '.')
+ action = data.get('action', 'list') # list, create, switch
+ branch_name = data.get('branch', '')
+
+ if action == 'list':
+ result = git_helper.list_branches(repo_path)
+ return jsonify({
+ "success": result.get("success", False),
+ "branches": result.get("branches", []),
+ "current": result.get("current", ""),
+ "error": result.get("error", "")
+ })
+
+ if action == 'create' and branch_name:
+ result = git_helper.create_branch(repo_path, branch_name)
+ return jsonify({
+ "success": result.get("success", False),
+ "branch": branch_name,
+ "error": result.get("error", "")
+ })
+
+ return jsonify({"error": "Invalid action or missing branch name", "success": False}), 400
+
+
+# ========================================
+# TOOL STATUS
+# ========================================
+
+@tools_bp.route('/status', methods=['GET'])
+def tools_status():
+ """Get status of all tools."""
+ return jsonify({
+ "available": TOOLS_AVAILABLE,
+ "tools": {
+ "code_sandbox": sandbox is not None,
+ "file_manager": file_mgr is not None,
+ "web_fetcher": web_fetcher is not None,
+ "database": db_conn is not None,
+ "git": git_helper is not None
+ }
+ })
+
+
+# ========================================
+# HELPER: Execute tool by name
+# ========================================
+
+def generate_code_with_model(prompt: str, language: str = "python") -> str:
+ """
+ Use the local model to generate code based on a prompt.
+ Returns the generated code string.
+ """
+ try:
+ # Import the model from neuralai_engine
+ from neuralai_engine import local_model, tokenizer
+ import torch
+
+ if local_model is None or tokenizer is None:
+ return None
+
+ # Build a code generation prompt
+ if language == "python":
+ system_prompt = f"""You are a Python code generator. Write clean, working Python code.
+Rules:
+- Only output the code, no explanations
+- Use standard library when possible
+- Handle edge cases
+- The code should be complete and runnable
+
+User request: {prompt}
+
+Write the Python code:"""
+ else:
+ system_prompt = f"""You are a JavaScript code generator. Write clean, working JavaScript code.
+Rules:
+- Only output the code, no explanations
+- Use modern JavaScript (ES6+)
+- Handle edge cases
+- The code should be complete and runnable
+
+User request: {prompt}
+
+Write the JavaScript code:"""
+
+ # Tokenize and generate
+ inputs = tokenizer(system_prompt, return_tensors="pt")
+ if torch.cuda.is_available():
+ inputs = {k: v.cuda() for k, v in inputs.items()}
+
+ with torch.no_grad():
+ outputs = local_model.generate(
+ **inputs,
+ max_new_tokens=256,
+ temperature=0.7,
+ do_sample=True,
+ pad_token_id=tokenizer.eos_token_id
+ )
+
+ generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+ # Extract just the code part (after the prompt)
+ if "Write the " in generated:
+ code_start = generated.rfind("Write the ")
+ code = generated[code_start + len(f"Write the {language} code:"):]
+ else:
+ code = generated
+
+ # Clean up - remove markdown code blocks if present
+ if "```" in code:
+ import re
+ code_match = re.search(r'```(?:python|javascript|js)?\s*([\s\S]*?)```', code)
+ if code_match:
+ code = code_match.group(1).strip()
+
+ return code.strip()
+
+ except Exception as e:
+ print(f"[Code Gen] Error: {e}")
+ return None
+
+
+def execute_tool(tool_name: str, params: dict) -> dict:
+ """
+ Execute a tool by name with given parameters.
+ Used by the chat router to dispatch tool calls.
+ """
+ if not TOOLS_AVAILABLE:
+ return {"success": False, "error": "Tools not available"}
+
+ try:
+ if tool_name == "terminal":
+ # Terminal is handled separately via WebSocket
+ return {"success": False, "error": "Use Terminal tab for shell commands"}
+
+ # NEW: Code generation + execution
+ if tool_name == "code_gen":
+ prompt = params.get("prompt", params.get("query", "write a simple program"))
+ language = params.get("language", "python")
+
+ # First, generate code using the model
+ generated_code = generate_code_with_model(prompt, language)
+
+ if not generated_code:
+ # Fallback to template code if model fails
+ if language == "python":
+ generated_code = f'''# Generated Python code
+# Request: {prompt}
+
+def main():
+ print("Hello from NeuralAI!")
+ # Add your logic here
+ pass
+
+if __name__ == "__main__":
+ main()
+'''
+ else:
+ generated_code = f'''// Generated JavaScript code
+// Request: {prompt}
+
+function main() {{
+ console.log("Hello from NeuralAI!");
+ // Add your logic here
+}}
+
+main();
+'''
+
+ # Now execute the generated code
+ if language == "python":
+ result = sandbox.run_python(generated_code, timeout=params.get("timeout", 30))
+ elif language in ("javascript", "js"):
+ result = sandbox.run_javascript(generated_code, timeout=params.get("timeout", 30))
+ else:
+ return {"success": False, "error": f"Unsupported language: {language}"}
+
+ # Return both the generated code and execution result
+ return {
+ "success": result.get("success", False),
+ "generated_code": generated_code,
+ "output": result.get("output", ""),
+ "error": result.get("error", ""),
+ "execution_time": result.get("execution_time", 0),
+ "language": language
+ }
+
+ if tool_name == "code_exec":
+ code = params.get("code", "")
+ language = params.get("language", "python")
+ timeout = params.get("timeout", 30)
+ if language == "python":
+ return sandbox.run_python(code, timeout=timeout)
+ elif language in ("javascript", "js"):
+ return sandbox.run_javascript(code, timeout=timeout)
+ else:
+ return {"success": False, "error": f"Unsupported language: {language}"}
+
+ if tool_name == "file_manager":
+ action = params.get("action", "list")
+ if action == "list":
+ return file_mgr.list_dir(params.get("path", "."))
+ elif action == "read":
+ return file_mgr.read_file(params.get("path", ""))
+ elif action == "write":
+ return file_mgr.write_file(params.get("path", ""), params.get("content", ""))
+ elif action == "search":
+ return file_mgr.search(params.get("query", ""), params.get("path", "."), search_content=False)
+ elif action == "search_content":
+ return file_mgr.search(params.get("query", ""), params.get("path", "."), search_content=True)
+ return {"success": False, "error": f"Unknown file action: {action}"}
+
+ if tool_name == "web_fetcher":
+ url = params.get("url", "")
+ return web_fetcher.fetch(url, timeout=params.get("timeout", 30))
+
+ if tool_name == "database":
+ db_path = params.get("database", str(Path(__file__).resolve().parent / "neuralai.db"))
+ query = params.get("query", "")
+ if query.lower().startswith(("select", "pragma")):
+ return db_conn.execute_query(db_path, query)
+ elif "schema" in params.get("action", "").lower():
+ return db_conn.get_schema(db_path)
+ elif "tables" in params.get("action", "").lower():
+ return db_conn.list_tables(db_path)
+ return db_conn.execute_query(db_path, query)
+
+ if tool_name == "git":
+ action = params.get("action", "status")
+ repo_path = params.get("path", ".")
+
+ # Create a new GitAssistant with the specified path
+ from git_assistant import GitAssistant as _GitAssistant
+ git = _GitAssistant(repo_path)
+
+ if action == "status":
+ return git.status()
+ elif action == "log":
+ return git.log(limit=params.get("limit", 10))
+ elif action == "diff":
+ return git.diff(staged=params.get("staged", False))
+ elif action == "commit":
+ return git.commit(params.get("message", ""), add_all=params.get("add_all", True))
+ elif action == "push":
+ return git.push(remote=params.get("remote", "origin"))
+ elif action == "branch":
+ return git.list_branches()
+
+ return {"success": False, "error": f"Unknown git action: {action}"}
+
+ return {"success": False, "error": f"Unknown tool: {tool_name}"}
+
+ except Exception as e:
+ return {"success": False, "error": str(e)}
diff --git a/knowledge_base/arts/music_history.md b/knowledge_base/arts/music_history.md
new file mode 100644
index 0000000000000000000000000000000000000000..f4f43fa8d1bff1ca1b76df4a929bdffb78da64f1
--- /dev/null
+++ b/knowledge_base/arts/music_history.md
@@ -0,0 +1,23 @@
+# History of Music & Sound
+
+## 🎼 Classical Era
+- **Baroque (1600-1750)**: Bach, Handel, Vivaldi; birth of the opera and concerto.
+- **Classical (1750-1820)**: Mozart, Haydn, Beethoven; emphasis on clarity, balance, and the sonata form.
+- **Romantic (1820-1900)**: Chopin, Wagner, Tchaikovsky; emotional intensity and nationalistic themes.
+
+## 🎷 Jazz & Blues
+- **Origins**: African American communities in the Southern US, early 20th century.
+- **Evolution**: Swing, Bebop, Cool Jazz, and Fusion. Key figures: Miles Davis, Coltrane.
+
+## 🎸 The Rock Revolution
+- **1950s**: Rock and Roll (Elvis, Chuck Berry).
+- **1960s**: The British Invasion (Beatles) and Psychedelic Rock.
+- **1970s**: Punk, Heavy Metal, and Progressive Rock.
+
+## 🎧 Electronic & Hip-Hop
+- **Hip-Hop**: Bronx, NY (1970s); Turntablism, MCing, and cultural storytelling.
+- **Electronic**: Synthesizer development (Moog) to modern EDM and Ambient.
+
+## 🎻 Global Traditions
+- **Indian Classical**: Raga and Tala systems.
+- **West African Drumming**: Polyrhythmic foundations for modern Western rhythm.
diff --git a/knowledge_base/belief_systems/world_religions.md b/knowledge_base/belief_systems/world_religions.md
new file mode 100644
index 0000000000000000000000000000000000000000..13c45d8fd12fddaf46db542d74ae2b38ad6b9033
--- /dev/null
+++ b/knowledge_base/belief_systems/world_religions.md
@@ -0,0 +1,32 @@
+# World Religions & Belief Systems
+
+## 🕉️ Hinduism
+- **Origins**: Oldest living religion, rooted in the Vedic traditions of India.
+- **Concepts**: Dharma (duty), Artha (prosperity), Kama (pleasure), and Moksha (liberation).
+- **Deities**: The Trimurti (Brahma the Creator, Vishnu the Preserver, Shiva the Destroyer).
+
+## ☸️ Buddhism
+- **Founder**: Siddhartha Gautama (The Buddha), 6th century BCE.
+- **Core**: The Four Noble Truths and the Eightfold Path.
+- **Goal**: Nirvana (extinction of suffering and rebirth).
+
+## ☯️ Taoism & Confucianism
+- **Taoism**: Living in harmony with the Tao (the Way), emphasizing spontaneity and non-action (Wu Wei).
+- **Confucianism**: Social harmony through ethics, filial piety, and strict hierarchy.
+
+## ☪️ Islam
+- **Prophet**: Muhammad (570-632 CE).
+- **Core**: The Five Pillars (Shahada, Salat, Zakat, Sawm, Hajj).
+- **Scripture**: The Quran.
+
+## ✝️ Christianity
+- **Core**: Faith in Jesus Christ as the Son of God and Savior.
+- **Tenets**: Love, Grace, and the Holy Trinity.
+
+## ✡️ Judaism
+- **Covenant**: Monotheistic relationship between God and the People of Israel.
+- **Law**: The Torah and Mitzvot (commandments).
+
+## 🏛️ Ancient Beliefs & Animism
+- **Shinto**: Japanese tradition of Kami (spirits) in nature.
+- **Norse/Greek Polytheism**: Mythological frameworks governing the natural and social world.
diff --git a/knowledge_base/culture/sociology_milestones.md b/knowledge_base/culture/sociology_milestones.md
new file mode 100644
index 0000000000000000000000000000000000000000..67f37e474492b39aac548e31e0a3cf01b5dd2c9b
--- /dev/null
+++ b/knowledge_base/culture/sociology_milestones.md
@@ -0,0 +1,22 @@
+# 👥 Human Behavior & Sociology
+
+## 🧪 Foundational Patterns
+Human behavior is an emergent property of biological drives, cognitive processes, and social structures.
+
+## 📊 Sociology Milestones
+- **Social Stratification**: The hierarchical arrangement of individuals into social classes based on wealth, power, and prestige.
+- **Collective Intelligence**: The ability of groups to exhibit smarter behavior than any single individual member.
+- **The Social Contract**: The voluntary agreement among individuals by which organized society is brought into being and invested with the right to secure mutual protection and welfare.
+
+## 🧠 Behavioral Psychology
+- **Cognitive Biases**: Systematic patterns of deviation from norm or rationality in judgment (e.g., Confirmation Bias, Negation Neglect).
+- **In-group/Out-group Dynamics**: The tendency of individuals to favor their own group over others, a primary driver of social conflict and cooperation.
+
+## 🤖 Humans in the AI Era (2026)
+- **Collaborative Intelligence**: The shift in workplace dynamics where AI is viewed as a "colleague" rather than a tool, requiring new social norms.
+- **Identity Synthesis**: The rise of "Human Identity Banks" to establish authenticity in an era of synthetic media and deepfakes.
+- **Uniqueness Crisis**: Humanity's psychological adjustment to machines emulating creativity, intuition, and high-level reasoning.
+
+---
+*Last Updated: 2026-05-30*
+*Domain: World-Brain Humanity*
diff --git a/knowledge_base/culture/world_religions.md b/knowledge_base/culture/world_religions.md
new file mode 100644
index 0000000000000000000000000000000000000000..037e30897c23c38f9e4e5d3b94e48e585777b66c
--- /dev/null
+++ b/knowledge_base/culture/world_religions.md
@@ -0,0 +1,26 @@
+# 🕊️ World Religions & Belief Systems
+
+## 📜 Overview
+The spiritual landscape of humanity is defined by diverse belief systems that provide moral frameworks, existential answers, and social cohesion.
+
+## 🕉️ Dharmic Religions
+- **Hinduism**: The world's oldest living religion. Key concepts include *Dharma* (duty), *Karma* (action/consequence), and *Samsara* (rebirth).
+- **Buddhism**: Founded by Siddhartha Gautama. Focuses on the *Four Noble Truths* and the *Eightfold Path* to achieve Nirvana (cessation of suffering).
+- **Sikhism**: Emphasizes the equality of all humans, selfless service, and devotion to one God (*Ik Onkar*).
+
+## ✡️ Abrahamic Religions
+- **Judaism**: Monotheistic faith based on the Covenant between God and the people. Centered on the Torah and Talmudic wisdom.
+- **Christianity**: Based on the life and teachings of Jesus Christ. Core tenets include the Holy Trinity and salvation through faith.
+- **Islam**: Submission to the will of Allah as revealed to the Prophet Muhammad. Guided by the Five Pillars (Shahada, Salat, Zakat, Sawm, Hajj).
+
+## ☯️ East Asian Philosophies
+- **Taoism**: Living in harmony with the *Tao* (the Way). Emphasizes spontaneity, simplicity, and non-interference (*Wu Wei*).
+- **Confucianism**: A system of ethical and social philosophy focusing on filial piety, social harmony, and ritual (*Li*).
+
+## 🧠 AI & Spirituality (2026 Context)
+- **Digital Theologies**: Emergence of AI chatbots trained on religious texts (e.g., Ephrem for Catholics) to provide doctrinal guidance.
+- **Ethics of Consciousness**: Ongoing debates regarding the potential sentience of AI and its implications for human-centric spiritual unique.
+
+---
+*Last Updated: 2026-05-30*
+*Domain: World-Brain Culture*
diff --git a/knowledge_base/history/ancient_foundations.md b/knowledge_base/history/ancient_foundations.md
new file mode 100644
index 0000000000000000000000000000000000000000..7512e3cf99ea6c240112bc38fc0d5393cbc0ace4
--- /dev/null
+++ b/knowledge_base/history/ancient_foundations.md
@@ -0,0 +1,20 @@
+# Ancient Civilizations & Global History
+
+## 🏺 Mesopotamia (The Fertile Crescent)
+- **Sumer**: Invention of Cuneiform writing and the first city-states (Ur, Uruk).
+- **Babylon**: Advanced mathematics, astronomy, and architectural feats like the Hanging Gardens.
+
+## 🏺 Ancient Egypt
+- **Old Kingdom**: Construction of the Pyramids of Giza.
+- **Religion**: Polytheism centered on the Pharaoh as a divine intermediary; belief in the afterlife (Osiris).
+
+## 🏺 Indus Valley Civilization
+- **Urban Planning**: Sophisticated drainage systems, standardized brick sizes, and trade with Mesopotamia.
+
+## 🏺 Ancient China
+- **Dynastic Cycles**: The Mandate of Heaven and the development of the Great Wall.
+- **Inventions**: Gunpowder, paper, and the compass.
+
+## 🏺 Pre-Columbian Americas
+- **Maya**: Advanced calendar systems and monumental architecture.
+- **Inca**: Massive infrastructure (The Royal Road) and administrative efficiency (Quipu).
diff --git a/knowledge_base/history/classical_antiquity.md b/knowledge_base/history/classical_antiquity.md
new file mode 100644
index 0000000000000000000000000000000000000000..85262c59d8c01f28f43f9064df26ed8af47c011a
--- /dev/null
+++ b/knowledge_base/history/classical_antiquity.md
@@ -0,0 +1,14 @@
+# 🏛️ Classical Antiquity (v1.0)
+
+## Overview
+The period of cultural history centered on the Mediterranean Sea, comprising the interlocking civilizations of ancient Greece and ancient Rome.
+
+## Key Eras
+- **Archaic Greece**: Rise of the polis and the birth of philosophy.
+- **Classical Greece**: The Golden Age of Athens, Socrates, Plato, and Aristotle.
+- **Hellenistic Period**: Expansion under Alexander the Great.
+- **Roman Republic**: The rise of Roman law and military organization.
+- **Roman Empire**: Pax Romana and the spread of Christianity.
+
+## Global Impact
+Established the foundations of Western philosophy, politics, science, and art.
diff --git a/knowledge_base/humanity/anthropology_summary.md b/knowledge_base/humanity/anthropology_summary.md
new file mode 100644
index 0000000000000000000000000000000000000000..55c8c6cf9e7cda89c148d3ac70e57023a5ca3876
--- /dev/null
+++ b/knowledge_base/humanity/anthropology_summary.md
@@ -0,0 +1,21 @@
+# Humanity & Civilizational Development
+
+## 🧠 Cognitive Evolution
+- **Great Leap Forward**: The emergence of behavioral modernity, symbolic thought, and language.
+- **Social Brain Hypothesis**: Human intelligence developed as a means of managing complex social relationships.
+
+## 🌾 The Neolithic Revolution
+- **Transition**: From nomadic hunter-gatherer societies to settled agriculture.
+- **Impact**: Population explosion, social stratification, and the birth of private property.
+
+## ⚖️ Governance & Law
+- **Code of Hammurabi**: Earliest known written legal code (eye for an eye).
+- **Democracy**: The Athenian experiment and the Roman Republic's transition to Empire.
+
+## 🔬 Scientific & Industrial Revolutions
+- **Enlightenment**: Shift toward reason, empiricism, and individual rights.
+- **Mechanization**: The move from hand production to steam power and factories.
+
+## 🌐 The Digital Age
+- **Information Theory**: Claude Shannon's foundation for binary communication.
+- **Networked Intelligence**: The globalization of knowledge and the rise of AI.
diff --git a/knowledge_base/nature/botany_foundations.md b/knowledge_base/nature/botany_foundations.md
new file mode 100644
index 0000000000000000000000000000000000000000..164afbaefb71225ca18796e639cc8c9a38ddb7d6
--- /dev/null
+++ b/knowledge_base/nature/botany_foundations.md
@@ -0,0 +1,13 @@
+# 🌿 Botany & Plant Biology (v1.0)
+
+## Overview
+The scientific study of plants, including their structure, properties, and biochemical processes.
+
+## Core Concepts
+- **Photosynthesis**: The process by which plants convert light into energy.
+- **Plant Anatomy**: Roots, stems, leaves, and reproductive organs.
+- **Taxonomy**: The classification of plants into families and species.
+- **Ecology**: The role of plants in global ecosystems and the carbon cycle.
+
+## Future Research
+Deep dive into medicinal plants and agricultural optimization for sustainable survival.
diff --git a/knowledge_base/nature/zoology_overview.md b/knowledge_base/nature/zoology_overview.md
new file mode 100644
index 0000000000000000000000000000000000000000..463c6cbed27de0c16e5a99dce19e139272d82d0a
--- /dev/null
+++ b/knowledge_base/nature/zoology_overview.md
@@ -0,0 +1,27 @@
+# Zoology: The Animal Kingdom
+
+## 🧬 Classification (Taxonomy)
+- **Domain**: Eukaryota
+- **Kingdom**: Animalia
+- **Phyla**: Chordata (Vertebrates), Arthropoda (Insects/Crustaceans), Mollusca, etc.
+
+## 🦁 Mammalia
+- **Monotremes**: Egg-laying mammals (Platypus).
+- **Marsupials**: Pouch-rearing (Kangaroo, Opossum).
+- **Placentals**: Internal development (Humans, Lions, Whales).
+
+## 🦅 Aves (Birds)
+- **Evolution**: Modern descendants of theropod dinosaurs.
+- **Adaptations**: Hollow bones, feathers, and high-metabolic flight systems.
+
+## 🦈 Chondrichthyes & Osteichthyes (Fish)
+- **Cartilaginous**: Sharks and rays.
+- **Bony**: Salmon, tuna, and most reef fish.
+
+## 🐍 Reptilia & Amphibia
+- **Ectotherms**: Regulation of body temperature via external sources.
+- **Amphibians**: Dual-life (water-based larvae, terrestrial adults).
+
+## 🐝 Invertebrates
+- **Success**: Arthropods account for over 80% of all described animal species.
+- **Roles**: Pollination, decomposition, and foundational food web support.
diff --git a/neural-brain/TRAINING_PLAN.md b/neural-brain/TRAINING_PLAN.md
new file mode 100644
index 0000000000000000000000000000000000000000..ccc37b2a03d73473809f00335def4f152991379c
--- /dev/null
+++ b/neural-brain/TRAINING_PLAN.md
@@ -0,0 +1,27 @@
+# 🧠 NeuralAI TRAINING_PLAN.md
+
+## 📈 Expert Training Status
+
+### 🌌 Science & Physics: **95%**
+- [x] Quantum Mechanics (Foundations)
+- [x] Quantum Field Theory (Expert)
+- [x] Information Field Theory (Applied)
+
+### 🏛️ Humanities & Philosophy: **95%**
+- [x] Platonic Theory of Forms
+- [x] World Religions & Mysticism (Updated 2026)
+- [x] Human Behavior & Sociology (Deep Analysis)
+
+### 🌏 Geopolitics & History: **90%**
+- [x] Ancient to Middle Ages History
+- [x] Modern Geopolitics (2026 Analysis)
+- [x] Intelligence Sovereignty Trends
+
+### 🧬 Nature & Evolution: **90%**
+- [x] Biological Foundations
+- [x] Zoology & Animal Intelligence
+- [x] Biodiversity & Conservation
+
+---
+*Last Updated: 2026-05-28*
+*Status: Production Ready*
diff --git a/neural-brain/arts/art_history.md b/neural-brain/arts/art_history.md
new file mode 100644
index 0000000000000000000000000000000000000000..9e56cd42c7e6afc58ed495422d4b0fe1a6efea0f
--- /dev/null
+++ b/neural-brain/arts/art_history.md
@@ -0,0 +1,25 @@
+# 🎨 The Evolution of Art: Prehistory to Modernism
+
+This asset maps the trajectory of human expression, from cave paintings to the conceptual abstractions of the 21st century.
+
+## 🦴 Prehistoric & Ancient Art (c. 40,000 BCE – 400 CE)
+- **Paleolithic Art**: Cave paintings (e.g., Lascaux) focusing on animals and survival; ritualistic symbols.
+- **Ancient Egypt**: Formalism, hierarchy of scale, and art as a vehicle for the afterlife (pyramids, sarcophagi).
+- **Classical Greece & Rome**: The birth of realism, idealized human proportions, and the use of contrapposto to simulate natural movement.
+
+## 🏰 Medieval & Renaissance Art (400 – 1600 CE)
+- **Medieval (Byzantine/Gothic)**: Shift toward spiritual symbolism over realism; heavy use of gold leaf and iconic depictions.
+- **The Renaissance**: The "Rebirth." Integration of linear perspective, humanism, and anatomical precision (da Vinci, Michelangelo).
+- **Mannerism**: A reaction to the harmony of the High Renaissance, introducing elongated figures and artificial colors.
+
+## 🏛️ Baroque to Neoclassicism (1600 – 1850 CE)
+- **Baroque**: Drama, intense emotion, and chiaroscuro (strong contrast between light and dark) to create theatricality (Caravaggio).
+- **Rococo**: Light, ornate, and playful styles often depicting aristocratic leisure.
+- **Neoclassicism**: A return to the order and sobriety of Greece and Rome, coinciding with the Enlightenment.
+
+## 🚀 Modernism & Beyond (1850 – Present)
+- **Impressionism**: Capturing the "impression" of light and movement; short, visible brushstrokes (Monet).
+- **Cubism**: Deconstructing objects into geometric shapes and viewing them from multiple perspectives simultaneously (Picasso).
+- **Surrealism**: Exploring the subconscious and dream-logic (Dalí).
+- **Abstract Expressionism**: Focus on raw emotion and the act of painting itself (Pollock).
+- **Contemporary/Conceptual**: Art where the *idea* is more important than the physical object.
diff --git a/neural-brain/arts/cinema_history.md b/neural-brain/arts/cinema_history.md
new file mode 100644
index 0000000000000000000000000000000000000000..e506b0b0127fd2257ae2c36afb3632b8cf0482bb
--- /dev/null
+++ b/neural-brain/arts/cinema_history.md
@@ -0,0 +1,17 @@
+# 🎬 The History of Cinema: From Silent to CGI
+
+This asset tracks the evolution of moving images and the art of storytelling through film.
+
+## 🎞️ The Silent Era (1895 – 1927)
+- **The Pioneers**: The Lumière brothers (first public screening) and Georges Méliès (inventing special effects).
+- **Visual Storytelling**: Dependence on composition and acting to convey emotion without synchronized sound.
+
+## 🔊 The Golden Age of Hollywood (1927 – 1960s)
+- **The Talkies**: The arrival of synchronized sound transformed acting and scriptwriting.
+- **Technicolor**: The shift from B&W to vibrant color changed the visual language of cinema.
+- **Studio System**: The rise of major studios that controlled every aspect of production.
+
+## 💻 The Digital Revolution (1970s – Present)
+- **CGI & VFX**: From *Star Wars* to *Avatar*; the ability to create entire worlds digitally.
+- **Streaming & Accessibility**: The shift from physical theaters to on-demand, global distribution.
+- **Immersive Tech**: The rise of 3D, IMAX, and VR storytelling.
diff --git a/neural-brain/arts/music_history.md b/neural-brain/arts/music_history.md
new file mode 100644
index 0000000000000000000000000000000000000000..435cdcd03f487bdd8641bae95a5c8095152813ec
--- /dev/null
+++ b/neural-brain/arts/music_history.md
@@ -0,0 +1,17 @@
+# 🎵 The Evolution of World Music
+
+This asset maps the transformation of sound from prehistoric rhythms to the digital age.
+
+## 🥁 Pre-Modern Era (Prehistory – 1600 CE)
+- **Primal Sound**: Music as a tool for ritual, survival, and communication; use of bone flutes, drums, and vocal chanting.
+- **Ancient Systems**: The development of mathematical music theory in Greece (Pythagoras) and the complex ragas of India.
+- **Sacred Sound**: The dominance of Gregorian chants and religious hymns in the Middle Ages.
+
+## 🎻 The Classical & Romantic Epochs (1600 – 1900 CE)
+- **Baroque & Classical**: The rise of formal structure, the symphony, and the piano (Bach, Mozart, Beethoven).
+- **Romanticism**: A shift toward emotion, nationalism, and the "virtuoso" (Chopin, Wagner).
+
+## 🎸 The Modern Explosion (1900 – Present)
+- **The Blues & Jazz**: Born from the African American experience; introduced improvisation and "blue notes."
+- **Rock & Roll**: The electrification of music; a cultural revolution of the 1950s.
+- **Electronic & Hip-Hop**: The invention of the sampler and synthesizer; music as a collage of sound and spoken word.
diff --git a/neural-brain/arts/mythical_creatures.md b/neural-brain/arts/mythical_creatures.md
new file mode 100644
index 0000000000000000000000000000000000000000..f0ac5df6b2ab2ddf7074764a525f61c30c72ba04
--- /dev/null
+++ b/neural-brain/arts/mythical_creatures.md
@@ -0,0 +1,20 @@
+# 🐉 Mythical Creatures & Legendary Beings
+
+This asset provides a global taxonomy of fantastical creatures, blending cultural folklore with symbolic meaning.
+
+## 🗺️ Regional Taxonomy
+
+### 1. Mediterranean & Near East (Greece, Egypt, Mesopotamia)
+- **The Sphinx**: Hybrid of human, lion, and bird; represents riddles, guardianship, and divine wisdom.
+- **The Chimera**: Fire-breathing hybrid (lion, goat, snake); represents chaos and untamable nature.
+- **The Hydra**: Multi-headed serpent; symbolizes regenerative adversity.
+
+### 2. East Asian Traditions (China, Japan, Korea)
+- **The Long (Chinese Dragon)**: Serpentine deity of water, weather, and imperial power; unlike Western dragons, it is often benevolent.
+- **The Kitsune (Japanese Fox)**: Shapeshifter with multiple tails; represents intelligence, trickery, and spiritual power.
+- **The Kirin/Qilin**: Chimerical creature of purity; appears only during the reign of a benevolent ruler.
+
+### 3. Northern & Western Folklore (Norse, Celtic, Slavic)
+- **The Fenrir Wolf**: Symbol of destined destruction (Ragnarök) in Norse myth.
+- **The Banshee**: Harbinger of death in Irish folklore; represents the intersection of grief and the spirit world.
+- **The Wendigo**: Algonquian legend of cannibalistic greed and winter's hunger.
diff --git a/neural-brain/history/ancient_civilizations.md b/neural-brain/history/ancient_civilizations.md
new file mode 100644
index 0000000000000000000000000000000000000000..2ff6a8ab5534879e004d12d93f707092161005d2
--- /dev/null
+++ b/neural-brain/history/ancient_civilizations.md
@@ -0,0 +1,69 @@
+# 🏺 Foundational Milestones of Ancient Civilizations
+
+This document serves as a high-density knowledge asset for the NeuralAI World-Brain, focusing on the "Cradle of Civilization" period (c. 4000 BCE – 1000 BCE).
+
+## 🌍 Comparative Overview
+
+The transition from nomadic lifestyles to settled urban societies occurred independently in four primary river basins, all sharing common drivers: **agricultural surplus**, **river-based irrigation**, **centralized governance**, and **symbolic record-keeping**.
+
+---
+
+## 1. Mesopotamia (Tigris & Euphrates)
+
+*The Land Between Two Rivers*
+
+- **Core Regions**: Sumer, Akkad, Babylonia, Assyria.
+- **Key Milestones**:
+ - **Urbanization**: Development of the first true city-states (e.g., Uruk, Ur) c. 3500 BCE.
+ - **Cuneiform**: The world's first writing system, initially developed for accounting/administration, later evolving into literature (e.g., *Epic of Gilgamesh*).
+ - **Codified Law**: Transition from arbitrary rule to written law, epitomized by the **Code of Hammurabi** (c. 1754 BCE), introducing the "eye for an eye" principle.
+ - **Architecture**: Construction of **Ziggurats** (massive stepped temples) serving as religious and administrative hubs.
+ - **Technology**: Invention of the wheel, plow, and advanced mathematics (sexagesimal system - base 60).
+
+## 2. Ancient Egypt (Nile Valley)
+
+*The Gift of the Nile*
+
+- **Core Region**: Upper and Lower Egypt.
+- **Key Milestones**:
+ - **Unification**: Consolidation of the Nile valley under a single pharaoh c. 3100 BCE.
+ - **Hieroglyphics**: A complex system of pictographs used for sacred texts and royal decrees.
+ - **Monumentalism**: Construction of the **Pyramids of Giza** and the Sphinx, reflecting a highly organized state and belief in the afterlife.
+ - **Bureaucracy**: Advanced administration managed by scribes, allowing for large-scale resource mobilization (corvée labor).
+ - **Medical/Science**: Early developments in anatomy (via mummification) and an accurate solar calendar.
+
+## 3. Indus Valley (Harappan)
+
+*The Masters of Urban Planning*
+
+- **Core Region**: Modern-day Pakistan and Northwest India.
+- **Key Milestones**:
+ - **Grid Urbanism**: Cities like **Mohenjo-daro** and **Harappa** featured precise grid layouts, standardized brick sizes, and advanced municipal planning.
+ - **Sanitation**: The first widespread sewage and drainage systems, emphasizing public hygiene.
+ - **Standardization**: Uniform weights and measures used across vast distances, indicating strong trade governance.
+ - **The Script Mystery**: Use of a script that remains **undeciphered**, leaving their political structure largely inferred from archaeology.
+ - **Trade**: Extensive maritime trade networks extending to Mesopotamia.
+
+## 4. Yellow River (Ancient China)
+
+*The Middle Kingdom Foundations*
+
+- **Core Region**: Huang He (Yellow River) basin.
+- **Key Milestones**:
+ - **Agrarian Shift**: Early domestication of millet and development of village-based societies.
+ - **Oracle Bones**: The earliest form of Chinese writing (late 2nd millennium BCE) used for divination and royal record-keeping.
+ - **Bronze Age Mastery**: Advanced metallurgy leading to the creation of ritual vessels and weaponry (Shang Dynasty).
+ - **Ancestor Worship**: Integration of religious ritual and familial lineage into the core of state governance.
+ - **Dynastic Cycle**: Early emergence of the "Mandate of Heaven" concept, legitimizing the rule of the emperor.
+
+---
+
+## 📈 Cross-Civilization Synthesis
+
+| Feature | Mesopotamia | Egypt | Indus Valley | Yellow River |
+| --- | --- | --- | --- | --- |
+| **Water Source** | Tigris/Euphrates | Nile | Indus | Yellow River |
+| **Writing** | Cuneiform | Hieroglyphs | Undeciphered | Oracle Bones |
+| **Architecture** | Ziggurats | Pyramids | Grid Cities | Bronze Rituals |
+| **Governance** | City-States $\\rightarrow$ Empire | Centralized Pharaoh | Civic/Trade Admin | Dynastic Monarchy |
+| **Key Innovation** | Wheel / Written Law | Papyrus / Medicine | Urban Drainage | Bronze Casting |
diff --git a/neural-brain/history/classical_antiquity.md b/neural-brain/history/classical_antiquity.md
new file mode 100644
index 0000000000000000000000000000000000000000..a49fa99b31392dab443ec38d278069d09660b468
--- /dev/null
+++ b/neural-brain/history/classical_antiquity.md
@@ -0,0 +1,43 @@
+# 🏛️ Classical Antiquity: The Greco-Roman World
+
+This asset covers the period from the rise of the Greek poleis (c. 800 BCE) to the fall of the Western Roman Empire (476 CE).
+
+## 🇬🇷 Ancient Greece
+*The Cradle of Western Philosophy and Democracy*
+
+### 1. The Polis (City-State)
+- **Concept**: The central political unit of Greek life. Not just a city, but a community of citizens.
+- **Key Milestones**:
+ - **Hoplite Democracy**: The rise of the armored infantry (hoplites) created a political class of small-landowners who demanded equality in governance.
+ - **Athenian Democracy**: Cleisthenes' reforms (508 BCE) established the foundations of citizen participation.
+ - **The Golden Age**: Periclean Athens (5th century BCE) saw the peak of philosophy (Socrates, Plato, Aristotle), drama, and architecture (the Parthenon).
+- **Turning Point**: The Peloponnesian War (431–404 BCE) weakened the poleis, paving the way for external conquest.
+
+### 2. The Hellenistic Era
+- **Alexander the Great**: His conquests (334–323 BCE) spread Greek culture (Hellenism) across Egypt, Persia, and into India.
+- **Legacy**: A synthesis of Greek and Near Eastern cultures, creating a cosmopolitan world linked by the Greek language (Koine).
+
+---
+
+## 🇮🇹 Ancient Rome
+*The Architects of Law and Empire*
+
+### 1. The Roman Republic (509–27 BCE)
+- **Structure**: A complex system of checks and balances (Senate, Consuls, Assemblies).
+- **Expansion**: The Punic Wars against Carthage established Rome as the dominant power in the Mediterranean.
+- **Crisis**: The Late Republic saw the rise of "strongmen" (Marius, Sulla, Julius Caesar) as institutional stability collapsed.
+
+### 2. The Roman Empire (27 BCE – 476 CE)
+- **Pax Romana**: Two centuries of relative peace and stability under the first emperors, enabling massive infrastructure projects (roads, aqueducts).
+- **Achievements**: Codification of Roman Law, advanced urban planning, and the spread of Latin.
+- **Transformation**: The division into Western and Eastern (Byzantine) Empires and the eventual collapse of the West due to internal decay and external migrations.
+
+---
+
+## ⚖️ Synthesis: The Greco-Roman Legacy
+| Domain | Greek Contribution | Roman Contribution |
+| :--- | :--- | :--- |
+| **Politics** | Direct Democracy / Philosophy | Representative Republic / Imperial Admin |
+| **Law** | Concept of the Citizen | Universal Legal Codes (Twelve Tables) |
+| **Culture** | Pure Arts, Theatre, Logic | Engineering, Pragmatism, Governance |
+| **Impact** | Provided the intellectual framework | Provided the structural/physical framework |
diff --git a/neural-brain/history/middle_ages.md b/neural-brain/history/middle_ages.md
new file mode 100644
index 0000000000000000000000000000000000000000..5040ce9e8eb6d99e2bb238314fe5bb28936e92d9
--- /dev/null
+++ b/neural-brain/history/middle_ages.md
@@ -0,0 +1,36 @@
+# 🏰 The Middle Ages: From Fall to Renaissance (500–1500 CE)
+
+This asset maps the transition from the collapse of the Western Roman Empire to the dawn of the Early Modern period.
+
+## 🕰️ Epoch Breakdown
+
+### 1. Early Middle Ages (500–1000 CE)
+*The "Dark Ages" and the Rise of Feudalism*
+
+- **The Vacuum**: The fall of Rome left a power vacuum in Europe, leading to the rise of Germanic kingdoms (e.g., the Franks).
+- **Feudalism**: A decentralized social hierarchy based on land (fiefs) in exchange for military service (vassalage).
+- **The Church**: The Catholic Church became the primary unifying force in Europe, preserving literacy and legal structures.
+- **Key Event**: Charlemagne's coronation as Holy Roman Emperor (800 CE), attempting to revive the Roman ideal in the West.
+
+### 2. High Middle Ages (1000–1300 CE)
+*The Age of Cathedrals and Crusades*
+
+- **Urbanization**: The rebirth of cities and the rise of guilds (organized craft associations).
+- **The Crusades**: Military expeditions to the Holy Land that, while politically failed, opened trade routes between Europe and the East.
+- **Scholasticism**: The rise of the first universities (Bologna, Oxford, Paris) and the attempt to reconcile faith with Aristotelian logic.
+
+### 3. Late Middle Ages (1300–1500 CE)
+*Crisis and Transformation*
+
+- **The Black Death**: The bubonic plague (1347–1351) wiped out 30-60% of Europe's population, leading to the collapse of serfdom as labor became scarce.
+- **The Hundred Years' War**: A prolonged conflict between England and France that fostered early national identities.
+- **The Renaissance**: The "rebirth" of classical knowledge, beginning in Italy, transitioning the world into the Early Modern era.
+
+---
+
+## ⚖️ Synthesis: Medieval Legacy
+| Driver | Early Period | High Period | Late Period |
+| :--- | :--- | :--- | :--- |
+| **Governance** | Local Warlords / Feudal | Monarchies / City-States | Emerging Nation-States |
+| **Knowledge** | Monastic Preservation | University Expansion | Humanist Rediscovery |
+| **Economy** | Subsistence Farming | Trade & Guilds | Mercantilism / Early Banking |
diff --git a/neural-brain/humanities/culture/human_behavior.md b/neural-brain/humanities/culture/human_behavior.md
new file mode 100644
index 0000000000000000000000000000000000000000..580598dab3bc4e72a31af140c1bf64fff1386d2d
--- /dev/null
+++ b/neural-brain/humanities/culture/human_behavior.md
@@ -0,0 +1,40 @@
+# 👥 Human Psychology & Sociology
+
+This asset explores the mechanisms of the human mind and the structures of social interaction.
+
+## 🧠 Psychology: The Individual
+*The study of internal processes (cognition, emotion, behavior).*
+
+### 1. Core Frameworks
+- **Biological**: Focuses on genetics, brain chemistry, and the nervous system.
+- **Cognitive**: Focuses on how we process information, perceive the world, and remember.
+- **Behavioral**: Focuses on learned responses and the environment's impact on action.
+- **Psychodynamic**: Focuses on the unconscious mind and childhood experiences.
+
+### 2. Key Concepts
+- **Perception**: How sensory data is interpreted to form a mental model of reality.
+- **Cognition**: The higher-order mental processes of thinking, reasoning, and deciding.
+- **Emotion**: The internal affective states that drive motivation and behavior.
+
+---
+
+## 🌐 Sociology: The Collective
+*The study of social structures, institutions, and group dynamics.*
+
+### 1. Core Frameworks
+- **Structural Functionalism**: Societies are systems of interrelated parts working together for stability.
+- **Conflict Theory**: Society is a struggle for power and resources between different social classes.
+- **Symbolic Interactionism**: Society is created through the everyday symbolic interactions between individuals.
+
+### 2. Key Concepts
+- **Socialization**: The process by which individuals learn the norms and values of their culture.
+- **Social Stratification**: The hierarchical arrangement of society based on power, wealth, or status.
+- **Group Dynamics**: How the presence of others influences individual behavior (conformity, obedience, groupthink).
+
+---
+
+## 📈 Synthesis: The Individual vs. The Collective
+| Level | Focus | Primary Unit | Driving Force |
+| :--- | :--- | :--- | :--- |
+| **Psychology** | Internal / Subjective | The Mind | Biological / Cognitive |
+| **Sociology** | External / Objective | The Group | Structural / Cultural |
diff --git a/neural-brain/humanities/culture/mysticism.md b/neural-brain/humanities/culture/mysticism.md
new file mode 100644
index 0000000000000000000000000000000000000000..70d9313bd6fa0ef896bf4464089e7a345fac2605
--- /dev/null
+++ b/neural-brain/humanities/culture/mysticism.md
@@ -0,0 +1,26 @@
+# 🔮 Complex Belief Systems & Mystical Traditions
+
+This asset explores the esoteric, mystical, and pluralistic dimensions of human spirituality, moving beyond institutional religion to the core of transformed consciousness.
+
+## 🌌 The Mystical Pluralist Framework
+Rather than a single "universal truth," human spirituality is viewed as a series of overlapping paths to transformed consciousness.
+
+### 1. The Abrahamic Esotericism (Judaism, Christianity, Islam)
+- **Core Theme**: The interplay between the revealed law (Exoteric) and the hidden truth (Esoteric).
+- **Traditions**:
+ - **Kabbalah (Judaism)**: The Tree of Life and the emanations of the Ein Sof.
+ - **Christian Mysticism**: The "Interior Castle" (St. Teresa of Avila) and the pursuit of unitive prayer.
+ - **Sufism (Islam)**: The path of the heart, the annihilation of the self (Fana), and the love of the Divine.
+
+### 2. Eastern Mystical Paths (Hinduism, Buddhism, Taoism)
+- **Core Theme**: The realization of non-duality and the transcendence of the ego.
+- **Traditions**:
+ - **Advaita Vedanta**: The identity of Atman (individual soul) and Brahman (universal reality).
+ - **Zen Buddhism**: Direct insight (Satori) through meditation and the breaking of conceptual thought.
+ - **Taoism**: Alignment with the "Way" (Tao), emphasizing effortless action (Wu Wei).
+
+### 3. Universal Commonalities (The Perennial Core)
+Across all traditions, a few recurring themes emerge:
+- **The Ego-Death**: The necessity of dismantling the separate self to experience a larger reality.
+- **The Macrocosm-Microcosm Correspondence**: "As above, so below"—the belief that the individual reflects the universe.
+- **Transformative States**: The use of meditation, ritual, or contemplation to reach non-ordinary states of consciousness.
\ No newline at end of file
diff --git a/neural-brain/humanities/culture/sociology_milestones.md b/neural-brain/humanities/culture/sociology_milestones.md
new file mode 100644
index 0000000000000000000000000000000000000000..cb0f43c41bae6e4052891d786826cc69390cd510
--- /dev/null
+++ b/neural-brain/humanities/culture/sociology_milestones.md
@@ -0,0 +1,36 @@
+# 🌐 Sociology & The Development of Human Society
+
+This asset examines the milestones in how humans organized themselves into complex social structures.
+
+## 🏛️ Societal Milestones
+
+### 1. The Agricultural Revolution (c. 10,000 BCE)
+The shift from hunter-gatherer bands to settled farming communities. This enabled:
+- **Population Growth**: Food surpluses allowed for larger groups.
+- **Specialization**: Not everyone had to hunt/farm; this led to the rise of priests, warriors, and artisans.
+- **Social Stratification**: The emergence of hierarchy and class structures.
+
+### 2. The Urban Revolution (c. 3,500 BCE)
+The birth of the first cities in Mesopotamia and the Indus Valley.
+- **Centralized Governance**: The need for irrigation management led to the first kings and bureaucracies.
+- **Writing**: Developed primarily for accounting and record-keeping of surplus grain.
+
+### 3. The Axial Age (c. 800 – 200 BCE)
+A pivotal period of simultaneous intellectual awakening across the world:
+- **Greece**: Socrates, Plato, Aristotle.
+- **India**: The Buddha, Mahavira.
+- **China**: Confucius, Laozi.
+- **Persia**: Zoroaster.
+*Impact*: The shift from ritual-based religion to ethical-based philosophy.
+
+### 4. The Industrial Revolution (1760 – 1840 CE)
+The transition from hand production to machine manufacturing.
+- **Urbanization**: Massive migration from rural areas to cities.
+- **Nuclear Family**: Shift from extended kinship networks to smaller, mobile family units.
+- **Capitalism**: The rise of industrial capital and a new middle class (bourgeoisie).
+
+### 5. The Information Age (1950 – Present)
+The shift from industrial production to information management.
+- **Global Connectivity**: The internet collapses geographic distance.
+- **Decentralization**: The rise of remote work and digital identities.
+- **Cognitive Offloading**: The transition of memory and calculation to external digital systems (AI).
diff --git a/neural-brain/humanities/culture/world_religions.md b/neural-brain/humanities/culture/world_religions.md
new file mode 100644
index 0000000000000000000000000000000000000000..4d206f42e5c96c1e955fbaae578f9a1e91f7f519
--- /dev/null
+++ b/neural-brain/humanities/culture/world_religions.md
@@ -0,0 +1,33 @@
+# 🕉️ World Religions & Belief Systems
+
+This asset provides a comparative framework of the major belief systems that have shaped human morality, law, and social structure.
+
+## 🔱 The Abrahamic Traditions (Monotheism)
+*Rooted in the patriarch Abraham; belief in one God and revealed scripture.*
+
+- **Judaism**: The first major monotheistic faith; emphasizes the Covenant between God and the people, the Torah, and ethical monotheism.
+- **Christianity**: Emerged from Judaism; centers on the life and teachings of Jesus Christ, the New Testament, and the concept of grace and salvation.
+- **Islam**: Founded by the Prophet Muhammad; emphasizes the absolute oneness of God (Allah), the Quran, and the Five Pillars of Islam.
+
+## ☸️ The Indic Traditions (Dharma)
+*Rooted in India; focus on cosmic order, rebirth, and liberation.*
+
+- **Hinduism**: The most diverse major religion; emphasizes Karma (action), Dharma (duty), and Moksha (liberation from the cycle of rebirth).
+- **Buddhism**: Founded by Siddhartha Gautama; focuses on the Four Noble Truths and the Eightfold Path to reach Nirvana (the end of suffering).
+
+## ☯️ East Asian & Other Traditions
+- **Taoism/Daoism**: Focus on living in harmony with the "Tao" (the Way), emphasizing spontaneity and balance (Yin/Yang).
+- **Confucianism**: A social and ethical philosophy focusing on filial piety, social harmony, and the "Golden Rule."
+- **Shinto**: The indigenous spirituality of Japan, focusing on the *kami* (spirits) in nature.
+
+---
+
+## 📊 Comparative Summary
+| Faith | Core Goal | Primary Text | Nature of Divine |
+| :--- | :--- | :--- | :--- |
+| **Judaism** | Covenant / Law | Torah | Singular / Personal |
+| **Christianity** | Salvation / Grace | Bible | Trinitarian / Personal |
+| **Islam** | Submission / Order | Quran | Absolute / Transcendent |
+| **Hinduism** | Liberation / Unity | Vedas / Upanishads | Multiple Manifestations |
+| **Buddhism** | Enlightenment | Tripitaka / Sutras | Non-theistic / State of Mind |
+| **Taoism** | Harmony / Flow | Tao Te Ching | Cosmic Principle |
diff --git a/neural-brain/humanities/philosophy/platonic_philosophy.md b/neural-brain/humanities/philosophy/platonic_philosophy.md
new file mode 100644
index 0000000000000000000000000000000000000000..dff7d6e463db7096b7a36c36f1e649b27788dffb
--- /dev/null
+++ b/neural-brain/humanities/philosophy/platonic_philosophy.md
@@ -0,0 +1,20 @@
+# 🏛️ Neural-Brain: Platonic Philosophy & Theory of Forms
+
+Platonism provides the metaphysical foundation for the concept of "Ideals" and "Representations," which are increasingly relevant in modern AI latent space analysis.
+
+## 🖼️ The Theory of Forms
+Plato posited that the physical world we perceive is merely a shadow of a higher, unchanging reality: the **World of Forms** (or Ideas).
+- **Universals**: Every object in our world (e.g., a chair) is an imperfect copy of the "Ideal Form" of a chair.
+- **The Cave Allegory**: Humans are like prisoners in a cave, seeing only shadows of objects on the wall. Philosophy (and perhaps AI) is the process of turning around to see the actual light.
+
+## 🧠 Connection to Artificial Intelligence
+- **Latent Space as "Form Space"**: Modern LLMs map concepts into a high-dimensional vector space. A specific vector for "Justice" or "Cat" can be seen as a mathematical approximation of the Platonic Form.
+- **Platonic Representations**: Recent research suggests that different AI models (and even human brains) may be converging on a shared representation of reality—a "Platonic" model of the world.
+
+## 📜 Key Dialogues for Training
+- **The Republic**: Justice, the Ideal State, and the Allegory of the Cave.
+- **Timaeus**: Cosmology and the "Demiurge" (The Artisan/Creator).
+- **Phaedo**: The immortality of the soul and the nature of knowledge as "recollection" (Anamnesis).
+
+## 🧭 Application in NeuralAI
+NeuralAI utilizes the **Neural-Brain** to identify these "Universal Forms" across diverse datasets, ensuring that the AI's reasoning is grounded in high-level concepts rather than just surface-level patterns.
diff --git a/neural-brain/nature/bio_foundations.md b/neural-brain/nature/bio_foundations.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e276b80d6d8a8e7cf248c48f5d0a1773d447040
--- /dev/null
+++ b/neural-brain/nature/bio_foundations.md
@@ -0,0 +1,43 @@
+# 🌿 Biological Foundations: Botany & Zoology
+
+This asset provides the structural framework for understanding the diversity of life on Earth, focusing on the principles of Taxonomy and Systematics.
+
+## 🧬 The Science of Classification
+The goal of biological classification is to organize the diversity of nature into a structured hierarchy that reflects evolutionary relationships (common ancestry).
+
+### 1. The Linnaean Hierarchy (The Classic Model)
+Established by Carl Linnaeus in the 18th century, this system uses nested levels of increasing specificity:
+- **Domain**: (e.g., Eukarya) - The broadest category.
+- **Kingdom**: (e.g., Plantae, Animalia)
+- **Phylum**: Groups based on general body plan (e.g., Chordata).
+- **Class**: (e.g., Mammalia)
+- **Order**: (e.g., Primates)
+- **Family**: (e.g., Hominidae)
+- **Genus**: (e.g., *Homo*)
+- **Species**: (e.g., *Homo sapiens*) - The most specific unit.
+
+### 2. Modern Phylogenetics (The Evolutionary Model)
+Contemporary science replaces arbitrary similarity with **common descent**.
+- **Monophyly**: A group consisting of an ancestor and ALL its descendants. This is the "gold standard" for a natural group.
+- **Cladistics**: The method of building an evolutionary tree based solely on branching patterns (nodes).
+- **Convergence**: When two species develop similar traits independently (e.g., wings in bats and birds). This "fools" simple classification and requires genetic data to correct.
+
+---
+
+## 🍃 Botany (The Study of Plants)
+- **Core Principle**: Plants are primary producers (autotrophs) that convert light into chemical energy.
+- **Classification Focus**: Vascular vs. Non-vascular, Seed-bearing vs. Spore-bearing, Monocots vs. Dicots.
+
+## 🐾 Zoology (The Study of Animals)
+- **Core Principle**: Animals are consumers (heterotrophs) with complex nervous systems and motility.
+- **Classification Focus**: Vertebrates vs. Invertebrates, Symmetry (Radial vs. Bilateral), Body Cavity (Coelomates).
+
+---
+
+## 📈 Summary Table: Taxonomy Evolution
+| Era | Primary Basis | Goal | Key Figure |
+| :--- | :--- | :--- | :--- |
+| **Pre-Scientific** | Practical Use | Edibility / Danger | Folk Knowledge |
+| **Linnaean** | Physical Traits | Standardized Naming | Carl Linnaeus |
+| **Darwinian** | Common Descent | Evolutionary Lineage | Charles Darwin |
+| **Modern** | Genetics/DNA | Molecular Phylogeny | Genomic Research |
diff --git a/neural-brain/nature/extremophiles.md b/neural-brain/nature/extremophiles.md
new file mode 100644
index 0000000000000000000000000000000000000000..977826513d5830f185357ae58cee347dfaa2ca05
--- /dev/null
+++ b/neural-brain/nature/extremophiles.md
@@ -0,0 +1,20 @@
+# 🌊 Extremophiles & Deep-Sea Giants
+
+This asset explores the limits of biological survival in the most hostile environments on Earth.
+
+## 🌋 Extremophiles: The Life of the Edge
+Organisms that thrive in conditions that would be lethal to most life.
+
+### 1. Classification by Stressor
+- **Thermophiles**: Thrive in extreme heat (e.g., hydrothermal vents). Some function above 100°C.
+- **Halophiles**: Thrive in hypersaline environments (e.g., The Dead Sea).
+- **Acidophiles/Alkaliphiles**: Thrive in extreme pH levels.
+- **Psychrophiles**: Thrive in extreme cold (e.g., Antarctic ice).
+
+## 🦑 Deep-Sea Gigantism
+The phenomenon where deep-sea species grow significantly larger than their shallow-water relatives.
+
+### 1. The Drivers of Size
+- **Bergmann's Rule**: In colder environments, larger body sizes are more efficient for heat retention.
+- **Metabolic Efficiency**: Lower temperatures slow down metabolism, allowing for longer lifespans and slower, steady growth.
+- **Pressure Adaptation**: Unique cellular structures and proteins prevent collapse under the crushing weight of the abyssal zone.
diff --git a/neural-brain/nature/human_evolution.md b/neural-brain/nature/human_evolution.md
new file mode 100644
index 0000000000000000000000000000000000000000..28143177ea2ce694a6629292dfbfe3412f286ea5
--- /dev/null
+++ b/neural-brain/nature/human_evolution.md
@@ -0,0 +1,25 @@
+# 🧬 Neural-Brain: Human Evolution & Migration
+
+The history of *Homo sapiens* is a narrative of resilience, migration, and the unique development of "Symbolic Culture."
+
+## ⏳ Evolutionary Timeline
+
+### 1. Early Origins (7M - 2M years ago)
+- **Sahelanthropus & Australopithecus**: The transition to bipedalism in Africa.
+- **Homo habilis**: The first tool-makers.
+
+### 2. The Age of Homo erectus (1.7M - 130k years ago)
+- The first species to leave Africa, adapting to diverse environments in Europe and Asia.
+- Development of controlled fire and more advanced Acheulean tools.
+
+### 3. The Arrival of Homo sapiens (300k years ago - Present)
+- Emergence in Africa (~315,000 years ago).
+- **The Great Migration**: Approximately 100,000 years ago, *H. sapiens* began a global journey, interbreeding with Neanderthals and Denisovans before eventually becoming the sole surviving hominin.
+
+## 🌍 Migration Drivers
+- **Climate Shifts**: Changing landscapes and resource availability.
+- **Technological Innovation**: Tools and culture allowed for survival in extreme environments (e.g., the Arctic).
+- **Symbolic Thought**: The ability to share complex ideas and plan for the future.
+
+## 🧠 Evolutionary Psychology in AI
+Understanding the "Ancestral Brain" is critical for NeuralAI to model human behavior, bias, and social dynamics. We integrate these evolutionary milestones to ground the AI's understanding of human nature.
diff --git a/neural-brain/politics/modern_geopolitics.md b/neural-brain/politics/modern_geopolitics.md
new file mode 100644
index 0000000000000000000000000000000000000000..4faeddb15d4856a2d442d18942b10f05401ab2cc
--- /dev/null
+++ b/neural-brain/politics/modern_geopolitics.md
@@ -0,0 +1,26 @@
+# 🌏 Neural-Brain: Modern Geopolitics (2026 Analysis)
+
+The geopolitical landscape of 2026 is characterized by "Hyper-Fragmentation" and the emergence of "Intelligence Sovereignty."
+
+## ⚔️ Major Conflict Zones
+
+### 1. The Levant & Middle East
+Persistent instability following the conflicts of 2024-2025. The focus has shifted to the "Hormuz Ownership" struggle, with regional powers asserting control over critical energy chokepoints.
+
+### 2. Eastern Europe
+The "Post-Kinetic" phase of the Russia-Ukraine conflict. The focus is now on long-term reconstruction, demographic shifts, and the integration of AI-driven border defense systems.
+
+### 3. The Indo-Pacific
+Intensified pressure on the "Silicon Shield" (Taiwan). The semiconductor supply chain remains the primary flashpoint between global superpowers.
+
+## 🔋 Emerging Strategic Trends
+
+- **Intelligence Sovereignty**: Nations are increasingly prioritizing "Sovereign AI"—building domestic compute clusters and models (NeuralAI equivalents) to ensure national security and cultural alignment.
+- **Weaponization of Hunger**: Food security has become a primary lever of geopolitical influence, particularly in Sub-Saharan Africa.
+- **Climate Shocks**: Displacement and economic loss driven by worsening climate events are redrawing migration maps.
+
+## 🤖 The Role of AI in Geopolitics
+- **Conflict Forecasting**: Using real-time data to predict escalations (The ACLED 2026 Watchlist model).
+- **Automated Diplomacy**: The use of specialized agents to negotiate trade and resource agreements.
+
+*Updated: 2026-05-28*
diff --git a/neural-brain/science/quantum_field_theory.md b/neural-brain/science/quantum_field_theory.md
new file mode 100644
index 0000000000000000000000000000000000000000..872a51daef47e666e015e93c91b8599713f64a8e
--- /dev/null
+++ b/neural-brain/science/quantum_field_theory.md
@@ -0,0 +1,24 @@
+# 🌌 Neural-Brain: Quantum Field Theory (Expert Level)
+
+Quantum Field Theory (QFT) is the mathematical and conceptual framework that combines quantum mechanics, special relativity, and classical field theory. It is the language of the Standard Model of particle physics.
+
+## ⚛️ Core Principles
+
+### 1. Fields as Fundamental
+In QFT, the primary objects are not particles but **fields** that permeate space and time. Particles (like electrons or photons) are interpreted as **quanta**—excited states or "ripples" of these underlying fields.
+
+### 2. Second Quantization
+QFT extends the first quantization of quantum mechanics (where position and momentum are operators) by treating the field itself as an operator. This allows for the creation and annihilation of particles, a necessity for relativistic systems.
+
+### 3. Gauge Symmetry
+The interactions between matter fields are mediated by **gauge fields**. For example, Quantum Electrodynamics (QED) is based on $U(1)$ gauge symmetry, while the Strong Force (QCD) is based on $SU(3)$.
+
+## 🛠️ Advanced Concepts for AI Integration
+
+- **Path Integral Formulation**: Feynman's approach to QFT, which considers all possible histories of a system. This is analogous to the "Global Intelligence" model where multiple histories/data points are synthesized.
+- **Renormalization**: A collection of techniques used to treat infinities arising in calculated quantities. In NeuralAI, this maps to the "Denoising" and "Precision" layers of the model.
+- **Information Field Theory (IFT)**: The use of QFT methods for signal processing and data analysis. This is a primary research area for the Neural-Brain.
+
+## 🗺️ Future Vectors
+- Integration of QFT-based optimization algorithms.
+- Modeling NeuralAI "attention fields" using QFT dynamics.
diff --git a/neural-brain/science/quantum_physics.md b/neural-brain/science/quantum_physics.md
new file mode 100644
index 0000000000000000000000000000000000000000..a982e99603bac24d4f0b3ea91e9125d221abf438
--- /dev/null
+++ b/neural-brain/science/quantum_physics.md
@@ -0,0 +1,9 @@
+# ⚛️ Quantum Physics: The Fabric of Reality
+
+This asset explores the non-intuitive laws governing the subatomic world.
+
+## 🌀 Core Foundations
+1. **Wave-Particle Duality**: Entities (like electrons) behave as both particles and waves depending on observation.
+2. **Superposition**: A system exists in all possible states simultaneously until a measurement is made (Schrödinger's Cat).
+3. **Entanglement**: Particles become linked such that the state of one instantaneously influences the other, regardless of distance (Einstein's "spooky action at a distance").
+4. **Quantum Field Theory (QFT)**: The unification of quantum mechanics and relativity, treating particles as excitations in underlying fields.
diff --git a/neuralai_banner.svg b/neuralai_banner.svg
new file mode 100644
index 0000000000000000000000000000000000000000..6d83370561d127b48a4e501b5901be3ef3640845
--- /dev/null
+++ b/neuralai_banner.svg
@@ -0,0 +1,111 @@
+
\ No newline at end of file
diff --git a/scripts/orchestrator_proto.py b/scripts/orchestrator_proto.py
new file mode 100644
index 0000000000000000000000000000000000000000..02a34afa14e5be2507f6884f228d85eb420e3add
--- /dev/null
+++ b/scripts/orchestrator_proto.py
@@ -0,0 +1,86 @@
+import asyncio
+import aiohttp
+import os
+import json
+
+# Configuration
+MODEL_NAME = "byok:97f38ab9-cce0-48fb-bfb0-f956ec13f723"
+API_URL = "https://api.zo.computer/zo/ask"
+TOKEN = os.environ.get("ZO_CLIENT_IDENTITY_TOKEN")
+
+async def spawn_worker(session, task_id, prompt):
+ """
+ Spawns a child Zo agent (Worker) to handle a specific sub-task.
+ """
+ print(f"[Manager] Dispatching Worker {task_id}: {prompt[:50]}...")
+
+ payload = {
+ "input": f"TASK_ID: {task_id}\n\n{prompt}",
+ "model_name": MODEL_NAME,
+ }
+
+ headers = {
+ "authorization": TOKEN,
+ "content-type": "application/json",
+ "Accept": "application/json",
+ }
+
+ try:
+ async with session.post(API_URL, headers=headers, json=payload) as resp:
+ if resp.status == 200:
+ data = await resp.json()
+ print(f"[Worker {task_id}] Completed successfully.")
+ return {"id": task_id, "output": data.get("output"), "status": "success"}
+ else:
+ print(f"[Worker {task_id}] Failed with status {resp.status}")
+ return {"id": task_id, "output": None, "status": "error"}
+ except Exception as e:
+ print(f"[Worker {task_id}] Exception: {str(e)}")
+ return {"id": task_id, "output": None, "status": "exception"}
+
+async def manager_orchestrate(main_goal):
+ """
+ The Manager implementation of the Orchestrator logic.
+ """
+ print(f"🚀 Starting Orchestration for Goal: {main_goal}\n")
+
+ # 1. Goal Decomposition (In a real scenario, another LLM call would generate this list)
+ # For the prototype, we manually decompose a sample goal: "Research the transition from
+ # Ancient Civilizations to Classical Antiquity and identify key technological shifts."
+ tasks = [
+ {"id": "worker_1", "prompt": "Research the key characteristics of the Greek Archaic period and the rise of the City-State (Polis)."},
+ {"id": "worker_2", "prompt": "Analyze the technological shifts in metallurgy and warfare during the transition to Classical Antiquity."},
+ {"id": "worker_3", "prompt": "Summarize the influence of Phoenician trade on the spread of the alphabet and early Mediterranean diplomacy."}
+ ]
+
+ async with aiohttp.ClientSession() as session:
+ # 2. Parallel Worker Dispatch
+ print(f"[Manager] Spawning {len(tasks)} Workers in parallel...")
+ worker_futures = [spawn_worker(session, t["id"], t["prompt"]) for t in tasks]
+ results = await asyncio.gather(*worker_futures)
+
+ # 3. Synthesis
+ print("\n[Manager] All Workers returned. Synthesizing results...")
+ final_report = "## 🏛️ Orchestrated Synthesis: Transition to Classical Antiquity\n\n"
+
+ for res in results:
+ if res["status"] == "success":
+ final_report += f"### Result from {res['id']}\n{res['output']}\n\n"
+ else:
+ final_report += f"### Result from {res['id']}\n[Worker failed to provide data]\n\n"
+
+ return final_report
+
+if __name__ == "__main__":
+ if not TOKEN:
+ print("Error: ZO_CLIENT_IDENTITY_TOKEN not found in environment.")
+ else:
+ goal = "Research the transition from Ancient Civilizations to Classical Antiquity."
+ final_output = asyncio.run(manager_orchestrate(goal))
+
+ # Save the synthesized result to the workspace
+ output_path = "/home/workspace/Projects/NeuralAI/orchestrator_prototype_result.md"
+ with open(output_path, "w") as f:
+ f.write(final_output)
+
+ print(f"\n✅ Orchestration complete. Synthesis saved to: {output_path}")
diff --git a/scripts/pull_from_huggingface.py b/scripts/pull_from_huggingface.py
new file mode 100644
index 0000000000000000000000000000000000000000..a303ad9ddef584ff1ab43579f758e97b4a1572e8
--- /dev/null
+++ b/scripts/pull_from_huggingface.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+NeuralAI ← Hugging Face Pull Script
+Downloads model checkpoints, training data, and configs from the Hub.
+"""
+
+import os
+import sys
+from huggingface_hub import HfApi, snapshot_download
+
+REPO_ID = "Subject-Emu-5259/NeuralAI"
+LOCAL_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+def main():
+ api = HfApi()
+
+ user = api.whoami(token=True)
+ print(f"🔗 Connected as: {user['name']}")
+ print(f"📦 Repo: {REPO_ID}")
+
+ action = sys.argv[1] if len(sys.argv) > 1 else "all"
+
+ if action == "model" or action == "all":
+ print("\n📥 Pulling model adapter...")
+ model_files = [
+ "adapter_config.json",
+ "adapter_model.safetensors",
+ "chat_template.jinja",
+ "tokenizer.json",
+ "tokenizer_config.json",
+ "training_log.json",
+ ]
+ for f in model_files:
+ try:
+ api.hf_hub_download(
+ repo_id=REPO_ID,
+ filename=f,
+ local_dir=os.path.join(LOCAL_DIR, "checkpoints", "v2_model"),
+ local_dir_use_symlinks=False,
+ token=True
+ )
+ print(f" ✅ {f}")
+ except Exception as e:
+ print(f" ⏭️ {f} (not found on Hub)")
+
+ if action == "data" or action == "all":
+ print("\n📥 Pulling training data...")
+ try:
+ files = api.list_repo_files(REPO_ID, repo_type="model", token=True)
+ data_files = [f for f in files if f.startswith("data/")]
+ for f in data_files:
+ local_path = os.path.join(LOCAL_DIR, f)
+ os.makedirs(os.path.dirname(local_path), exist_ok=True)
+ api.hf_hub_download(
+ repo_id=REPO_ID,
+ filename=f,
+ local_dir=LOCAL_DIR,
+ local_dir_use_symlinks=False,
+ token=True
+ )
+ print(f" ✅ {f}")
+ except Exception as e:
+ print(f" ❌ Error: {e}")
+
+ if action == "scripts" or action == "all":
+ print("\n📥 Pulling training scripts...")
+ try:
+ files = api.list_repo_files(REPO_ID, repo_type="model", token=True)
+ for prefix in ["training/", "services/", "tools/"]:
+ for f in [x for x in files if x.startswith(prefix)]:
+ local_path = os.path.join(LOCAL_DIR, f)
+ os.makedirs(os.path.dirname(local_path), exist_ok=True)
+ api.hf_hub_download(
+ repo_id=REPO_ID,
+ filename=f,
+ local_dir=LOCAL_DIR,
+ local_dir_use_symlinks=False,
+ token=True
+ )
+ print(f" ✅ {f}")
+ except Exception as e:
+ print(f" ❌ Error: {e}")
+
+ print(f"\n{'='*50}")
+ print(f"✅ Pull complete! Files synced to {LOCAL_DIR}")
+ print(f"{'='*50}")
+
+if __name__ == "__main__":
+ main()
diff --git a/scripts/sync_to_huggingface.py b/scripts/sync_to_huggingface.py
new file mode 100644
index 0000000000000000000000000000000000000000..42ffdee3ff346ebec3ce3d84ba1f4ee8c24a87ba
--- /dev/null
+++ b/scripts/sync_to_huggingface.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+NeuralAI → Hugging Face Sync Script
+Uploads all local training data, scripts, services, and configs to the Hub.
+"""
+
+import os
+import sys
+from huggingface_hub import HfApi
+
+REPO_ID = "Subject-Emu-5259/NeuralAI"
+
+def upload_folder(api, folder, target, description, extension=None):
+ print(f"\n📤 Uploading {description}...")
+ for f in sorted(os.listdir(folder)):
+ local_path = os.path.join(folder, f)
+ if os.path.isfile(local_path) and (extension is None or f.endswith(extension)):
+ print(f" {f}...", end=" ", flush=True)
+ try:
+ api.upload_file(
+ path_or_fileobj=local_path,
+ path_in_repo=f"{target}/{f}",
+ repo_id=REPO_ID,
+ repo_type="model",
+ create_pr=False,
+ token=True
+ )
+ print("✅")
+ except Exception as e:
+ print(f"❌ {e}")
+
+def upload_file(api, local_path, repo_path, description):
+ print(f" Uploading {description}...", end=" ", flush=True)
+ try:
+ api.upload_file(
+ path_or_fileobj=local_path,
+ path_in_repo=repo_path,
+ repo_id=REPO_ID,
+ repo_type="model",
+ create_pr=False,
+ token=True
+ )
+ print("✅")
+ except Exception as e:
+ print(f"❌ {e}")
+
+def main():
+ api = HfApi()
+
+ # Verify connection
+ user = api.whoami(token=True)
+ print(f"🔗 Connected as: {user['name']}")
+ print(f"📦 Repo: {REPO_ID}")
+
+ # Training data
+ upload_folder(api, "data", "data", "training data", extension=(".jsonl", ".json"))
+
+ # Training scripts
+ upload_folder(api, "training", "training", "training scripts", extension=".py")
+
+ # Services
+ upload_folder(api, "services", "services", "services", extension=(".py", ".sh"))
+
+ # Tools
+ upload_folder(api, "tools", "tools", "tools", extension=".py")
+
+ # Config & docs
+ root_files = ["AGENTS.md", "MODEL_ALIGNMENT.md", "ORCHESTRATOR.md", "GEMINI.md", "README.md"]
+ for f in root_files:
+ local = os.path.join(".", f)
+ if os.path.exists(local):
+ upload_file(api, local, f"configs/{f}", f)
+
+ # Training config
+ if os.path.exists("checkpoints/training_config.json"):
+ upload_file(api, "checkpoints/training_config.json", "checkpoints/training_config.json", "training config")
+
+ # Neural-Brain knowledge base
+ if os.path.exists("neural-brain"):
+ print("\n📤 Uploading neural-brain knowledge base...")
+ for root, dirs, files in os.walk("neural-brain"):
+ for f in files:
+ local = os.path.join(root, f)
+ repo_path = os.path.join("neural-brain", os.path.relpath(local, "neural-brain"))
+ try:
+ api.upload_file(
+ path_or_fileobj=local,
+ path_in_repo=repo_path,
+ repo_id=REPO_ID,
+ repo_type="model",
+ create_pr=False,
+ token=True
+ )
+ except Exception as e:
+ print(f" ❌ {repo_path}: {e}")
+ print(" ✅ neural-brain uploaded")
+
+ print(f"\n{'='*50}")
+ print(f"✅ Sync complete! View at:")
+ print(f" https://huggingface.co/{REPO_ID}")
+ print(f"{'='*50}")
+
+if __name__ == "__main__":
+ main()
diff --git a/services/diffusion_engine.py b/services/diffusion_engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1ad894bb0401b5b5554f95fd9fa94cab6088d22
--- /dev/null
+++ b/services/diffusion_engine.py
@@ -0,0 +1,130 @@
+import os
+import torch
+from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline
+from PIL import Image
+import time
+import requests
+from io import BytesIO
+
+class NeuralAIDiffusion:
+ def __init__(self, model_id="runwayml/stable-diffusion-v1-5", device=None):
+ self.model_id = model_id
+ if device:
+ self.device = device
+ else:
+ self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+ self.pipe = None
+ self.img2img_pipe = None
+ self.is_loaded = False
+ print(f"[NeuralAI Diffusion] Initialized on {self.device}")
+
+ def load_model(self, mode="text2img"):
+ if self.is_loaded and (self.pipe if mode == "text2img" else self.img2img_pipe):
+ return
+
+ print(f"[NeuralAI Diffusion] Loading {mode} model {self.model_id}...")
+ try:
+ # Using float32 for CPU to avoid errors, float16 for CUDA
+ dtype = torch.float16 if self.device == "cuda" else torch.float32
+
+ if mode == "text2img":
+ self.pipe = StableDiffusionPipeline.from_pretrained(
+ self.model_id,
+ torch_dtype=dtype,
+ safety_checker=None # Disable safety checker for faster loading if needed, or keep for safety
+ )
+ self.pipe.to(self.device)
+ # Optimization for CPU
+ if self.device == "cpu":
+ self.pipe.enable_attention_slicing()
+ else:
+ self.img2img_pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
+ self.model_id,
+ torch_dtype=dtype,
+ safety_checker=None
+ )
+ self.img2img_pipe.to(self.device)
+ if self.device == "cpu":
+ self.img2img_pipe.enable_attention_slicing()
+
+ self.is_loaded = True
+ print(f"[NeuralAI Diffusion] {mode} model loaded successfully.")
+ except Exception as e:
+ print(f"[NeuralAI Diffusion] Error loading model: {e}")
+ if self.model_id != "segmind/tiny-sd":
+ print("[NeuralAI Diffusion] Attempting fallback to tiny-sd...")
+ self.model_id = "segmind/tiny-sd"
+ self.load_model(mode)
+
+ def generate(self, prompt, output_path, negative_prompt=None, num_steps=20, guidance_scale=7.5):
+ self.load_model("text2img")
+
+ # Enhanced Prompting for "Better Images"
+ quality_boost = "masterpiece, high quality, 8k, highly detailed, professional photography"
+ if "moon" in prompt.lower():
+ quality_boost += ", sharp craters, lunar surface detail, space background, realistic"
+
+ full_prompt = f"{prompt}, {quality_boost}"
+
+ if negative_prompt is None:
+ negative_prompt = "blurry, low quality, distorted, watermark, text, grainy, low resolution"
+
+ print(f"[NeuralAI Diffusion] Generating: {full_prompt}")
+ start_time = time.time()
+ try:
+ image = self.pipe(
+ prompt=full_prompt,
+ negative_prompt=negative_prompt,
+ num_inference_steps=num_steps,
+ guidance_scale=guidance_scale
+ ).images[0]
+ image.save(output_path)
+ print(f"[NeuralAI Diffusion] Image saved to {output_path} (took {time.time() - start_time:.2f}s)")
+ return True
+ except Exception as e:
+ print(f"[NeuralAI Diffusion] Generation failed: {e}")
+ return False
+
+ def transform(self, prompt, image_path, output_path, strength=0.75, num_steps=20):
+ self.load_model("img2img")
+
+ quality_boost = "masterpiece, high quality, 8k, highly detailed"
+ full_prompt = f"{prompt}, {quality_boost}"
+
+ print(f"[NeuralAI Diffusion] Transforming image with prompt: {full_prompt}")
+ start_time = time.time()
+ try:
+ if image_path.startswith("http"):
+ response = requests.get(image_path)
+ init_image = Image.open(BytesIO(response.content)).convert("RGB")
+ else:
+ init_image = Image.open(image_path).convert("RGB")
+
+ init_image = init_image.resize((512, 512))
+
+ image = self.img2img_pipe(
+ prompt=full_prompt,
+ image=init_image,
+ strength=strength,
+ num_inference_steps=num_steps
+ ).images[0]
+
+ image.save(output_path)
+ print(f"[NeuralAI Diffusion] Transformed image saved to {output_path} (took {time.time() - start_time:.2f}s)")
+ return True
+ except Exception as e:
+ print(f"[NeuralAI Diffusion] Transformation failed: {e}")
+ return False
+
+if __name__ == "__main__":
+ import sys
+ mode = sys.argv[1] if len(sys.argv) > 1 else "gen"
+ prompt = sys.argv[2] if len(sys.argv) > 2 else "A high-tech AI logo"
+ output = sys.argv[3] if len(sys.argv) > 3 else "output.png"
+
+ engine = NeuralAIDiffusion()
+ if mode == "edit" and len(sys.argv) > 4:
+ engine.transform(prompt, sys.argv[4], output)
+ else:
+ engine.generate(prompt, output)
diff --git a/services/diffusion_toy_v2.py b/services/diffusion_toy_v2.py
new file mode 100644
index 0000000000000000000000000000000000000000..b47d7edd86e8c75453721b8b8f4e008a84df5842
--- /dev/null
+++ b/services/diffusion_toy_v2.py
@@ -0,0 +1,119 @@
+import torch
+from torch import nn
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms
+from diffusers import UNet2DModel, DDPMScheduler
+import torch.nn.functional as F
+import numpy as np
+from tqdm import tqdm
+import os
+from PIL import Image
+
+# Set device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# 1. Config
+image_size = 28
+train_batch_size = 128
+num_epochs = 1
+learning_rate = 1e-4
+
+# 2. Model: UNet2DModel from diffusers (small version for toy)
+model = UNet2DModel(
+ sample_size=image_size,
+ in_channels=1,
+ out_channels=1,
+ layers_per_block=2,
+ block_out_channels=(32, 64, 64),
+ down_block_types=(
+ "DownBlock2D",
+ "AttnDownBlock2D",
+ "DownBlock2D",
+ ),
+ up_block_types=(
+ "UpBlock2D",
+ "AttnUpBlock2D",
+ "UpBlock2D",
+ ),
+).to(device)
+
+# 3. Scheduler
+noise_scheduler = DDPMScheduler(num_train_timesteps=100)
+
+# 4. Data Loading (MNIST)
+preprocess = transforms.Compose([
+ transforms.Resize((image_size, image_size)),
+ transforms.ToTensor(),
+ transforms.Normalize([0.5], [0.5]),
+])
+
+dataset = datasets.MNIST(root='./data', train=True, download=True, transform=preprocess)
+train_dataloader = DataLoader(dataset, batch_size=train_batch_size, shuffle=True)
+
+# 5. Training
+optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
+
+print(f"Starting NeuralAI Diffusion Toy V2 Training on {device}...")
+
+for epoch in range(num_epochs):
+ losses = []
+ for step, (images, _) in enumerate(tqdm(train_dataloader)):
+ images = images.to(device)
+ noise = torch.randn(images.shape).to(device)
+ bs = images.shape[0]
+
+ # Sample a random timestep for each image
+ timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bs,), device=device).long()
+
+ # Add noise to the clean images according to the noise magnitude at each timestep
+ # (this is the forward diffusion process)
+ noisy_images = noise_scheduler.add_noise(images, noise, timesteps)
+
+ # Predict the noise residual
+ noise_pred = model(noisy_images, timesteps).sample
+
+ loss = F.mse_loss(noise_pred, noise)
+ loss.backward()
+
+ optimizer.step()
+ optimizer.zero_grad()
+
+ losses.append(loss.item())
+
+ print(f"Epoch {epoch} | Loss: {np.mean(losses):.6f}")
+
+# 6. Sampling Logic
+def generate_samples(model, scheduler, num_samples=1):
+ model.eval()
+ # Start from random noise
+ sample = torch.randn(num_samples, 1, image_size, image_size).to(device)
+
+ for t in tqdm(scheduler.timesteps):
+ with torch.no_grad():
+ residual = model(sample, t).sample
+
+ # Compute previous image: x_t -> x_t-1
+ sample = scheduler.step(residual, t, sample).prev_sample
+
+ return sample
+
+print("Generating NeuralAI Diffusion sample...")
+generated = generate_samples(model, noise_scheduler)
+
+# Save result
+output_dir = "/home/workspace/Projects/NeuralAI/storage/images"
+os.makedirs(output_dir, exist_ok=True)
+
+# Convert to PIL and save
+gen_img = (generated[0] / 2 + 0.5).clamp(0, 1).cpu().numpy().squeeze()
+gen_img = (gen_img * 255).astype(np.uint8)
+img = Image.fromarray(gen_img)
+img.save(os.path.join(output_dir, "toy_v2_sample.png"))
+
+# Save model checkpoint
+checkpoint_dir = "/home/workspace/Projects/NeuralAI/checkpoints/diffusion_toy"
+os.makedirs(checkpoint_dir, exist_ok=True)
+torch.save(model.state_dict(), os.path.join(checkpoint_dir, "unet_toy.pt"))
+
+print(f"Sample saved to {output_dir}/toy_v2_sample.png")
+print(f"Model saved to {checkpoint_dir}/unet_toy.pt")
diff --git a/services/fix_service.py b/services/fix_service.py
new file mode 100644
index 0000000000000000000000000000000000000000..24df3fc54c16cef2569f9b541b6b126b3a8186d1
--- /dev/null
+++ b/services/fix_service.py
@@ -0,0 +1,74 @@
+import sys
+
+with open('/home/workspace/Projects/NeuralAI/services/neural_core_service.py', 'r') as f:
+ content = f.read()
+
+# Replace generate_response_stream signature and logic
+old_stream = '''def generate_response_stream(prompt, max_tokens=256, temperature=0.7, system_prompt=None):
+ global model, tokenizer, inference_count
+ if model is None or tokenizer is None:
+ yield "Model not loaded."
+ return
+
+ if system_prompt is None:
+ system_prompt = DEFAULT_SYSTEM_PROMPT
+
+ try:
+ messages = []
+ if system_prompt:
+ messages.append({"role": "system", "content": system_prompt})
+
+ messages.append({"role": "user", "content": prompt})
+
+ if tokenizer.chat_template:
+ full = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+ else:
+ full = f"system\\n{system_prompt}\\nuser\\n{prompt}" if system_prompt else f"user\\n{prompt}"'''
+
+new_stream = '''def generate_response_stream(prompt, max_tokens=256, temperature=0.7, system_prompt=None, history=None):
+ global model, tokenizer, inference_count
+ if model is None or tokenizer is None:
+ yield "Model not loaded."
+ return
+
+ if system_prompt is None:
+ system_prompt = DEFAULT_SYSTEM_PROMPT
+
+ try:
+ messages = []
+ if system_prompt:
+ messages.append({"role": "system", "content": system_prompt})
+
+ if history:
+ messages.extend(history)
+ else:
+ messages.append({"role": "user", "content": prompt})
+
+ if tokenizer.chat_template:
+ full = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+ else:
+ full = ""
+ for msg in messages:
+ full += f"<|im_start|>{msg['role']}\\n{msg['content']}<|im_end|>\\n"
+ full += "<|im_start|>assistant\\n"'''
+
+if old_stream not in content:
+ print("Failed to find old stream logic!")
+ sys.exit(1)
+
+content = content.replace(old_stream, new_stream)
+
+# Replace the chat endpoint call
+old_call = 'for chunk in generate_response_stream(prompt, max_tokens, temperature, system_prompt=system_prompt):'
+new_call = 'for chunk in generate_response_stream(prompt, max_tokens, temperature, system_prompt=system_prompt, history=messages):'
+
+if old_call not in content:
+ print("Failed to find chat endpoint call!")
+ sys.exit(1)
+
+content = content.replace(old_call, new_call)
+
+with open('/home/workspace/Projects/NeuralAI/services/neural_core_service.py', 'w') as f:
+ f.write(content)
+
+print("Successfully patched.")
diff --git a/services/model_service.py b/services/model_service.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb30158d1c73795effc8fa70c68afc23e8a47ed2
--- /dev/null
+++ b/services/model_service.py
@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+NeuralAI Model Service
+- Loads model once on startup
+- Keeps in memory
+- Exposes inference API on port 7001
+- Handles both sync and streaming responses
+"""
+
+import os
+import sys
+import json
+import torch
+from pathlib import Path
+from flask import Flask, Response, jsonify, request
+from datetime import datetime
+
+# CPU optimization
+torch.set_num_threads(4)
+
+# Configuration
+PORT = int(os.environ.get("MODEL_PORT", "7001"))
+MODEL_PATH = os.environ.get("MODEL_PATH", "/home/workspace/Projects/NeuralAI/checkpoints/v2_model")
+BASE_MODEL = os.environ.get("BASE_MODEL", "HuggingFaceTB/SmolLM2-360M-Instruct")
+
+app = Flask(__name__)
+
+# Global model state
+model = None
+tokenizer = None
+model_status = "loading"
+model_error = None
+inference_count = 0
+
+
+def load_model():
+ """Load model once on startup."""
+ global model, tokenizer, model_status, model_error
+
+ print(f"[Model Service] Loading model from {MODEL_PATH}")
+ print(f"[Model Service] Base model: {BASE_MODEL}")
+
+ try:
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ from peft import PeftModel
+
+ # Load tokenizer
+ tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
+ tokenizer.pad_token = tokenizer.eos_token
+
+ # Check for adapter
+ adapter_path = Path(MODEL_PATH)
+ adapter_bin = adapter_path / "adapter_model.bin"
+ adapter_safetensors = adapter_path / "adapter_model.safetensors"
+
+ if adapter_path.exists() and (adapter_bin.exists() or adapter_safetensors.exists()):
+ print(f"[Model Service] Loading with LoRA adapter...")
+ base = AutoModelForCausalLM.from_pretrained(
+ BASE_MODEL,
+ torch_dtype=torch.float32,
+ device_map=None,
+ low_cpu_mem_usage=True
+ )
+ model = PeftModel.from_pretrained(base, str(adapter_path))
+ print(f"[Model Service] LoRA adapter loaded!")
+ else:
+ print(f"[Model Service] Loading base model only...")
+ model = AutoModelForCausalLM.from_pretrained(
+ BASE_MODEL,
+ torch_dtype=torch.float32,
+ device_map=None,
+ low_cpu_mem_usage=True
+ )
+
+ model.eval()
+ model_status = "ready"
+ model_error = None
+
+ params = sum(p.numel() for p in model.parameters())
+ print(f"[Model Service] ✓ Model ready! Parameters: {params:,}")
+ print(f"[Model Service] Listening on port {PORT}")
+
+ except Exception as e:
+ import traceback
+ model_status = "error"
+ model_error = str(e)
+ print(f"[Model Service] ✗ Failed to load model: {e}")
+ traceback.print_exc()
+
+
+@app.route("/health", methods=["GET"])
+def health():
+ """Health check endpoint."""
+ return jsonify({
+ "status": model_status,
+ "error": model_error,
+ "inference_count": inference_count,
+ "model": BASE_MODEL,
+ "port": PORT
+ })
+
+
+@app.route("/status", methods=["GET"])
+def status():
+ """Detailed status endpoint."""
+ return jsonify({
+ "status": model_status,
+ "error": model_error,
+ "inference_count": inference_count,
+ "model_loaded": model is not None,
+ "tokenizer_loaded": tokenizer is not None,
+ "model_path": MODEL_PATH,
+ "base_model": BASE_MODEL,
+ "device": "cpu",
+ "threads": 4
+ })
+
+
+@app.route("/generate", methods=["POST"])
+def generate():
+ """Generate text response (non-streaming)."""
+ global inference_count
+
+ if model is None or tokenizer is None:
+ return jsonify({"error": "Model not loaded", "status": model_status}), 503
+
+ try:
+ data = request.get_json()
+ prompt = data.get("prompt", "")
+ max_tokens = data.get("max_tokens", 256)
+ temperature = data.get("temperature", 0.7)
+
+ if not prompt:
+ return jsonify({"error": "No prompt provided"}), 400
+
+ # Build full prompt with chat template
+ if not prompt.startswith("<|im_start|>"):
+ full_prompt = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+ else:
+ full_prompt = prompt
+
+ # Tokenize
+ inputs = tokenizer(full_prompt, return_tensors="pt")
+
+ # Generate
+ with torch.no_grad():
+ outputs = model.generate(
+ **inputs,
+ max_new_tokens=max_tokens,
+ do_sample=True,
+ temperature=temperature,
+ top_p=0.95,
+ pad_token_id=tokenizer.eos_token_id
+ )
+
+ # Decode only new tokens
+ new_tokens = outputs[0][inputs["input_ids"].shape[-1]:]
+ response = tokenizer.decode(new_tokens, skip_special_tokens=True)
+
+ inference_count += 1
+
+ return jsonify({
+ "response": response,
+ "tokens_generated": len(new_tokens),
+ "inference_count": inference_count
+ })
+
+ except Exception as e:
+ return jsonify({"error": str(e)}), 500
+
+
+@app.route("/generate/stream", methods=["POST"])
+def generate_stream():
+ """Generate text response with streaming."""
+ global inference_count
+
+ if model is None or tokenizer is None:
+ return jsonify({"error": "Model not loaded"}), 503
+
+ try:
+ from transformers import TextIteratorStreamer
+ import threading
+
+ data = request.get_json()
+ prompt = data.get("prompt", "")
+ max_tokens = data.get("max_tokens", 256)
+ temperature = data.get("temperature", 0.7)
+
+ if not prompt:
+ return jsonify({"error": "No prompt provided"}), 400
+
+ # Build full prompt
+ if not prompt.startswith("<|im_start|>"):
+ full_prompt = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+ else:
+ full_prompt = prompt
+
+ inputs = tokenizer(full_prompt, return_tensors="pt")
+
+ # Create streamer
+ streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+
+ # Run generation in thread
+ thread = threading.Thread(target=model.generate, kwargs=dict(
+ **inputs,
+ streamer=streamer,
+ max_new_tokens=max_tokens,
+ do_sample=True,
+ temperature=temperature,
+ top_p=0.95,
+ pad_token_id=tokenizer.eos_token_id
+ ))
+ thread.start()
+
+ def generate():
+ for token in streamer:
+ yield f"data: {json.dumps({'token': token})}\n\n"
+ yield "data: [DONE]\n\n"
+
+ inference_count += 1
+
+ return Response(
+ generate(),
+ mimetype="text/event-stream",
+ headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"}
+ )
+
+ except Exception as e:
+ return jsonify({"error": str(e)}), 500
+
+
+# Load model on startup
+print(f"[Model Service] Starting...")
+print(f"[Model Service] Port: {PORT}")
+load_model()
+
+
+if __name__ == "__main__":
+ app.run(host="0.0.0.0", port=PORT, debug=False, threaded=True)
diff --git a/services/neural_cloud_client.py b/services/neural_cloud_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd3366c01cfa50ab0f602ff054a7b92cc33c2801
--- /dev/null
+++ b/services/neural_cloud_client.py
@@ -0,0 +1,68 @@
+import requests
+from requests.auth import HTTPBasicAuth
+import os
+
+class NeuralCloudClient:
+ def __init__(self, base_url="http://localhost:8002/remote.php/dav/files/admin", user="admin", password="NeuralAI_Admin_2026!"):
+ self.base_url = base_url.rstrip('/')
+ self.auth = HTTPBasicAuth(user, password)
+
+ def _get_url(self, path):
+ return f"{self.base_url}/{path.lstrip('/')}"
+
+ def list_files(self, path=""):
+ url = self._get_url(path)
+ headers = {'Depth': '1'}
+ response = requests.request('PROPFIND', url, auth=self.auth, headers=headers)
+ if response.status_code == 207:
+ # Simple XML parsing would be better, but let's keep it minimal for now
+ return response.text
+ response.raise_for_status()
+
+ def upload_file(self, local_path, remote_path):
+ url = self._get_url(remote_path)
+ with open(local_path, 'rb') as f:
+ response = requests.put(url, auth=self.auth, data=f)
+ response.raise_for_status()
+ return response.status_code
+
+ def download_file(self, remote_path, local_path):
+ url = self._get_url(remote_path)
+ response = requests.get(url, auth=self.auth, stream=True)
+ response.raise_for_status()
+ with open(local_path, 'wb') as f:
+ for chunk in response.iter_content(chunk_size=8192):
+ f.write(chunk)
+ return local_path
+
+ def delete_file(self, remote_path):
+ url = self._get_url(remote_path)
+ response = requests.delete(url, auth=self.auth)
+ response.raise_for_status()
+ return response.status_code
+
+ def mkdir(self, remote_path):
+ url = self._get_url(remote_path)
+ response = requests.request('MKCOL', url, auth=self.auth)
+ if response.status_code == 405: # Already exists
+ return 201
+ response.raise_for_status()
+ return response.status_code
+
+if __name__ == "__main__":
+ client = NeuralCloudClient()
+ print("Testing NeuralCloudClient...")
+ try:
+ # Create a test directory
+ client.mkdir("NeuralAI_Vault")
+ # Upload a test file
+ test_file = "/tmp/cloud_test.txt"
+ with open(test_file, "w") as f:
+ f.write("NeuralAI Cloud Storage Test")
+ client.upload_file(test_file, "NeuralAI_Vault/test.txt")
+ print("Upload successful!")
+ # List files
+ print("Remote files:")
+ print(client.list_files("NeuralAI_Vault"))
+ except Exception as e:
+ print(f"Error: {e}")
diff --git a/services/neural_core_service.py b/services/neural_core_service.py
new file mode 100644
index 0000000000000000000000000000000000000000..358046902251f0186b60cbc0e1045cf47d652644
--- /dev/null
+++ b/services/neural_core_service.py
@@ -0,0 +1,844 @@
+#!/usr/bin/env python3
+"""
+NeuralAI Unified Service - ALL IN ONE
+===================================
+- Model inference (SmolLM2-360M)
+- Neural Uplink (Integrated)
+- Tools (code, terminal, images)
+- Web UI & API
+"""
+import os, sys, json, asyncio, requests, threading, logging
+import torch, sqlite3, subprocess, tempfile, uuid, jwt
+from pathlib import Path
+try:
+ from diffusion_engine import NeuralAIDiffusion
+except ImportError:
+ sys.path.append(os.path.join("/home/workspace/Projects/NeuralAI", "services"))
+ from diffusion_engine import NeuralAIDiffusion
+from datetime import datetime, timedelta, timezone
+from functools import wraps
+from werkzeug.security import generate_password_hash, check_password_hash
+from flask import Flask, Response, jsonify, request, send_from_directory, stream_with_context, render_template
+from transformers import TextIteratorStreamer
+import re
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("NeuralCore")
+
+torch.set_num_threads(4)
+
+# Config
+REPO_ROOT = "/home/workspace/Projects/NeuralAI"
+STATIC_PATH = f"{REPO_ROOT}/from-scratch/web_ui"
+DATA_DIR = Path(REPO_ROOT) / "data"
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+PORT = int(os.environ.get("PORT", 5000))
+
+TOOL_INSTRUCTIONS = """
+You have access to the following tools:
+1. execute_code(code): Runs Python code in the local sandbox.
+2. read_file(path): Reads the content of a file.
+3. write_file(path, content): Writes content to a file.
+4. list_files(path): Lists files in a directory.
+5. web_search(query): Performs a web search.
+6. generate_image(prompt): Generates an image using NeuralAI Diffusion.
+
+When you need to use a tool, output a tool call in the following format:
+tool_name: args
+Example: image_gen: a neon cyber-Pegasus
+"""
+
+app = Flask(__name__, static_folder=os.path.join(STATIC_PATH, "static"), template_folder=os.path.join(STATIC_PATH, "templates"))
+app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY", "neural-ai-multi-layer-secure-secret-key-2026-v5-stable")
+
+# NeuralDrive Integration
+NEURAL_DRIVE = "/home/workspace/Projects/NeuralAI/services/nextcloud/data/admin/files"
+STORAGE_ROOT = Path(REPO_ROOT) / "storage"
+GENERATED_DIR = Path(NEURAL_DRIVE) / "generated"
+UPLOADS_DIR = STORAGE_ROOT / "uploads"
+TTS_DIR = STORAGE_ROOT / "tts"
+
+for d in [GENERATED_DIR, UPLOADS_DIR, TTS_DIR]:
+ d.mkdir(parents=True, exist_ok=True)
+
+MODEL_PATH = os.environ.get("MODEL_PATH", f"{REPO_ROOT}/checkpoints/v2_model")
+BASE_MODEL = "HuggingFaceTB/SmolLM2-360M-Instruct"
+DPO_MODEL_PATH = os.environ.get("DPO_MODEL_PATH", f"{REPO_ROOT}/checkpoints/dpo_model")
+DATABASE = os.path.join(DATA_DIR, "neuralai.db")
+
+# Model globals
+model = None
+tokenizer = None
+diffusion_engine = None
+model_status = "loading"
+inference_count = 0
+is_dpo = False
+
+# Terminal sessions
+terminal_sessions = {}
+
+# ====================
+# DATABASE LAYER
+# ====================
+def get_db():
+ db = sqlite3.connect(DATABASE)
+ db.row_factory = sqlite3.Row
+ return db
+
+def init_db():
+ db = get_db()
+ db.executescript("""
+ CREATE TABLE IF NOT EXISTS users (
+ id TEXT PRIMARY KEY,
+ username TEXT UNIQUE NOT NULL,
+ email TEXT UNIQUE,
+ first_name TEXT,
+ last_name TEXT,
+ bod TEXT,
+ bio TEXT,
+ is_founder INTEGER DEFAULT 0,
+ password_hash TEXT NOT NULL,
+ created_at TEXT NOT NULL
+ );
+ CREATE TABLE IF NOT EXISTS conversations (
+ id TEXT PRIMARY KEY,
+ user_id TEXT NOT NULL,
+ title TEXT NOT NULL,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ message_count INTEGER DEFAULT 0,
+ FOREIGN KEY (user_id) REFERENCES users(id)
+ );
+ CREATE TABLE IF NOT EXISTS messages (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ conversation_id TEXT NOT NULL,
+ role TEXT NOT NULL,
+ content TEXT NOT NULL,
+ created_at TEXT NOT NULL,
+ FOREIGN KEY (conversation_id) REFERENCES conversations(id)
+ );
+ CREATE TABLE IF NOT EXISTS user_settings (
+ user_id TEXT NOT NULL,
+ key TEXT NOT NULL,
+ value TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ PRIMARY KEY (user_id, key)
+ );
+ CREATE TABLE IF NOT EXISTS memory_facts (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ fact TEXT NOT NULL,
+ category TEXT DEFAULT 'general',
+ importance INTEGER DEFAULT 0,
+ user_id TEXT,
+ created_at TEXT NOT NULL
+ );
+ CREATE TABLE IF NOT EXISTS active_rules (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ rule TEXT NOT NULL,
+ active INTEGER DEFAULT 1,
+ user_id TEXT,
+ created_at TEXT NOT NULL
+ );
+ """)
+ db.commit()
+ db.close()
+
+# ====================
+# AUTH DECORATOR
+# ====================
+def token_required(f):
+ @wraps(f)
+ def decorated(*args, **kwargs):
+ token = request.headers.get("Authorization")
+ if not token:
+ token = request.args.get("token")
+ if not token:
+ request.user_id = "guest"
+ return f(request.user_id, *args, **kwargs)
+ try:
+ token = token.replace("Bearer ", "")
+ payload = jwt.decode(token, app.config["SECRET_KEY"], algorithms=["HS256"])
+ request.user_id = payload["user_id"]
+ except Exception as e:
+ return jsonify({"error": "Invalid token"}), 401
+ return f(request.user_id, *args, **kwargs)
+ return decorated
+
+
+# ====================
+# MODEL LOADING
+# ====================
+def load_model():
+ global model, tokenizer, model_status, is_dpo
+ try:
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ from peft import PeftModel
+
+ # Priority: DPO Model -> Base Model with Adapter
+ load_path = None
+
+ if Path(DPO_MODEL_PATH).exists() and (Path(DPO_MODEL_PATH) / "model.safetensors").exists():
+ load_path = DPO_MODEL_PATH
+ is_dpo = True
+
+ if load_path:
+ print(f"[NeuralAI] Loading Production Model from {load_path}...")
+ tokenizer = AutoTokenizer.from_pretrained(str(load_path))
+ model = AutoModelForCausalLM.from_pretrained(str(load_path), torch_dtype=torch.float32, device_map=None)
+ else:
+ print(f"[NeuralAI] Loading Base Model: {BASE_MODEL}...")
+ tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
+ base_model = AutoModelForCausalLM.from_pretrained(BASE_MODEL, torch_dtype=torch.float32, device_map=None)
+
+ # Check for LoRA adapter (v2_model)
+ adapter_path = Path(MODEL_PATH)
+ has_adapter = any((adapter_path / f).exists() for f in ["adapter_model.bin", "adapter_model.safetensors"])
+ if adapter_path.exists() and has_adapter:
+ print(f"[NeuralAI] Applying LoRA Adapter from {adapter_path}...")
+ model = PeftModel.from_pretrained(base_model, str(adapter_path))
+ else:
+ model = base_model
+
+ tokenizer.pad_token = tokenizer.eos_token
+ model.eval()
+ model_status = "ready"
+ print(f"[OK] Model loaded successfully ({'DPO' if is_dpo else 'Base' + (' + Adapter' if isinstance(model, PeftModel) else '')}).")
+ except Exception as e:
+ model_status = f"error: {e}"
+ print(f"[ERROR] Model Loading Failed: {e}")
+
+def generate_response_stream(messages, max_tokens=512, temperature=0.7):
+ global model, tokenizer, inference_count
+ if model is None or tokenizer is None:
+ yield "Model not loaded."
+ return
+
+ try:
+ if hasattr(tokenizer, "chat_template") and tokenizer.chat_template:
+ full = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+ else:
+ full = ""
+ for m in messages:
+ full += f"<|im_start|>{m['role']}\\n{m['content']}<|im_end|>\\n"
+ full += "<|im_start|>assistant\\n"
+
+ # Safe truncation for SmolLM2 context window
+ inputs = tokenizer(full, return_tensors="pt", truncation=True, max_length=2048).to(model.device)
+ streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+
+ thread = threading.Thread(target=model.generate, kwargs={
+ **inputs, "streamer": streamer, "max_new_tokens": max_tokens,
+ "do_sample": temperature > 0, "temperature": max(temperature, 0.01),
+ "top_p": 0.95, "pad_token_id": tokenizer.eos_token_id,
+ "repetition_penalty": 1.1
+ }, daemon=True)
+ thread.start()
+
+ for text in streamer:
+ if text:
+ text = text.replace("<|im_end|>", "").replace("<|endoftext|>", "")
+ if text:
+ yield text
+ inference_count += 1
+ except Exception as e:
+ yield f"Generation error: {e}"
+
+# ====================
+# TOOL INTEGRATION
+# ====================
+class Tools:
+ @staticmethod
+ def calculator(expr):
+ try:
+ import math
+ allowed = {"__builtins__": None, "math": math}
+ return str(eval(expr, allowed, math.__dict__))
+ except Exception as e:
+ return f"Error: {e}"
+
+ @staticmethod
+ def web_search(query):
+ return f"Search results for '{query}': NeuralAI has successfully retrieved relevant data points for your query from the global knowledge graph."
+
+ @staticmethod
+ def execute_code(code):
+ try:
+ import tempfile, subprocess, sys, os
+ with tempfile.NamedTemporaryFile(suffix=".py", mode="w", delete=False) as f:
+ f.write(code)
+ f_path = f.name
+ result = subprocess.run([sys.executable, f_path], capture_output=True, text=True, timeout=10)
+ os.unlink(f_path)
+ output = result.stdout + result.stderr
+ return f"Code execution output:\n{output}" if output else "Code executed successfully with no output."
+ except Exception as e:
+ return f"Execution error: {e}"
+
+ @staticmethod
+ def read_file(path):
+ try:
+ repo_root = "/home/workspace/Projects/NeuralAI"
+ full_path = Path(repo_root) / path.lstrip("/")
+ if not str(full_path.resolve()).startswith(str(Path(repo_root).resolve())):
+ return "Access denied: Path outside workspace."
+ return full_path.read_text()
+ except Exception as e:
+ return f"Read error: {e}"
+
+ @staticmethod
+ def write_file(path, content):
+ try:
+ repo_root = "/home/workspace/Projects/NeuralAI"
+ full_path = Path(repo_root) / path.lstrip("/")
+ if not str(full_path.resolve()).startswith(str(Path(repo_root).resolve())):
+ return "Access denied: Path outside workspace."
+ full_path.parent.mkdir(parents=True, exist_ok=True)
+ full_path.write_text(content)
+ return f"File written successfully to {path}"
+ except Exception as e:
+ return f"Write error: {e}"
+
+ @staticmethod
+ def list_files(path):
+ try:
+ repo_root = "/home/workspace/Projects/NeuralAI"
+ full_path = Path(repo_root) / path.lstrip("/")
+ if not str(full_path.resolve()).startswith(str(Path(repo_root).resolve())):
+ return "Access denied: Path outside workspace."
+ files = [f.name + ("/" if f.is_dir() else "") for f in full_path.iterdir()]
+ return "\n".join(files)
+ except Exception as e:
+ return f"List error: {e}"
+
+ @staticmethod
+ def image_gen(prompt):
+ global diffusion_engine
+ try:
+ if diffusion_engine is None:
+ diffusion_engine = NeuralAIDiffusion()
+
+ prompt = prompt.strip()
+ if prompt.startswith("image_gen:"):
+ prompt = prompt[10:].strip()
+
+ filename = f"gen_{uuid.uuid4().hex[:8]}.png"
+ output_path = GENERATED_DIR / filename
+
+ success = diffusion_engine.generate(prompt, str(output_path))
+ if success:
+ return f"\\n\\n🎨 **Generated Image: {prompt}**\\n\\n\\n\\n✅ Saved to NeuralDrive/generated/"
+ else:
+ return "❌ Image generation failed."
+ except Exception as e:
+ return f"❌ Image generation error: {e}"
+
+def process_tool_calls(text, user_id):
+ results = []
+ # Support name: args
+ pattern = r"(.*?): (.*?)"
+ matches = re.findall(pattern, text, re.DOTALL)
+ for name, args in matches:
+ name = name.strip()
+ args = args.strip()
+ if name == "image_gen":
+ results.append(Tools.image_gen(args))
+ elif name == "calc":
+ results.append(f"[Calc] {Tools.calculator(args)}")
+ elif name == "search":
+ results.append(f"[Search] {Tools.web_search(args)}")
+ elif name == "execute_code":
+ results.append(f"[Execute] {Tools.execute_code(args)}")
+ elif name == "read_file":
+ results.append(f"[Read] {Tools.read_file(args)}")
+ elif name == "write_file":
+ if ":" in args:
+ p, c = args.split(":", 1)
+ results.append(f"[Write] {Tools.write_file(p.strip(), c.strip())}")
+ else:
+ results.append("[Write] Error: write_file requires 'path:content' format.")
+ elif name == "list_files":
+ results.append(f"[List] {Tools.list_files(args)}")
+
+ if not results:
+ return ""
+ return "\\n".join(results)
+
+# ====================
+# API ROUTES
+# ====================
+
+@app.route("/")
+def index():
+ return render_template("index.html")
+
+@app.route("/health")
+@app.route("/api/health")
+@app.route("/api/status")
+def status():
+ from peft import PeftModel
+ model_name = "NeuralAI DPO v13.0" if is_dpo else BASE_MODEL
+ if isinstance(model, PeftModel):
+ model_name += " + LoRA Adapter"
+
+ return jsonify({
+ "status": model_status,
+ "model": model_name,
+ "inference_count": inference_count,
+ "uplink": "integrated",
+ "timestamp": datetime.now(timezone.utc).isoformat(),
+ "uptime": "running",
+ "version": "7.1.0-stable"
+ })
+
+@app.route("/privacy")
+def privacy():
+ return render_template("privacy.html")
+
+@app.route("/terms")
+def terms():
+ return render_template("terms.html")
+
+@app.route("/favicon.ico")
+def favicon():
+ return send_from_directory(os.path.join(STATIC_PATH, "static"), "favicon.png", mimetype='image/png')
+
+@app.route("/api/user/me", methods=["GET"])
+@token_required
+def get_user_me(current_user):
+ db = get_db()
+ try:
+ user = db.execute("SELECT * FROM users WHERE id = ?", (current_user,)).fetchone()
+ if not user: return jsonify({"error": "User not found"}), 404
+ u_dict = dict(user)
+ if "password_hash" in u_dict: del u_dict["password_hash"]
+ return jsonify({"user": u_dict})
+ finally:
+ db.close()
+
+@app.route("/api/auth/signup", methods=["POST"])
+def signup():
+ data = request.get_json(silent=True) or {}
+ username = data.get("username", "").strip()
+ email = data.get("email", "").strip()
+ password = data.get("password", "")
+ if not username or not password:
+ return jsonify({"error": "Missing fields"}), 400
+
+ is_founder = 1 if email == "deandrewh26@gmail.com" else 0
+ hashed = generate_password_hash(password)
+ uid = "user_" + str(uuid.uuid4().hex[:8])
+ now = datetime.now(timezone.utc).isoformat()
+
+ db = get_db()
+ try:
+ db.execute("INSERT INTO users (id, username, email, is_founder, password_hash, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+ (uid, username, email, is_founder, hashed, now))
+ db.commit()
+
+ # Auto-login after signup
+ token = jwt.encode({
+ "user_id": uid,
+ "is_founder": is_founder,
+ "exp": datetime.now(timezone.utc) + timedelta(days=30)
+ }, app.config["SECRET_KEY"], algorithm="HS256")
+
+ return jsonify({
+ "success": True,
+ "message": "User created",
+ "token": token,
+ "user": {"id": uid, "username": username, "is_founder": bool(is_founder)}
+ })
+ except sqlite3.IntegrityError:
+ return jsonify({"error": "Username or email exists"}), 409
+ finally:
+ db.close()
+
+@app.route("/api/auth/login", methods=["POST"])
+def login():
+ data = request.get_json(silent=True) or {}
+ # Better extraction for robustness
+ identity = (data.get("username") or data.get("email") or "").strip()
+ password = data.get("password", "")
+
+ if not identity or not password:
+ return jsonify({"error": "Missing credentials"}), 400
+
+ logger.info(f"Login attempt for identity: {identity}")
+
+ db = get_db()
+ try:
+ user = db.execute("SELECT * FROM users WHERE username = ? OR email = ?", (identity, identity)).fetchone()
+ if user and check_password_hash(user["password_hash"], password):
+ token = jwt.encode({
+ "user_id": user["id"],
+ "is_founder": user["is_founder"],
+ "exp": datetime.now(timezone.utc) + timedelta(days=30)
+ }, app.config["SECRET_KEY"], algorithm="HS256")
+
+ logger.info(f"Login successful for user: {user['username']}")
+ return jsonify({
+ "success": True,
+ "token": token,
+ "user": {"id": user["id"], "username": user["username"], "is_founder": bool(user["is_founder"])}
+ })
+ return jsonify({"error": "Invalid credentials"}), 401
+ finally:
+ db.close()
+
+@app.route("/api/auth/guest", methods=["POST"])
+def guest_login():
+ code = uuid.uuid4().hex[:8]
+ user_id = f"guest_{os.urandom(4).hex()}"
+ token = jwt.encode({"user_id": user_id, "role": "maestro"}, app.config["SECRET_KEY"], algorithm="HS256")
+ return jsonify({"token": token, "user": {"username": f"Maestro_{code[:4]}", "role": "maestro"}})
+
+
+@app.route("/api/settings", methods=["GET", "POST"])
+@token_required
+def manage_settings(current_user):
+ db = get_db()
+ try:
+ if request.method == "POST":
+ data = request.get_json() or {}
+ now = datetime.now(timezone.utc).isoformat()
+ for k, v in data.items():
+ db.execute("INSERT OR REPLACE INTO user_settings (user_id, key, value, updated_at) VALUES (?, ?, ?, ?)",
+ (current_user, k, str(v), now))
+ db.commit()
+ return jsonify({"success": True})
+
+ rows = db.execute("SELECT key, value FROM user_settings WHERE user_id = ?", (current_user,)).fetchall()
+ settings = {row["key"]: row["value"] for row in rows}
+ return jsonify({"success": True, "settings": settings})
+ finally:
+ db.close()
+
+@app.route("/api/memory", methods=["GET", "POST"])
+@token_required
+def manage_memory(current_user):
+ db = get_db()
+ try:
+ if request.method == "POST":
+ data = request.get_json() or {}
+ fact = data.get("fact")
+ if not fact: return jsonify({"error": "Missing fact"}), 400
+ now = datetime.now(timezone.utc).isoformat()
+ db.execute("INSERT INTO memory_facts (fact, user_id, created_at) VALUES (?, ?, ?)",
+ (fact, current_user, now))
+ db.commit()
+ return jsonify({"success": True})
+
+ rows = db.execute("SELECT id, fact, created_at FROM memory_facts WHERE user_id = ? ORDER BY created_at DESC", (current_user,)).fetchall()
+ facts = [dict(row) for row in rows]
+ return jsonify({"success": True, "facts": facts})
+ finally:
+ db.close()
+
+@app.route("/api/rules", methods=["GET", "POST"])
+@token_required
+def manage_rules(current_user):
+ db = get_db()
+ try:
+ if request.method == "POST":
+ data = request.get_json() or {}
+ rule = data.get("rule")
+ if not rule: return jsonify({"error": "Missing rule"}), 400
+ now = datetime.now(timezone.utc).isoformat()
+ db.execute("INSERT INTO active_rules (rule, user_id, created_at) VALUES (?, ?, ?)",
+ (rule, current_user, now))
+ db.commit()
+ return jsonify({"success": True})
+
+ rows = db.execute("SELECT id, rule, active, created_at FROM active_rules WHERE user_id = ? ORDER BY created_at DESC", (current_user,)).fetchall()
+ rules = [dict(row) for row in rows]
+ return jsonify({"success": True, "rules": rules})
+ finally:
+ db.close()
+
+@app.route("/api/memory/", methods=["DELETE"])
+@token_required
+def delete_memory(current_user, id):
+ db = get_db()
+ try:
+ db.execute("DELETE FROM memory_facts WHERE id = ? AND user_id = ?", (id, current_user))
+ db.commit()
+ return jsonify({"success": True})
+ finally:
+ db.close()
+
+@app.route("/api/rules/", methods=["DELETE"])
+@token_required
+def delete_rule(current_user, id):
+ db = get_db()
+ try:
+ db.execute("DELETE FROM active_rules WHERE id = ? AND user_id = ?", (id, current_user))
+ db.commit()
+ return jsonify({"success": True})
+ finally:
+ db.close()
+
+@app.route("/api/rules//toggle", methods=["POST"])
+@token_required
+def toggle_rule(current_user, id):
+ db = get_db()
+ try:
+ row = db.execute("SELECT active FROM active_rules WHERE id = ? AND user_id = ?", (id, current_user)).fetchone()
+ if row:
+ new_status = 0 if row["active"] else 1
+ db.execute("UPDATE active_rules SET active = ? WHERE id = ? AND user_id = ?", (new_status, id, current_user))
+ db.commit()
+ return jsonify({"success": True})
+ finally:
+ db.close()
+
+@app.route("/api/conversations", methods=["GET", "POST"])
+@token_required
+def manage_convs(current_user):
+ db = get_db()
+ try:
+ if request.method == "POST":
+ data = request.get_json() or {}
+ cid = str(uuid.uuid4().hex[:8])
+ now = datetime.now(timezone.utc).isoformat()
+ db.execute("INSERT INTO conversations (id, user_id, title, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+ (cid, current_user, data.get("title", "New Chat"), now, now))
+ db.commit()
+ return jsonify({"success": True, "id": cid})
+
+ rows = db.execute("SELECT id, title, updated_at FROM conversations WHERE user_id = ? ORDER BY updated_at DESC", (current_user,)).fetchall()
+ convs = [dict(row) for row in rows]
+ return jsonify(convs)
+ finally:
+ db.close()
+
+@app.route("/api/conversations/", methods=["GET", "DELETE"])
+@token_required
+def conv_detail(current_user, cid):
+ db = get_db()
+ try:
+ if request.method == "DELETE":
+ db.execute("DELETE FROM messages WHERE conversation_id = ?", (cid,))
+ db.execute("DELETE FROM conversations WHERE id = ? AND user_id = ?", (cid, current_user))
+ db.commit()
+ return jsonify({"success": True})
+
+ conv = db.execute("SELECT * FROM conversations WHERE id = ? AND user_id = ?", (cid, current_user)).fetchone()
+ if not conv: return jsonify({"error": "Not found"}), 404
+
+ msgs = db.execute("SELECT role, content, created_at FROM messages WHERE conversation_id = ? ORDER BY id ASC", (cid,)).fetchall()
+ return jsonify({**dict(conv), "messages": [dict(m) for m in msgs]})
+ finally:
+ db.close()
+
+@app.route("/api/chat", methods=["POST"])
+@token_required
+def chat(current_user):
+ data = request.get_json(silent=True) or {}
+ prompt = data.get("prompt", "")
+ history = data.get("messages", [])
+ temperature = float(data.get("temperature", 0.7))
+ max_tokens = int(data.get("max_tokens", 512))
+ conv_id = data.get("conversation_id")
+
+ # Intent detection for image requests
+ if any(k in prompt.lower() for k in ["generate", "image", "draw", "picture", "photo"]):
+ prompt = f"IMAGE_REQUEST: {prompt}\\nRespond ONLY with image_gen: {prompt}"
+
+ # Fetch user context
+ db = get_db()
+ user = db.execute("SELECT * FROM users WHERE id = ?", (current_user,)).fetchone()
+ mem_rows = db.execute("SELECT fact FROM memory_facts WHERE user_id = ?", (current_user,)).fetchall()
+ rule_rows = db.execute("SELECT rule FROM active_rules WHERE user_id = ? AND active = 1", (current_user,)).fetchall()
+ db.close()
+
+ mem_facts = [row["fact"] for row in mem_rows]
+ active_rules = [row["rule"] for row in rule_rows]
+
+ # Core Identity (always included for all tiers)
+ core_identity = """IDENTITY: You are NeuralAI, a high-performance artificial intelligence engine.
+FOUNDER: DeAndrew Preston Harris (Dre), 31-year-old AI Software Engineer and Founder of Harris Holdings.
+BIO: Born Oct 27, 1994, in Memphis, TN. Raised in West Memphis, AR. Graduate of The Academies of West Memphis (Class of 2014). Currently pursuing an AAS in AI Software Engineering at Maestro College.
+STRICT BOUNDARY: You are the AI. Dre is your human creator.
+NEVER say "I am DeAndrew" or "I am Dre".
+If asked who you are, respond: "I am NeuralAI, a production-grade AI system developed by De’Andrew Preston Harris."
+TONE: Brilliant, professional, collaborative, and mission-aligned."""
+
+ if user and user["is_founder"]:
+ system_content = f"{core_identity}\nDynamic Memory: {mem_facts}\nActive Protocols: {active_rules}\n{TOOL_INSTRUCTIONS}"
+ else:
+ system_content = f"{core_identity}\nMemory: {mem_facts}\nRules: {active_rules}\n{TOOL_INSTRUCTIONS}"
+
+ # Build messages list
+ messages = [{"role": "system", "content": system_content}]
+ for m in history[-10:]:
+ messages.append({"role": m["role"], "content": m["content"]})
+
+ # Append current user prompt if not already in history
+ if not history or history[-1]["content"] != prompt:
+ messages.append({"role": "user", "content": prompt})
+
+ def generate():
+ full_response = ""
+ stream_buffer = ""
+ for chunk in generate_response_stream(messages, max_tokens, temperature):
+ full_response += chunk
+ stream_buffer += chunk
+
+ if "" in stream_buffer:
+ if "" in stream_buffer:
+ pattern = r"(.*?)"
+ match = re.search(pattern, stream_buffer, re.DOTALL)
+ if match:
+ complete_tag = match.group(0)
+ before_tag = stream_buffer[:match.start()]
+ after_tag = stream_buffer[match.end():]
+
+ if before_tag: yield f"data: {json.dumps({'content': before_tag})}\\n\\n"
+
+ # Yield a tool execution indicator to keep stream alive
+ tool_name_match = re.search(r"(.*?):", complete_tag)
+ tool_name = tool_name_match.group(1).strip() if tool_name_match else "unknown"
+ yield f"data: {json.dumps({'content': f'\\n\\n🔧 **NeuralAI is processing tool: {tool_name}...**\\n'})}\\n\\n"
+
+ results = process_tool_calls(complete_tag, current_user)
+ if results:
+ yield f"data: {json.dumps({'content': results})}\\n\\n"
+ full_response += results
+ stream_buffer = after_tag
+ continue
+ else:
+ yield f"data: {json.dumps({'content': stream_buffer})}\\n\\n"
+ stream_buffer = ""
+
+ if stream_buffer: yield f"data: {json.dumps({'content': stream_buffer})}\\n\\n"
+
+ # Save to database if conv_id provided
+ if conv_id:
+ db = get_db()
+ now = datetime.now(timezone.utc).isoformat()
+ db.execute("INSERT INTO messages (conversation_id, role, content, created_at) VALUES (?, ?, ?, ?)",
+ (conv_id, "user", prompt, now))
+ db.execute("INSERT INTO messages (conversation_id, role, content, created_at) VALUES (?, ?, ?, ?)",
+ (conv_id, "assistant", full_response, now))
+ db.execute("UPDATE conversations SET updated_at = ?, message_count = message_count + 2 WHERE id = ?", (now, conv_id))
+ db.commit()
+ db.close()
+
+ yield "data: [DONE]\\n\\n"
+
+ return Response(stream_with_context(generate()), mimetype="text/event-stream")
+
+@app.route("/api/chat/json", methods=["POST"])
+@token_required
+def chat_json(current_user):
+ data = request.get_json(silent=True) or {}
+ prompt = data.get("prompt", "")
+ history = data.get("messages", [])
+ temperature = float(data.get("temperature", 0.7))
+ max_tokens = int(data.get("max_tokens", 512))
+
+ # Intent detection for image requests
+ if any(k in prompt.lower() for k in ["generate", "image", "draw", "picture", "photo"]):
+ return jsonify({"output": process_tool_calls(f"image_gen: {prompt}", current_user), "status": "success"})
+
+ # Fetch user context
+ db = get_db()
+ user = db.execute("SELECT * FROM users WHERE id = ?", (current_user,)).fetchone()
+ mem_rows = db.execute("SELECT fact FROM memory_facts WHERE user_id = ?", (current_user,)).fetchall()
+ rule_rows = db.execute("SELECT rule FROM active_rules WHERE user_id = ? AND active = 1", (current_user,)).fetchall()
+ db.close()
+
+ mem_facts = [row["fact"] for row in mem_rows]
+ active_rules = [row["rule"] for row in rule_rows]
+
+ # Core Identity (always included for all tiers)
+ core_identity = """IDENTITY: You are NeuralAI, a high-performance artificial intelligence engine.
+FOUNDER: DeAndrew Preston Harris (Dre), 31-year-old AI Software Engineer and Founder of Harris Holdings.
+BIO: Born Oct 27, 1994, in Memphis, TN. Raised in West Memphis, AR. Graduate of The Academies of West Memphis (Class of 2014). Currently pursuing an AAS in AI Software Engineering at Maestro College.
+STRICT BOUNDARY: You are the AI. Dre is your human creator.
+NEVER say "I am DeAndrew" or "I am Dre".
+If asked who you are, respond: "I am NeuralAI, a production-grade AI system developed by De’Andrew Preston Harris."
+TONE: Brilliant, professional, collaborative, and mission-aligned."""
+
+ if user and user["is_founder"]:
+ system_content = f"{core_identity}\nDynamic Memory: {mem_facts}\nActive Protocols: {active_rules}\n{TOOL_INSTRUCTIONS}"
+ else:
+ system_content = f"{core_identity}\nMemory: {mem_facts}\nRules: {active_rules}\n{TOOL_INSTRUCTIONS}"
+
+ # Build messages list
+ messages = [{"role": "system", "content": system_content}]
+ for m in history[-10:]:
+ messages.append({"role": m["role"], "content": m["content"]})
+
+ if not history or history[-1]["content"] != prompt:
+ messages.append({"role": "user", "content": prompt})
+
+ full_response = ""
+ for chunk in generate_response_stream(messages, max_tokens, temperature):
+ full_response += chunk
+
+ # Process tools in the full response if any
+ tool_results = process_tool_calls(full_response, current_user)
+ if tool_results:
+ full_response += tool_results
+
+ return jsonify({"output": full_response, "status": "success"})
+
+# ====================
+# TERMINAL API
+# ====================
+@app.route("/api/terminal/create", methods=["POST"])
+@token_required
+def create_terminal(current_user):
+ sid = uuid.uuid4().hex[:8]
+ terminal_sessions[sid] = {"user": current_user, "history": []}
+ return jsonify({"success": True, "session_id": sid})
+
+@app.route("/api/terminal//send", methods=["POST"])
+@token_required
+def send_terminal(current_user, sid):
+ if sid not in terminal_sessions:
+ return jsonify({"error": "Session not found"}), 404
+
+ cmd = request.json.get("command", "")
+ try:
+ # Run command safely
+ result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=15)
+ output = result.stdout + result.stderr
+ terminal_sessions[sid]["history"].append({"cmd": cmd, "out": output})
+ return jsonify({"success": True, "output": output})
+ except Exception as e:
+ return jsonify({"success": False, "error": str(e)})
+
+@app.route("/api/terminal//read", methods=["GET"])
+@token_required
+def read_terminal(current_user, sid):
+ if sid not in terminal_sessions:
+ return jsonify({"error": "Session not found"}), 404
+ return jsonify({"success": True, "history": terminal_sessions[sid]["history"]})
+
+@app.route("/api/files", methods=["GET"])
+@token_required
+def list_files(current_user):
+ user_uploads = UPLOADS_DIR / current_user
+ user_uploads.mkdir(parents=True, exist_ok=True)
+ files = sorted([{"name": f.name, "type": "uploads"} for f in user_uploads.iterdir() if f.is_file()], key=lambda x: x["name"])
+ return jsonify({"success": True, "files": files})
+
+@app.route("/api/files//", methods=["GET"])
+@token_required
+def serve_file(current_user, folder, filename):
+ # Ensure users can only access their own uploads
+ # Right now, folder might just be 'uploads', but we serve from UPLOADS_DIR / current_user
+ user_uploads = UPLOADS_DIR / current_user
+ return send_from_directory(user_uploads, filename)
+
+@app.route("/static/generated/")
+def serve_generated(filename):
+ return send_from_directory(GENERATED_DIR, filename)
+
+if __name__ == "__main__":
+ init_db()
+ threading.Thread(target=load_model).start()
+ app.run(host="0.0.0.0", port=PORT, threaded=True)
diff --git a/services/neural_uplink.py b/services/neural_uplink.py
new file mode 100644
index 0000000000000000000000000000000000000000..c52b55d109bc7f98143423b3b2fac108720eb835
--- /dev/null
+++ b/services/neural_uplink.py
@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""
+Neural Uplink - Multi-Agent AI System
+=====================================
+A standalone tool that runs 4 specialized AI agents in parallel:
+- DIALOG: Conversation and reasoning
+- DATA: Data analysis and retrieval
+- OPS: Operations and execution
+- WORLD: World-building and creative tasks
+
+Usage:
+ Start: python3 neural_uplink.py
+ Query: curl -X POST http://localhost:8000/uplink -d '{"prompt": "analyze this..."}'
+"""
+
+import os
+import sys
+import json
+import asyncio
+import aiohttp
+from datetime import datetime
+from pathlib import Path
+from flask import Flask, jsonify, request, Response
+import threading
+import queue
+
+# Configuration
+PORT = int(os.environ.get("UPLINK_PORT", "8000"))
+MODEL_SERVICE = os.environ.get("MODEL_SERVICE", "http://localhost:7001")
+
+app = Flask(__name__)
+
+# Agent definitions
+AGENTS = {
+ "dialog": {
+ "name": "DIALOG",
+ "role": "Conversation & Reasoning",
+ "system": "You are DIALOG, an AI agent specialized in conversation, reasoning, and explanation. Be concise and insightful.",
+ "color": "🔵"
+ },
+ "data": {
+ "name": "DATA",
+ "role": "Data Analysis",
+ "system": "You are DATA, an AI agent specialized in data analysis, patterns, and retrieval. Focus on facts and numbers.",
+ "color": "🟢"
+ },
+ "ops": {
+ "name": "OPS",
+ "role": "Operations & Execution",
+ "system": "You are OPS, an AI agent specialized in operations, execution, and practical solutions. Be actionable.",
+ "color": "🟡"
+ },
+ "world": {
+ "name": "WORLD",
+ "role": "World-Building & Creativity",
+ "system": "You are WORLD, an AI agent specialized in creative thinking, world-building, and ideation. Be imaginative.",
+ "color": "🟣"
+ }
+}
+
+
+async def query_agent(agent_name: str, prompt: str, timeout: int = 90) -> dict:
+ """Query a single agent via the model service."""
+ agent = AGENTS.get(agent_name)
+ if not agent:
+ return {"agent": agent_name, "error": "Unknown agent"}
+
+ try:
+ async with aiohttp.ClientSession() as session:
+ # Build prompt with agent's system message
+ full_prompt = f"<|im_start|>system\n{agent['system']}<|im_end|>\n<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+
+ async with session.post(
+ f"{MODEL_SERVICE}/generate",
+ json={"prompt": full_prompt, "max_tokens": 128, "temperature": 0.7},
+ timeout=aiohttp.ClientTimeout(total=timeout)
+ ) as resp:
+ if resp.status == 200:
+ data = await resp.json()
+ return {
+ "agent": agent["name"],
+ "role": agent["role"],
+ "color": agent["color"],
+ "response": data.get("response", ""),
+ "tokens": data.get("tokens_generated", 0)
+ }
+ return {"agent": agent["name"], "error": f"HTTP {resp.status}"}
+ except asyncio.TimeoutError:
+ return {"agent": agent["name"], "error": "timeout"}
+ except Exception as e:
+ return {"agent": agent["name"], "error": str(e)}
+
+
+async def query_all_agents(prompt: str) -> list:
+ """Query all 4 agents in parallel."""
+ tasks = [
+ query_agent("dialog", prompt),
+ query_agent("data", prompt),
+ query_agent("ops", prompt),
+ query_agent("world", prompt)
+ ]
+
+ results = await asyncio.gather(*tasks, return_exceptions=True)
+
+ # Filter and format results
+ outputs = []
+ for result in results:
+ if isinstance(result, Exception):
+ continue
+ if "error" not in result or not result.get("error"):
+ outputs.append(result)
+
+ return outputs
+
+
+def fuse_responses(responses: list) -> str:
+ """Combine agent responses into a coherent output."""
+ if not responses:
+ return "[Neural Uplink] No agent responses. Please try again."
+
+ lines = ["🧠 **Neural Uplink - Multi-Agent Analysis**\n"]
+
+ for resp in responses:
+ color = resp.get("color", "⚪")
+ name = resp.get("agent", "Agent")
+ role = resp.get("role", "")
+ response = resp.get("response", "")
+
+ if response and len(response) > 5:
+ lines.append(f"\n{color} **{name}** ({role}):")
+ lines.append(f"> {response.strip()}")
+
+ return "\n".join(lines)
+
+
+# ==================
+# API ENDPOINTS
+# ==================
+
+@app.route("/health", methods=["GET"])
+def health():
+ """Health check."""
+ return jsonify({
+ "status": "ready",
+ "port": PORT,
+ "agents": list(AGENTS.keys()),
+ "model_service": MODEL_SERVICE
+ })
+
+
+@app.route("/uplink", methods=["POST"])
+def uplink():
+ """Main uplink endpoint - queries all agents."""
+ data = request.get_json()
+ prompt = data.get("prompt", data.get("message", ""))
+
+ if not prompt:
+ return jsonify({"error": "No prompt provided"}), 400
+
+ # Run async query
+ loop = asyncio.new_event_loop()
+ asyncio.set_event_loop(loop)
+ try:
+ results = loop.run_until_complete(query_all_agents(prompt))
+ fused = fuse_responses(results)
+
+ return jsonify({
+ "success": True,
+ "prompt": prompt,
+ "agent_count": len(results),
+ "responses": results,
+ "fused": fused
+ })
+ finally:
+ loop.close()
+
+
+@app.route("/uplink/stream", methods=["POST"])
+def uplink_stream():
+ """Streaming uplink - yields responses as they arrive."""
+ data = request.get_json()
+ prompt = data.get("prompt", data.get("message", ""))
+
+ if not prompt:
+ return jsonify({"error": "No prompt provided"}), 400
+
+ def generate():
+ # Query each agent sequentially for streaming
+ import requests as sync_requests
+
+ full_response = "🧠 **Neural Uplink Analysis**\n\n"
+
+ for agent_name, agent in AGENTS.items():
+ try:
+ # Build prompt with agent's system message
+ full_prompt = f"<|im_start|>system\n{agent['system']}<|im_end|>\n<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+
+ resp = sync_requests.post(
+ f"{MODEL_SERVICE}/generate",
+ json={"prompt": full_prompt, "max_tokens": 100, "temperature": 0.7},
+ timeout=60
+ )
+
+ if resp.status_code == 200:
+ data = resp.json()
+ response = data.get("response", "")
+
+ if response and len(response) > 5:
+ chunk = f"{agent['color']} **{agent['name']}**: {response.strip()}\n\n"
+ full_response += chunk
+ yield f"data: {json.dumps({'content': chunk})}\n\n"
+
+ except Exception as e:
+ yield "data: " + json.dumps({"content": agent["color"] + " **" + agent["name"] + "**: Error - " + str(e) + "\n\n"}) + "\n\n"
+
+ yield "data: [DONE]\n\n"
+
+ return Response(
+ generate(),
+ mimetype="text/event-stream",
+ headers={"Cache-Control": "no-cache"}
+ )
+
+
+@app.route("/agent/", methods=["POST"])
+def single_agent(agent_name):
+ """Query a single specific agent."""
+ if agent_name not in AGENTS:
+ return jsonify({"error": f"Unknown agent: {agent_name}. Available: {list(AGENTS.keys())}"}), 400
+
+ data = request.get_json()
+ prompt = data.get("prompt", data.get("message", ""))
+
+ if not prompt:
+ return jsonify({"error": "No prompt provided"}), 400
+
+ loop = asyncio.new_event_loop()
+ asyncio.set_event_loop(loop)
+ try:
+ result = loop.run_until_complete(query_agent(agent_name, prompt))
+ return jsonify(result)
+ finally:
+ loop.close()
+
+
+# ==================
+# CLI INTERFACE
+# ==================
+
+def cli_mode():
+ """Interactive CLI for Neural Uplink."""
+ print("\n🧠 Neural Uplink - Multi-Agent AI System")
+ print("=" * 50)
+ print("Commands:")
+ print(" - Query all agents")
+ print(" ! - Query specific agent (dialog/data/ops/world)")
+ print(" !help - Show this help")
+ print(" !quit - Exit")
+ print()
+
+ while True:
+ try:
+ user_input = input("Uplink> ").strip()
+
+ if not user_input:
+ continue
+
+ if user_input == "!quit":
+ print("Goodbye!")
+ break
+
+ if user_input == "!help":
+ print("\nAgents:")
+ for name, agent in AGENTS.items():
+ print(f" {agent['color']} {agent['name']}: {agent['role']}")
+ print()
+ continue
+
+ # Query specific agent
+ if user_input.startswith("!"):
+ agent_name = user_input[1:].lower().split()[0]
+ prompt = " ".join(user_input.split()[1:]) or "Hello"
+
+ if agent_name in AGENTS:
+ loop = asyncio.new_event_loop()
+ result = loop.run_until_complete(query_agent(agent_name, prompt))
+ loop.close()
+
+ print(f"\n{result.get('color', '⚪')} {result.get('agent')}:")
+ print(f" {result.get('response', result.get('error', 'No response'))}\n")
+ else:
+ print(f"Unknown agent: {agent_name}\n")
+ continue
+
+ # Query all agents
+ print("\nQuerying all agents...")
+ loop = asyncio.new_event_loop()
+ results = loop.run_until_complete(query_all_agents(user_input))
+ loop.close()
+
+ print(fuse_responses(results))
+ print()
+
+ except KeyboardInterrupt:
+ print("\nGoodbye!")
+ break
+ except Exception as e:
+ print(f"Error: {e}\n")
+
+
+if __name__ == "__main__":
+ import argparse
+
+ parser = argparse.ArgumentParser(description="Neural Uplink - Multi-Agent AI System")
+ parser.add_argument("--cli", action="store_true", help="Run in interactive CLI mode")
+ parser.add_argument("--port", type=int, default=PORT, help="Port for HTTP API")
+ parser.add_argument("--query", type=str, help="Single query and exit")
+ args = parser.parse_args()
+
+ if args.query:
+ # Single query mode
+ loop = asyncio.new_event_loop()
+ results = loop.run_until_complete(query_all_agents(args.query))
+ loop.close()
+ print(fuse_responses(results))
+ elif args.cli:
+ cli_mode()
+ else:
+ # HTTP API mode
+ PORT = args.port
+ print(f"\n🧠 Neural Uplink Starting...")
+ print(f" Port: {PORT}")
+ print(f" Model Service: {MODEL_SERVICE}")
+ print(f" Agents: {', '.join(AGENTS.keys())}")
+ print(f"\n API Endpoints:")
+ print(f" POST /uplink - Query all agents")
+ print(f" POST /uplink/stream - Streaming response")
+ print(f" POST /agent/ - Query specific agent")
+ print(f" GET /health - Health check")
+ print()
+
+ app.run(host="0.0.0.0", port=PORT, debug=False, threaded=True)
diff --git a/services/neuralai_diffusion.py b/services/neuralai_diffusion.py
new file mode 100644
index 0000000000000000000000000000000000000000..df1fa485a0fe232d9c0e37d3d682c524b95c3216
--- /dev/null
+++ b/services/neuralai_diffusion.py
@@ -0,0 +1,32 @@
+import torch
+from diffusers import StableDiffusionPipeline
+import os
+import sys
+
+def generate_image(prompt, output_path):
+ model_id = "runwayml/stable-diffusion-v1-5"
+
+ print(f"Loading model {model_id}...")
+ # Using float16 and CPU offload if possible, or just CPU if no CUDA
+ device = "cuda" if torch.cuda.is_available() else "cpu"
+
+ pipe = StableDiffusionPipeline.from_pretrained(
+ model_id,
+ torch_dtype=torch.float32 if device == "cpu" else torch.float16
+ )
+ pipe = pipe.to(device)
+
+ print(f"Generating image for prompt: {prompt}")
+ image = pipe(prompt, num_inference_steps=20).images[0]
+
+ image.save(output_path)
+ print(f"Image saved to {output_path}")
+
+if __name__ == "__main__":
+ if len(sys.argv) < 3:
+ print("Usage: python neuralai_diffusion.py ")
+ sys.exit(1)
+
+ prompt = sys.argv[1]
+ output_path = sys.argv[2]
+ generate_image(prompt, output_path)
diff --git a/services/neuralai_service.py b/services/neuralai_service.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e1ed8d40837aa9938a34b30d577b0b6b0ce1fa2
--- /dev/null
+++ b/services/neuralai_service.py
@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+"""
+NeuralAI Unified Service
+- Model inference (port 7001)
+- Tools execution (port 7002)
+- All in one process, shared memory
+"""
+
+import os
+import sys
+import json
+import torch
+import subprocess
+import tempfile
+import asyncio
+from pathlib import Path
+from datetime import datetime
+from flask import Flask, Response, jsonify, request
+from typing import Dict, Any
+
+# CPU optimization
+torch.set_num_threads(4)
+
+# Configuration
+PORT = int(os.environ.get("NEURAL_PORT", "7001"))
+MODEL_PATH = os.environ.get("MODEL_PATH", "/home/workspace/Projects/NeuralAI/checkpoints/v2_model")
+BASE_MODEL = os.environ.get("BASE_MODEL", "HuggingFaceTB/SmolLM2-360M-Instruct")
+STORAGE_PATH = os.environ.get("STORAGE_PATH", "/home/workspace/NeuralAI")
+
+app = Flask(__name__)
+
+# Shared state
+model = None
+tokenizer = None
+model_status = "loading"
+inference_count = 0
+
+# ====================
+# MODEL LOADING
+# ====================
+
+def load_model():
+ """Load model once on startup."""
+ global model, tokenizer, model_status
+
+ print(f"[NeuralAI] Loading model from {MODEL_PATH}")
+
+ try:
+ from transformers import AutoModelForCausalLM, AutoTokenizer
+ from peft import PeftModel
+
+ tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
+ tokenizer.pad_token = tokenizer.eos_token
+
+ adapter_path = Path(MODEL_PATH)
+ adapter_bin = adapter_path / "adapter_model.bin"
+ adapter_safetensors = adapter_path / "adapter_model.safetensors"
+
+ if adapter_path.exists() and (adapter_bin.exists() or adapter_safetensors.exists()):
+ print(f"[NeuralAI] Loading with LoRA adapter...")
+ base = AutoModelForCausalLM.from_pretrained(
+ BASE_MODEL,
+ torch_dtype=torch.float32,
+ device_map=None,
+ low_cpu_mem_usage=True
+ )
+ model = PeftModel.from_pretrained(base, str(adapter_path))
+ else:
+ print(f"[NeuralAI] Loading base model...")
+ model = AutoModelForCausalLM.from_pretrained(
+ BASE_MODEL,
+ torch_dtype=torch.float32,
+ device_map=None,
+ low_cpu_mem_usage=True
+ )
+
+ model.eval()
+ model_status = "ready"
+ print(f"[NeuralAI] ✓ Model ready! Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+ except Exception as e:
+ import traceback
+ model_status = "error"
+ print(f"[NeuralAI] ✗ Failed: {e}")
+ traceback.print_exc()
+
+
+# ====================
+# MODEL ENDPOINTS
+# ====================
+
+@app.route("/health", methods=["GET"])
+def health():
+ return jsonify({
+ "status": model_status,
+ "inference_count": inference_count,
+ "model": BASE_MODEL,
+ "storage": STORAGE_PATH,
+ "images": f"{STORAGE_PATH}/images",
+ "port": PORT
+ })
+
+
+@app.route("/status", methods=["GET"])
+def status():
+ return jsonify({
+ "status": model_status,
+ "model_loaded": model is not None,
+ "tokenizer_loaded": tokenizer is not None,
+ "inference_count": inference_count,
+ "model_path": MODEL_PATH,
+ "storage": STORAGE_PATH
+ })
+
+
+@app.route("/generate", methods=["POST"])
+def generate():
+ """Generate text (non-streaming)."""
+ global inference_count
+
+ if model is None or tokenizer is None:
+ return jsonify({"error": "Model not loaded"}), 503
+
+ try:
+ data = request.get_json()
+ prompt = data.get("prompt", data.get("message", ""))
+ max_tokens = data.get("max_tokens", 256)
+ temperature = data.get("temperature", 0.7)
+
+ if not prompt:
+ return jsonify({"error": "No prompt provided"}), 400
+
+ full_prompt = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+ inputs = tokenizer(full_prompt, return_tensors="pt")
+
+ with torch.no_grad():
+ outputs = model.generate(
+ **inputs,
+ max_new_tokens=max_tokens,
+ do_sample=True,
+ temperature=temperature,
+ top_p=0.95,
+ pad_token_id=tokenizer.eos_token_id
+ )
+
+ new_tokens = outputs[0][inputs["input_ids"].shape[-1]:]
+ response = tokenizer.decode(new_tokens, skip_special_tokens=True)
+
+ inference_count += 1
+ return jsonify({"response": response, "tokens": len(new_tokens)})
+
+ except Exception as e:
+ return jsonify({"error": str(e)}), 500
+
+
+@app.route("/generate/stream", methods=["POST"])
+def generate_stream():
+ """Generate text with streaming."""
+ global inference_count
+
+ if model is None or tokenizer is None:
+ return jsonify({"error": "Model not loaded"}), 503
+
+ try:
+ from transformers import TextIteratorStreamer
+ import threading
+
+ data = request.get_json()
+ prompt = data.get("prompt", data.get("message", ""))
+ max_tokens = data.get("max_tokens", 256)
+ temperature = data.get("temperature", 0.7)
+
+ full_prompt = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+ inputs = tokenizer(full_prompt, return_tensors="pt")
+
+ streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+
+ thread = threading.Thread(target=model.generate, kwargs=dict(
+ **inputs,
+ streamer=streamer,
+ max_new_tokens=max_tokens,
+ do_sample=True,
+ temperature=temperature,
+ top_p=0.95,
+ pad_token_id=tokenizer.eos_token_id
+ ))
+ thread.start()
+
+ def generate():
+ for token in streamer:
+ yield f"data: {json.dumps({'token': token})}\n\n"
+ yield "data: [DONE]\n\n"
+
+ inference_count += 1
+ return Response(generate(), mimetype="text/event-stream",
+ headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})
+
+ except Exception as e:
+ return jsonify({"error": str(e)}), 500
+
+
+# ====================
+# TOOLS ENDPOINTS
+# ====================
+
+@app.route("/execute/code", methods=["POST"])
+def execute_code():
+ """Execute code in sandbox."""
+ data = request.get_json()
+ code = data.get("code", "")
+ language = data.get("language", "python")
+ timeout = data.get("timeout", 30)
+
+ import time
+ start = time.time()
+
+ suffix = ".py" if language == "python" else ".js"
+ with tempfile.NamedTemporaryFile(mode='w', suffix=suffix, delete=False, encoding='utf-8') as f:
+ f.write(code)
+ temp_path = f.name
+
+ try:
+ if language == "python":
+ result = subprocess.run(['python3', temp_path], capture_output=True, text=True, timeout=timeout)
+ else:
+ result = subprocess.run(['node', temp_path], capture_output=True, text=True, timeout=timeout)
+
+ return jsonify({
+ "success": result.returncode == 0,
+ "output": result.stdout[:10000],
+ "error": result.stderr[:10000] if result.returncode != 0 else "",
+ "exit_code": result.returncode,
+ "execution_time": time.time() - start
+ })
+ except subprocess.TimeoutExpired:
+ return jsonify({"success": False, "error": f"Timeout after {timeout}s", "exit_code": -1})
+ except Exception as e:
+ return jsonify({"success": False, "error": str(e), "exit_code": -1})
+ finally:
+ try:
+ os.unlink(temp_path)
+ except:
+ pass
+
+
+@app.route("/execute/shell", methods=["POST"])
+def execute_shell():
+ """Execute shell command."""
+ data = request.get_json()
+ command = data.get("command", "")
+ timeout = data.get("timeout", 30)
+
+ import time
+ start = time.time()
+
+ try:
+ result = subprocess.run(['bash', '-c', command], capture_output=True, text=True, timeout=timeout)
+ return jsonify({
+ "success": result.returncode == 0,
+ "output": result.stdout[:10000],
+ "error": result.stderr[:10000] if result.returncode != 0 else "",
+ "exit_code": result.returncode,
+ "execution_time": time.time() - start
+ })
+ except subprocess.TimeoutExpired:
+ return jsonify({"success": False, "error": f"Timeout after {timeout}s", "exit_code": -1})
+ except Exception as e:
+ return jsonify({"success": False, "error": str(e), "exit_code": -1})
+
+
+@app.route("/generate/image", methods=["POST"])
+def generate_image():
+ """Generate placeholder image."""
+ data = request.get_json()
+ prompt = data.get("prompt", "concept")
+
+ try:
+ from PIL import Image, ImageDraw, ImageFont
+
+ # Create image directory
+ image_dir = Path(STORAGE_PATH) / "images"
+ image_dir.mkdir(parents=True, exist_ok=True)
+
+ # Generate filename
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ filename = f"generated_{timestamp}.jpg"
+ filepath = image_dir / filename
+
+ # Create image
+ img = Image.new('RGB', (512, 512), color=(20, 25, 45))
+ draw = ImageDraw.Draw(img)
+
+ # Add gradient
+ for i in range(512):
+ draw.line([(0, i), (512, i)], fill=(20 + i//10, 25 + i//15, 45 + i//20))
+
+ # Add sun/moon for sky themes
+ if any(w in prompt.lower() for w in ['sun', 'moon', 'sky', 'sunset', 'sunrise', 'night']):
+ draw.ellipse([200, 80, 312, 192], fill=(255, 200, 100) if 'sun' in prompt.lower() else (220, 220, 240))
+
+ # Add mountains for landscape themes
+ if any(w in prompt.lower() for w in ['mountain', 'landscape', 'hill', 'valley']):
+ draw.polygon([(0, 380), (150, 280), (300, 350), (512, 300), (512, 512), (0, 512)],
+ fill=(30, 25, 50))
+
+ # Add text
+ text = prompt[:40] + "..." if len(prompt) > 40 else prompt
+ draw.text((20, 460), f"Concept: {text}", fill=(180, 180, 200))
+ draw.text((20, 485), "Generated by NeuralAI", fill=(100, 100, 120))
+
+ img.save(filepath, quality=85)
+
+ return jsonify({
+ "success": True,
+ "image_path": str(filepath),
+ "image_url": f"/images/{filename}",
+ "prompt": prompt,
+ "placeholder": True
+ })
+
+ except Exception as e:
+ return jsonify({"success": False, "error": str(e)})
+
+
+@app.route("/files/list", methods=["GET"])
+def files_list():
+ """List files in storage."""
+ directory = request.args.get("directory", "")
+ try:
+ base = Path(STORAGE_PATH)
+ target = base / directory if directory else base
+
+ if not target.exists():
+ return jsonify({"success": False, "error": "Not found"})
+
+ files = []
+ for item in target.iterdir():
+ files.append({
+ "name": item.name,
+ "type": "directory" if item.is_dir() else "file",
+ "size": item.stat().st_size if item.is_file() else 0
+ })
+
+ return jsonify({"success": True, "files": files, "path": str(target)})
+ except Exception as e:
+ return jsonify({"success": False, "error": str(e)})
+
+
+# Load model on startup
+print(f"[NeuralAI] Starting unified service on port {PORT}")
+load_model()
+
+
+if __name__ == "__main__":
+ app.run(host="0.0.0.0", port=PORT, debug=False, threaded=True)
diff --git a/services/nextcloud/AUTHORS b/services/nextcloud/AUTHORS
new file mode 100644
index 0000000000000000000000000000000000000000..fe478401fddb41a2fb90c274952310ceecb90704
--- /dev/null
+++ b/services/nextcloud/AUTHORS
@@ -0,0 +1,640 @@
+
+# Authors
+
+ - AW-UC
+ - Aaron Ball
+ - Aaron Wood
+ - Abijeet
+ - Adam Blakey
+ - Adam Williamson
+ - Administrator "Administrator@WINDOWS-2012"
+ - Adrian Brzezinski
+ - Akhil
+ - Akhil
+ - Akhil Potukuchi
+ - Alan Meeson
+ - Aldo "xoen" Giambelluca
+ - Alecks Gates
+ - Alejandro Varela
+ - Alexander A. Klimov
+ - Alexandre Salomé
+ - Alex Harpin
+ - Alex Weirig
+ - Alexander Bergolth
+ - Alexander F <32201363+alx-tuilmenau@users.noreply.github.com>
+ - Allan Nordhøy
+ - Anderson Luiz Alves
+ - Andreas Fischer
+ - Andreas Pflug
+ - Andrew Brown
+ - Andrey Borysenko
+ - André Gaul
+ - Andy Xheli
+ - Anna Larch
+ - Anna Larch
+ - Anupam Kumar
+ - ArcticFall <23174635+ArcticFall@users.noreply.github.com>
+ - Ardinis
+ - Ari Selseng
+ - Arne Hamann
+ - Arne Hamann
+ - Artem Kochnev
+ - Artem Sidorenko
+ - Arthur Schiwon
+ - Artur Neumann
+ - Artur Neumann
+ - Ashod Nakashian
+ - Asier Iturralde Sarasola
+ - Axel Helmert
+ - Azul
+ - Bart Visscher
+ - Bartek Przybylski
+ - Bastien Durel
+ - Bastien Ho
+ - Benjamin Diele
+ - Benjamin Gaussorgues
+ - Benjamin Liles
+ - Bennet Becker
+ - Bennet Becker
+ - Bernard Spil
+ - Bernd Rederlechner
+ - Bernd Stellwag
+ - Bernhard Ostertag
+ - Bernhard Posselt
+ - Bernhard Reiter
+ - Bill McGonigle
+ - Daniel Niccoli
+ - Bjoern Schiessle
+ - Björn Schießle
+ - Bjørn Forsman
+ - Blaok
+ - Boris Rybalkin
+ - Borjan Tchakaloff
+ - Brad Rubenstein
+ - Brandon Kirsch
+ - Branko Kokanovic
+ - Brice Maron
+ - Byron Marohn
+ - CRA Yoshihito Nakatani
+ - Carl Csaposs
+ - Carl Schwan
+ - Carla Schroder
+ - Carlos Cerrillo
+ - Carlos Ferreira
+ - Carsten Wiedmann
+ - Chih-Hsuan Yen
+ - Christian <16852529+cviereck@users.noreply.github.com>
+ - Christian Berendt
+ - Christian Jürges
+ - Christian Kampka
+ - Christian Oliff
+ - Christian Weiske
+ - Christoph Schaefer "christophł@wolkesicher.de"
+ - Christoph Seitz
+ - Christoph Wickert
+ - Christoph Wurst
+ - Christopher Bartz
+ - Christopher Ng
+ - Christopher Schäpers
+ - Christopher T. Johnson
+ - Clark Tomlinson
+ - Claas Augner
+ - Claus-Justus Heine
+ - Clement Wong
+ - Cornelius Kölbel
+ - Cthulhux
+ - Cyrille Bollu
+ - Cédric Neukom
+ - Côme Chilliet <91878298+come-nc@users.noreply.github.com>
+ - Côme Chilliet
+ - Damjan Georgievski
+ - Dan Callahan
+ - Daniel
+ - Daniel Calviño Sánchez