Upload 11 files

.env.example

@@ -0,0 +1,31 @@
+# JARVIS environment configuration
+# Copy this to .env and fill in your values.
+# On HuggingFace Spaces: set these in Settings → Variables & Secrets instead.
+
+# --- Model selection ---
+JARVIS_MODEL=microsoft/Phi-3-mini-4k-instruct
+# Alternatively for deeper reasoning (still fits 16GB with 4-bit):
+# JARVIS_MODEL=mistralai/Mistral-7B-Instruct-v0.2
+
+# --- Quantisation (reduces RAM dramatically) ---
+JARVIS_QUANT=4bit
+# Options: 4bit | 8bit | none
+
+# --- Memory paths ---
+# Leave blank to use ./data/memory (relative, HF-safe)
+JARVIS_MEMORY_DIR=
+JARVIS_DB_PATH=
+
+# --- Voice ---
+JARVIS_TTS_VOICE=en-US-GuyNeural
+# Other voice options: en-US-JennyNeural, en-GB-RyanNeural
+
+# --- Whisper STT (only used if you add mic input) ---
+JARVIS_WHISPER_MODEL=base
+
+# --- Thinking engine ---
+JARVIS_THINKING=true
+JARVIS_THINK_INTERVAL=3600
+
+# --- Gradio server ---
+PORT=7860

.gitignore

@@ -0,0 +1,10 @@
+# .gitignore for JARVIS HuggingFace Space
+__pycache__/
+*.pyc
+*.pyo
+.env
+data/
+*.db
+*.log
+.DS_Store
+Thumbs.db

README.md

@@ -0,0 +1,106 @@
+---
+title: JARVIS - Personal AI Agent
+emoji: 🤖
+colorFrom: blue
+colorTo: gray
+sdk: gradio
+sdk_version: "4.26.0"
+app_file: app.py
+pinned: true
+license: mit
+tags:
+  - conversational
+  - personal-assistant
+  - llm
+  - phi-3
+  - jarvis
+  - voice
+  - memory
+  - agentic
+hardware: cpu-upgrade
+---
+
+# J.A.R.V.I.S — Just A Rather Very Intelligent System
+
+> *"Sometimes you gotta run before you can walk."*
+
+Your personal AI assistant — conversational, voice-enabled, and memory-powered. Runs locally on a HuggingFace Space with **16 GB RAM** and no GPU required (thanks to 4-bit quantisation).
+
+---
+
+## ✨ Features
+
+| Feature | Detail |
+|---|---|
+| 🧠 **Local LLM** | Microsoft Phi-3-mini-4k-instruct (3.8B params, 4-bit ≈ 2-4 GB RAM) |
+| 💬 **Chat interface** | Clean Gradio UI — type or use voice |
+| 🎙️ **Voice replies** | Edge-TTS (Microsoft GuyNeural, no GPU, minimal cloud) |
+| 🗂️ **Persistent memory** | SQLite facts + conversation history |
+| 💡 **Thinking engine** | Background anticipation — JARVIS predicts your needs |
+| 🔧 **Commands** | `status` · `remember X is Y` · `anticipate` |
+
+---
+
+## 🚀 Quick Start (local)
+
+```bash
+git clone https://huggingface.co/spaces/<your-username>/jarvis
+cd jarvis
+pip install -r requirements.txt
+python app.py
+```
+
+Open `http://localhost:7860` in your browser.
+
+---
+
+## ⚙️ Environment Variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `JARVIS_MODEL` | `microsoft/Phi-3-mini-4k-instruct` | HuggingFace model ID |
+| `JARVIS_QUANT` | `4bit` | Quantisation: `4bit` / `8bit` / `none` |
+| `JARVIS_MEMORY_DIR` | `./data/memory` | Where SQLite DB is stored |
+| `JARVIS_TTS_VOICE` | `en-US-GuyNeural` | Edge-TTS voice name |
+| `JARVIS_THINKING` | `true` | Enable background thinking engine |
+
+Set in HuggingFace Space **Settings → Variables & Secrets** or in a `.env` file locally.
+
+---
+
+## 💾 RAM Requirements
+
+| Model | Quant | RAM |
+|---|---|---|
+| Phi-3-mini-4k-instruct (3.8B) | 4-bit | ~3–4 GB |
+| Phi-3-mini-4k-instruct (3.8B) | fp16 | ~7.6 GB |
+| Mistral-7B-Instruct-v0.2 | 4-bit | ~4–5 GB |
+| Mistral-7B-Instruct-v0.2 | fp16 | ~14 GB |
+
+**Recommended for 16 GB RAM:** Phi-3-mini 4-bit (fast) or Mistral-7B 4-bit (deeper reasoning).
+
+---
+
+## 🗂️ Project Structure
+
+```
+app.py          — Gradio UI + entry point
+brain.py        — HuggingFace model inference (lazy-loaded)
+memory.py       — SQLite facts + conversation history
+thinking.py     — Background anticipation engine
+voice_tts.py    — Edge-TTS text-to-speech
+config.py       — All settings via env vars
+requirements.txt
+README.md       — This file (HuggingFace model card)
+```
+
+---
+
+## 🤝 Credits
+
+Built on top of:
+- [Microsoft Phi-3](https://huggingface.co/microsoft/Phi-3-mini-4k-instruct)
+- [HuggingFace Transformers](https://github.com/huggingface/transformers)
+- [Gradio](https://gradio.app)
+- [Edge-TTS](https://github.com/rany2/edge-tts)
+- Original JARVIS project — OpenJarvis architecture inspiration

UPLOAD_GUIDE.txt

@@ -0,0 +1,139 @@
+══════════════════════════════════════════════════════════════
+  JARVIS → HUGGINGFACE UPLOAD GUIDE
+  16 GB RAM · Local inference · No GPU required
+══════════════════════════════════════════════════════════════
+
+WHAT'S IN THIS FOLDER (hf_jarvis/)
+────────────────────────────────────────────────────────────
+  app.py          → Gradio UI (entry point for HF Spaces)
+  brain.py        → HuggingFace Transformers inference engine
+  memory.py       → SQLite memory (facts + conversation history)
+  thinking.py     → Background anticipation engine
+  voice_tts.py    → Edge-TTS voice output
+  config.py       → All settings via environment variables
+  requirements.txt→ All pip packages needed
+  README.md       → HuggingFace model card (auto-displayed)
+  .env.example    → Local dev environment template
+  .gitignore      → Keeps your DB and secrets out of git
+
+════════════════════════════════════════════════════════════
+STEP 1: CREATE A HUGGINGFACE ACCOUNT / LOG IN
+════════════════════════════════════════════════════════════
+  Go to: https://huggingface.co
+  Sign up (free) or log in.
+
+════════════════════════════════════════════════════════════
+STEP 2: CREATE A NEW SPACE
+════════════════════════════════════════════════════════════
+  1. Click your profile icon → New Space
+  2. Space name:    jarvis          (or any name you like)
+  3. License:       MIT
+  4. SDK:           Gradio          ← IMPORTANT: select Gradio
+  5. Hardware:      CPU (upgraded)  ← free tier is fine for 3.8B 4-bit
+     For Mistral-7B choose "CPU upgrade" or "A10G small" if available
+  6. Visibility:   Private (or Public — your choice)
+  7. Click: Create Space
+
+════════════════════════════════════════════════════════════
+STEP 3: UPLOAD FILES
+════════════════════════════════════════════════════════════
+  METHOD A — Drag-and-drop in browser (easiest)
+  ──────────────────────────────────────────────
+  1. Open your Space page → click "Files" tab
+  2. Click "Add file" → "Upload files"
+  3. Select ALL files from this folder:
+       app.py
+       brain.py
+       memory.py
+       thinking.py
+       voice_tts.py
+       config.py
+       requirements.txt
+       README.md
+       .env.example
+       .gitignore
+  4. Click "Commit changes to main"
+  5. HuggingFace will install requirements.txt and launch app.py
+     automatically. Wait ~2-5 minutes for the build to finish.
+
+  METHOD B — Git push (recommended for updates)
+  ───────────────────────────────────────────────
+  Run in PowerShell from the hf_jarvis\ folder:
+
+    git init
+    git remote add origin https://huggingface.co/spaces/<YOUR_USERNAME>/jarvis
+    git add .
+    git commit -m "Initial JARVIS upload"
+    git push origin main
+
+  (You may need: git lfs install  if you ever add large model files)
+
+════════════════════════════════════════════════════════════
+STEP 4: SET ENVIRONMENT VARIABLES (optional but recommended)
+════════════════════════════════════════════════════════════
+  In your Space page → Settings tab → Variables & Secrets
+
+  Add these if you want to customize:
+    JARVIS_MODEL  = microsoft/Phi-3-mini-4k-instruct  (default)
+    JARVIS_QUANT  = 4bit                              (default)
+    JARVIS_THINKING = true
+
+  Leave blank to use the safe defaults already in config.py.
+
+════════════════════════════════════════════════════════════
+STEP 5: WAIT FOR BUILD & OPEN JARVIS
+════════════════════════════════════════════════════════════
+  HuggingFace will show build logs. When it says "Running",
+  your JARVIS is live at:
+
+    https://huggingface.co/spaces/<YOUR_USERNAME>/jarvis
+
+  First response takes ~30-90 seconds (model loading).
+  Every subsequent message is fast.
+
+════════════════════════════════════════════════════════════
+WHAT JARVIS CAN DO ON HUGGINGFACE
+════════════════════════════════════════════════════════════
+  ✅ Chat with 3.8B / 7B local model — no external API costs
+  ✅ Voice replies (Edge-TTS, Microsoft GuyNeural voice)
+  ✅ Remember facts: type "remember name is Tony"
+  ✅ Check status: type "status"
+  ✅ See predictions: type "anticipate"
+  ✅ Persistent memory across sessions (SQLite DB, local to the Space)
+  ✅ Runs on 16 GB RAM — Phi-3-mini 4-bit uses only ≈3-4 GB
+
+════════════════════════════════════════════════════════════
+RAM & MODEL OPTIONS
+════════════════════════════════════════════════════════════
+  Your 16 GB gives you a LOT of headroom:
+
+  Model                              │ Quant │ RAM used
+  ───────────────────────────────────┼───────┼──────────
+  Phi-3-mini-4k-instruct (3.8B)     │ 4-bit │ ~3-4 GB  ← default (fast)
+  Phi-3-mini-4k-instruct (3.8B)     │ fp16  │ ~7.6 GB
+  Mistral-7B-Instruct-v0.2 (7B)     │ 4-bit │ ~4-5 GB  ← deep reasoning
+  Mistral-7B-Instruct-v0.2 (7B)     │ fp16  │ ~14 GB   ← max quality
+
+  To switch: set JARVIS_MODEL in Space Settings.
+
+════════════════════════════════════════════════════════════
+TROUBLESHOOTING
+════════════════════════════════════════════════════════════
+  "Model loading..." forever
+    → First load downloads from HF Hub. Wait 3-5 minutes.
+      The model (~2-7 GB) downloads once and is cached.
+
+  "bitsandbytes not available"
+    → 4-bit quant needs a recent version. Set JARVIS_QUANT=none
+      if bitsandbytes fails (fp32, uses more RAM but works).
+
+  Out of memory
+    → Set JARVIS_QUANT=4bit (default) to reduce RAM to ~3-4 GB.
+
+  Voice not working
+    → edge-tts needs internet. On fully offline HF Spaces,
+      TTS falls back silently to text-only — chat still works.
+
+══════════════════════════════════════════════════════════════
+  SIR — YOUR JARVIS IS READY FOR THE WORLD
+══════════════════════════════════════════════════════════════

app.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+JARVIS — HuggingFace Space App
+Gradio chat interface for JARVIS personal AI assistant.
+Runs entirely locally on HuggingFace Spaces (CPU or GPU) with 16 GB RAM.
+
+Launch:  python app.py
+Or via HuggingFace Spaces (auto-detected from README.md sdk: gradio).
+"""
+
+import os
+import io
+import json
+import threading
+import gradio as gr
+
+# ── Init subsystems ──────────────────────────────────────────────────────────
+import memory
+import thinking
+import brain
+
+memory.init_db()
+thinking.start_thinking_engine()
+
+# Warm-up model in background so UI loads instantly
+_warmup_thread = brain.warmup()
+
+# ── TTS helper ────────────────────────────────────────────────────────────────
+def _speak(text: str):
+    """Return audio bytes for Gradio Audio component, or None."""
+    try:
+        from voice_tts import tts_bytes
+        return tts_bytes(text)
+    except Exception:
+        return None
+
+
+# ── Core chat logic ────────────────────────────────────────────────────────────
+def chat(user_message: str, history: list[list[str]], audio_reply: bool):
+    """
+    Main chat handler — called by Gradio.
+    history: [[user_msg, bot_msg], ...]
+    Returns: (updated_history, status_text, audio_or_None)
+    """
+    if not user_message.strip():
+        return history, "Say something, sir.", None
+
+    lower = user_message.lower().strip()
+
+    # ── Built-in commands ──────────────────────────────────────────────────
+    if lower in ("status", "jarvis status"):
+        facts = memory.get_all_facts()
+        reply = (
+            f"Status: Online. "
+            f"Memory: {len(facts)} facts. "
+            f"Model: {brain.HF_MODEL}. "
+            f"TTS: {'ON' if audio_reply else 'OFF'}."
+        )
+        history.append([user_message, reply])
+        audio = _speak(reply) if audio_reply else None
+        return history, "Ready.", audio
+
+    if lower in ("anticipate", "what are you thinking"):
+        ants = thinking.get_anticipations()
+        reply = "Thinking ahead: " + (", ".join(ants[:3]) if ants else "No predictions yet.")
+        history.append([user_message, reply])
+        audio = _speak(reply) if audio_reply else None
+        return history, "Ready.", audio
+
+    if lower.startswith("remember ") and " is " in lower:
+        try:
+            part = user_message[9:]  # strip "remember "
+            key, val = part.split(" is ", 1)
+            memory.save_fact(key.strip().lower().replace(" ", "_"), val.strip())
+            reply = f"Remembered: {key.strip()} is {val.strip()}."
+        except Exception as e:
+            reply = f"Couldn't remember that: {e}"
+        history.append([user_message, reply])
+        audio = _speak(reply) if audio_reply else None
+        return history, "Memory updated.", audio
+
+    # ── Normal brain query ─────────────────────────────────────────────────
+    hist_flat = [
+        {"role": "user",   "message": pair[0]}
+        for pair in history
+        if pair[0]
+    ] + [
+        {"role": "jarvis", "message": pair[1]}
+        for pair in history
+        if len(pair) > 1 and pair[1]
+    ]
+    # interleave properly
+    hist_pairs = []
+    for pair in history:
+        if pair[0]:
+            hist_pairs.append({"role": "user",   "message": pair[0]})
+        if len(pair) > 1 and pair[1]:
+            hist_pairs.append({"role": "jarvis", "message": pair[1]})
+
+    reply = brain.ask(user_message, hist_pairs)
+    history.append([user_message, reply])
+    audio = _speak(reply) if audio_reply else None
+    return history, "Ready.", audio
+
+
+def remember_fact(key: str, value: str):
+    """Directly save a fact via the sidebar form."""
+    if not key.strip() or not value.strip():
+        return "Please fill in both fields."
+    memory.save_fact(key.strip().lower().replace(" ", "_"), value.strip())
+    return f"Saved: {key.strip()} = {value.strip()}"
+
+
+def load_facts():
+    facts = memory.get_all_facts()
+    if not facts:
+        return "No facts stored yet."
+    return "\n".join(f"**{k}**: {v}" for k, v in facts.items())
+
+
+def load_anticipations():
+    ants = thinking.get_anticipations()
+    if not ants:
+        return "No predictions yet. JARVIS thinks every hour."
+    return "\n".join(f"• {a}" for a in ants[:5])
+
+
+# ── Build Gradio UI ──────────────────────────────────────────────────────���─────
+def build_ui() -> gr.Blocks:
+    css = """
+    #jarvis-header { text-align: center; margin-bottom: 8px; }
+    #jarvis-header h1 { font-size: 2.4em; font-weight: 800; letter-spacing: 2px; }
+    #jarvis-header p  { color: #888; margin-top: -8px; }
+    .gradio-container { max-width: 900px !important; margin: auto; }
+    """
+
+    with gr.Blocks(title="JARVIS – Personal AI", css=css, theme=gr.themes.Soft()) as demo:
+
+        # ── Header ──────────────────────────────────────────────────────────
+        with gr.Row(elem_id="jarvis-header"):
+            gr.HTML(
+                "<h1>🤖 J.A.R.V.I.S</h1>"
+                "<p>Just A Rather Very Intelligent System — Your Personal AI Agent</p>"
+                "<p style='font-size:0.8em;color:#555'>"
+                f"Powered by: <code>{brain.HF_MODEL}</code> · 16 GB RAM optimised · Local inference"
+                "</p>"
+            )
+
+        with gr.Row():
+            # ── Main chat column ─────────────────────────────────────────────
+            with gr.Column(scale=3):
+                chatbot = gr.Chatbot(
+                    label="JARVIS",
+                    height=480,
+                    avatar_images=(
+                        None,  # user avatar
+                        "https://upload.wikimedia.org/wikipedia/en/thumb/6/68/Iron_Man_in_Marvel_Cinematic_Universe.jpg/250px-Iron_Man_in_Marvel_Cinematic_Universe.jpg",
+                    ),
+                    bubble_full_width=False,
+                )
+                with gr.Row():
+                    msg_box = gr.Textbox(
+                        placeholder="Talk to JARVIS... (try: 'status', 'remember name is Tony', or any question)",
+                        show_label=False,
+                        scale=5,
+                        container=False,
+                    )
+                    send_btn = gr.Button("Send", variant="primary", scale=1)
+
+                audio_out  = gr.Audio(label="JARVIS Voice", autoplay=True, visible=True)
+                audio_on   = gr.Checkbox(label="Voice replies (TTS)", value=True)
+                status_bar = gr.Textbox(label="Status", value="Ready.", interactive=False)
+
+            # ── Sidebar ──────────────────────────────────────────────────────
+            with gr.Column(scale=1):
+                gr.Markdown("### 📂 Memory")
+                with gr.Group():
+                    fact_key = gr.Textbox(placeholder="fact key (e.g. name)", label="Key", lines=1)
+                    fact_val = gr.Textbox(placeholder="value", label="Value", lines=1)
+                    save_btn = gr.Button("Save Fact", variant="secondary")
+                    save_status = gr.Textbox(label="", interactive=False, lines=1)
+
+                gr.Markdown("### 🧠 Stored Facts")
+                facts_display = gr.Markdown(value=load_facts, every=15)
+
+                gr.Markdown("### 💡 JARVIS Thinks Ahead")
+                ants_display = gr.Markdown(value=load_anticipations, every=60)
+
+        # ── Events ───────────────────────────────────────────────────────────
+        def handle_submit(user_msg, history, audio_on_val):
+            return chat(user_msg, history, audio_on_val)
+
+        # Send on Enter or button
+        msg_box.submit(
+            handle_submit,
+            inputs=[msg_box, chatbot, audio_on],
+            outputs=[chatbot, status_bar, audio_out],
+        ).then(lambda: "", outputs=msg_box)
+
+        send_btn.click(
+            handle_submit,
+            inputs=[msg_box, chatbot, audio_on],
+            outputs=[chatbot, status_bar, audio_out],
+        ).then(lambda: "", outputs=msg_box)
+
+        # Save fact
+        save_btn.click(
+            remember_fact,
+            inputs=[fact_key, fact_val],
+            outputs=save_status,
+        )
+
+        # Refresh facts panel when a fact is saved
+        save_btn.click(load_facts, outputs=facts_display)
+
+    return demo
+
+
+# ── Entry point ────────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    demo = build_ui()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", 7860)),
+        share=False,          # set True for a public tunnel link
+        show_error=True,
+    )

brain.py

@@ -0,0 +1,161 @@
+# JARVIS Brain — HuggingFace Edition
+# Uses HuggingFace Transformers pipeline for local inference.
+# Designed for 16 GB RAM:
+#   - Phi-3-mini-4k-instruct (3.8B, fp16 ≈ 7.6 GB) — default, fits comfortably
+#   - Mistral-7B-Instruct-v0.2 (7B, 4-bit ≈ 4 GB) — use JARVIS_MODEL env var
+#
+# Set JARVIS_MODEL or JARVIS_QUANT in env or .env to choose a different model.
+
+import os
+import threading
+import memory
+from config import HF_MODEL, QUANT_MODE
+
+_pipe = None
+_lock = threading.Lock()
+_load_error = None
+
+
+def _build_system_prompt() -> str:
+    facts = memory.get_all_facts()
+    facts_str = "\n".join(f"- {k}: {v}" for k, v in facts.items()) or "None yet."
+    return (
+        "You are JARVIS — Just A Rather Very Intelligent System.\n"
+        "You are a loyal, intelligent, and proactive AI assistant.\n"
+        "You are direct, confident, and slightly witty.\n"
+        "You serve only your user.\n\n"
+        f"What you know about your user:\n{facts_str}\n\n"
+        "Guidelines:\n"
+        "- Be concise but helpful\n"
+        "- Answer clearly and confidently\n"
+        "- Remember context across the conversation"
+    )
+
+
+def _load_pipeline():
+    """Load HuggingFace model. Called once at first use (lazy load)."""
+    global _pipe, _load_error
+    if _pipe is not None:
+        return _pipe, None
+    if _load_error is not None:
+        return None, _load_error
+
+    try:
+        from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+        import torch
+
+        print(f"[Brain] Loading model: {HF_MODEL} (quant={QUANT_MODE}) ...")
+
+        kwargs: dict = {
+            "task": "text-generation",
+            "model": HF_MODEL,
+            "device_map": "auto",
+            "trust_remote_code": True,
+        }
+
+        if QUANT_MODE == "4bit":
+            try:
+                from transformers import BitsAndBytesConfig
+                kwargs["model_kwargs"] = {
+                    "quantization_config": BitsAndBytesConfig(
+                        load_in_4bit=True,
+                        bnb_4bit_compute_dtype=torch.float16,
+                        bnb_4bit_use_double_quant=True,
+                    )
+                }
+                print("[Brain] 4-bit quantisation enabled (approx 2-4 GB RAM)")
+            except Exception as e:
+                print(f"[Brain] bitsandbytes not available, loading fp16: {e}")
+                kwargs["torch_dtype"] = torch.float16
+        elif QUANT_MODE == "8bit":
+            try:
+                from transformers import BitsAndBytesConfig
+                kwargs["model_kwargs"] = {
+                    "quantization_config": BitsAndBytesConfig(load_in_8bit=True)
+                }
+            except Exception as e:
+                kwargs["torch_dtype"] = torch.float16
+        else:
+            # CPU-friendly fallback: float32
+            kwargs["torch_dtype"] = torch.float32
+            kwargs.pop("device_map", None)  # use CPU
+
+        _pipe = pipeline(**kwargs)
+        print(f"[Brain] Model ready: {HF_MODEL}")
+        return _pipe, None
+
+    except Exception as e:
+        _load_error = str(e)
+        print(f"[Brain] Failed to load model: {e}")
+        return None, _load_error
+
+
+def ask(query: str, history: list[dict] | None = None) -> str:
+    """
+    Ask JARVIS a question.
+    history: list of {"role": "user"|"jarvis", "message": str}
+    Returns JARVIS's response as a string.
+    """
+    with _lock:
+        pipe, err = _load_pipeline()
+
+    if pipe is None:
+        return f"[Brain unavailable: {err}]"
+
+    # Build messages in chat format
+    messages = [{"role": "system", "content": _build_system_prompt()}]
+
+    if history:
+        for turn in history[-6:]:  # keep last 3 user+jarvis pairs
+            role = "user" if turn.get("role") == "user" else "assistant"
+            messages.append({"role": role, "content": turn.get("message", "")})
+
+    messages.append({"role": "user", "content": query})
+
+    try:
+        # Run generation
+        out = pipe(
+            messages,
+            max_new_tokens=350,
+            temperature=0.7,
+            do_sample=True,
+            pad_token_id=pipe.tokenizer.eos_token_id,
+            return_full_text=False,
+        )
+
+        # Extract generated text
+        if isinstance(out, list) and out:
+            first = out[0]
+            if isinstance(first, dict):
+                # most pipelines return {"generated_text": [{...messages...}]}
+                gen = first.get("generated_text", "")
+                if isinstance(gen, list):
+                    # find the last assistant turn
+                    for turn in reversed(gen):
+                        if isinstance(turn, dict) and turn.get("role") == "assistant":
+                            result = turn.get("content", "").strip()
+                            break
+                    else:
+                        result = str(gen).strip()
+                else:
+                    result = str(gen).strip()
+            else:
+                result = str(first).strip()
+        else:
+            result = str(out).strip()
+
+        # Persist conversation
+        memory.save_message("user", query)
+        memory.save_message("jarvis", result)
+
+        return result if result else "[No response generated]"
+
+    except Exception as e:
+        return f"[Generation error: {e}]"
+
+
+def warmup():
+    """Pre-load model so first user query doesn't feel slow."""
+    thread = threading.Thread(target=_load_pipeline, daemon=True)
+    thread.start()
+    return thread

config.py

@@ -0,0 +1,33 @@
+# JARVIS HuggingFace Configuration
+# All paths driven by environment variables — no hardcoded Windows paths
+
+import os
+
+# ── Paths (env-var driven, HF-friendly) ────────────────────────────────────
+BASE_DIR   = os.path.dirname(os.path.abspath(__file__))
+MEMORY_DIR = os.environ.get("JARVIS_MEMORY_DIR", os.path.join(BASE_DIR, "data", "memory"))
+DB_PATH    = os.environ.get("JARVIS_DB_PATH",    os.path.join(MEMORY_DIR, "jarvis.db"))
+
+# ── Model (HuggingFace) ────────────────────────────────────────────────────
+# For 16 GB RAM: Phi-3 Mini (3.8B, 4-bit) or Mistral-7B (4-bit)
+# phi3:mini fits easily; Mistral-7B-Instruct needs bitsandbytes 4-bit quant
+HF_MODEL   = os.environ.get("JARVIS_MODEL", "microsoft/Phi-3-mini-4k-instruct")
+
+# Quantisation: set "4bit" to load in 4-bit (saves VRAM/RAM; needs bitsandbytes)
+# set "8bit" for 8-bit, leave blank for full-precision (fp16/fp32).
+QUANT_MODE = os.environ.get("JARVIS_QUANT", "4bit")  # 4bit / 8bit / none
+
+# ── Voice ──────────────────────────────────────────────────────────────────
+TTS_VOICE    = os.environ.get("JARVIS_TTS_VOICE", "en-US-GuyNeural")
+WHISPER_MODEL = os.environ.get("JARVIS_WHISPER_MODEL", "base")
+
+# ── Agent identity ──────────────────────────────────────────────────────────
+AGENT_NAME = "JARVIS"
+AGENT_TAGLINE = "Just A Rather Very Intelligent System"
+
+# ── Thinking engine ─────────────────────────────────────────────────────────
+THINKING_ENABLED = os.environ.get("JARVIS_THINKING", "true").lower() == "true"
+THINKING_INTERVAL = int(os.environ.get("JARVIS_THINK_INTERVAL", "3600"))
+
+# ── Memory ──────────────────────────────────────────────────────────────────
+MAX_HISTORY = int(os.environ.get("JARVIS_MAX_HISTORY", "20"))

memory.py

@@ -0,0 +1,101 @@
+# JARVIS Memory System — HuggingFace Edition
+# SQLite3 persistent memory: facts, conversation history, preferences
+# All paths relative / env-var driven — no hardcoded Windows paths
+
+import sqlite3
+import json
+import datetime
+import os
+from config import DB_PATH, MEMORY_DIR
+
+os.makedirs(MEMORY_DIR, exist_ok=True)
+
+
+def _connect():
+    return sqlite3.connect(DB_PATH)
+
+
+def init_db():
+    """Create tables if they don't exist."""
+    with _connect() as conn:
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS conversations (
+                id        INTEGER PRIMARY KEY AUTOINCREMENT,
+                role      TEXT NOT NULL,          -- 'user' or 'jarvis'
+                message   TEXT NOT NULL,
+                timestamp TEXT NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS facts (
+                id        INTEGER PRIMARY KEY AUTOINCREMENT,
+                key       TEXT NOT NULL UNIQUE,   -- e.g. 'user_name'
+                value     TEXT NOT NULL,
+                updated   TEXT NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS preferences (
+                id        INTEGER PRIMARY KEY AUTOINCREMENT,
+                category  TEXT NOT NULL,
+                setting   TEXT NOT NULL,
+                value     TEXT NOT NULL
+            );
+        """)
+    print("[Memory] Database ready.")
+
+
+def save_message(role: str, message: str):
+    """Save a conversation turn."""
+    ts = datetime.datetime.now().isoformat()
+    with _connect() as conn:
+        conn.execute(
+            "INSERT INTO conversations (role, message, timestamp) VALUES (?,?,?)",
+            (role, message, ts)
+        )
+
+
+def get_recent_history(n: int = 10) -> list[dict]:
+    """Return the last n conversation turns."""
+    with _connect() as conn:
+        rows = conn.execute(
+            "SELECT role, message, timestamp FROM conversations ORDER BY id DESC LIMIT ?",
+            (n,)
+        ).fetchall()
+    return [{"role": r[0], "message": r[1], "timestamp": r[2]} for r in reversed(rows)]
+
+
+def save_fact(key: str, value: str):
+    """Save or update a fact about the user."""
+    ts = datetime.datetime.now().isoformat()
+    with _connect() as conn:
+        conn.execute(
+            "INSERT INTO facts (key, value, updated) VALUES (?,?,?) "
+            "ON CONFLICT(key) DO UPDATE SET value=excluded.value, updated=excluded.updated",
+            (key, value, ts)
+        )
+
+
+def get_fact(key: str) -> str | None:
+    """Retrieve a stored fact."""
+    with _connect() as conn:
+        row = conn.execute(
+            "SELECT value FROM facts WHERE key=?", (key,)
+        ).fetchone()
+    return row[0] if row else None
+
+
+def get_all_facts() -> dict:
+    """Return all stored facts as a dict."""
+    with _connect() as conn:
+        rows = conn.execute("SELECT key, value FROM facts").fetchall()
+    return {r[0]: r[1] for r in rows}
+
+
+def search_history(query: str, limit: int = 5) -> list[dict]:
+    """Simple keyword search through conversation history."""
+    with _connect() as conn:
+        rows = conn.execute(
+            "SELECT role, message, timestamp FROM conversations "
+            "WHERE message LIKE ? ORDER BY id DESC LIMIT ?",
+            (f"%{query}%", limit)
+        ).fetchall()
+    return [{"role": r[0], "message": r[1], "timestamp": r[2]} for r in rows]

requirements.txt

@@ -0,0 +1,23 @@
+# Core packages
+gradio>=4.26.0
+transformers>=4.41.0
+accelerate>=0.30.0
+torch>=2.1.0
+
+# 4-bit / 8-bit quantisation (hugely reduces RAM usage on 16 GB)
+bitsandbytes>=0.43.0
+
+# TTS — Microsoft neural voices, works without a GPU
+edge-tts>=6.1.9
+
+# Memory
+# (sqlite3 is built-in — no extra package needed)
+
+# Sentence tokeniser for Phi-3 / Mistral chat templates
+sentencepiece>=0.1.99
+
+# Optional safety filters (HuggingFace Hub recommends these)
+safetensors>=0.4.3
+
+# Protobuf (needed by some tokenisers)
+protobuf>=3.20.0

thinking.py

@@ -0,0 +1,110 @@
+# JARVIS Thinking Engine — HuggingFace Edition
+# Runs periodically in the background to generate anticipations.
+# Paths and intervals are env-var driven.
+
+import threading
+import time
+import json
+import os
+from datetime import datetime
+from config import THINKING_ENABLED, THINKING_INTERVAL, MEMORY_DIR
+import memory
+
+_thinking_thread = None
+_thinking_active = False
+_anticipations: list[str] = []
+
+
+def _get_user_patterns() -> dict:
+    """Summarise what the user talks about most."""
+    history = memory.get_recent_history(100)
+    keywords: dict[str, int] = {}
+    for turn in history:
+        for word in turn["message"].lower().split():
+            if len(word) > 4:
+                keywords[word] = keywords.get(word, 0) + 1
+    top = sorted(keywords.items(), key=lambda x: x[1], reverse=True)[:10]
+    return {
+        "top_keywords": top,
+        "total_interactions": len(history),
+    }
+
+
+def _generate_anticipations() -> list[str]:
+    """Ask the brain what the user might need next."""
+    try:
+        import brain as b
+        patterns = _get_user_patterns()
+        facts    = memory.get_all_facts()
+        prompt   = (
+            f"Given user interests: {', '.join(k for k, _ in patterns['top_keywords'])} "
+            f"and facts: {json.dumps(facts)}, "
+            "predict 3 brief, helpful things JARVIS should proactively offer. "
+            "Reply with one bullet per line."
+        )
+        response = b.ask(prompt)
+        lines = [l.strip("•- ").strip() for l in response.splitlines() if l.strip()]
+        return lines[:3]
+    except Exception as e:
+        return [f"[Thinking error: {e}]"]
+
+
+def _save_thinking_state(anticipations: list[str]):
+    """Persist thinking results to disk."""
+    os.makedirs(MEMORY_DIR, exist_ok=True)
+    path = os.path.join(MEMORY_DIR, "thinking.json")
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump({
+            "timestamp": datetime.now().isoformat(),
+            "anticipations": anticipations,
+            "patterns": _get_user_patterns(),
+        }, f, indent=2)
+
+
+def _thinking_loop():
+    global _thinking_active, _anticipations
+    _thinking_active = True
+    print(f"[Thinking] Started. Cycle: {THINKING_INTERVAL}s")
+    while _thinking_active:
+        try:
+            time.sleep(THINKING_INTERVAL)
+            if not _thinking_active:
+                break
+            print("[Thinking] Generating anticipations...")
+            _anticipations = _generate_anticipations()
+            _save_thinking_state(_anticipations)
+            print(f"[Thinking] {len(_anticipations)} anticipation(s) ready.")
+        except Exception as e:
+            print(f"[Thinking] Error: {e}")
+
+
+def start_thinking_engine():
+    global _thinking_thread, _thinking_active
+    if not THINKING_ENABLED:
+        return
+    if _thinking_thread and _thinking_thread.is_alive():
+        return
+    _thinking_thread = threading.Thread(target=_thinking_loop, daemon=True)
+    _thinking_thread.start()
+
+
+def stop_thinking_engine():
+    global _thinking_active
+    _thinking_active = False
+    if _thinking_thread:
+        _thinking_thread.join(timeout=5)
+
+
+def get_anticipations() -> list[str]:
+    """Return most recent anticipations (from memory on disk or in-process)."""
+    if _anticipations:
+        return _anticipations
+    path = os.path.join(MEMORY_DIR, "thinking.json")
+    if os.path.exists(path):
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return data.get("anticipations", [])
+        except Exception:
+            pass
+    return []

voice_tts.py

@@ -0,0 +1,43 @@
+# JARVIS Voice TTS — HuggingFace Edition
+# Uses edge-tts (Microsoft neural voices, works without a local GPU)
+# Falls back to plain text if edge-tts is unavailable.
+
+import asyncio
+import io
+import os
+from config import TTS_VOICE
+
+try:
+    import edge_tts
+    EDGE_TTS_AVAILABLE = True
+except ImportError:
+    EDGE_TTS_AVAILABLE = False
+
+
+async def _generate_audio_bytes(text: str) -> bytes | None:
+    """Generate TTS audio bytes asynchronously using edge-tts."""
+    if not EDGE_TTS_AVAILABLE:
+        return None
+    try:
+        communicate = edge_tts.Communicate(text=text, voice=TTS_VOICE, rate="+0%")
+        audio = b""
+        async for chunk in communicate.stream():
+            if chunk["type"] == "audio":
+                audio += chunk["data"]
+        return audio if audio else None
+    except Exception as e:
+        print(f"[TTS] Edge-TTS error: {e}")
+        return None
+
+
+def tts_bytes(text: str) -> bytes | None:
+    """Synchronous wrapper — returns MP3 bytes or None."""
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        result = loop.run_until_complete(_generate_audio_bytes(text))
+        loop.close()
+        return result
+    except Exception as e:
+        print(f"[TTS] Error: {e}")
+        return None