#!/usr/bin/env python3
"""
build_compressed_summaries.py
Generates compressed, layered summaries for all raw documents in raw_docs/
"""

import os
import json
import ollama
from pathlib import Path

# Configuration
RAW_FOLDER = "./raw_docs"
OUTPUT_FOLDER = "./summaries"
MODEL = "phi3.5:3.8b"  # or llama3.2:3b

Path(OUTPUT_FOLDER).mkdir(exist_ok=True)

for file_path in Path(RAW_FOLDER).glob("*.*"):
    print(f"Processing: {file_path.name}")

    # Read and truncate to fit context window
    raw_text = file_path.read_text(encoding="utf-8", errors="ignore")[:10000]

    prompt = f"""
You are a Cyberdeck Compiler. Analyze this text.
Define a strict 'stone-set topic' that anchors the entire content.
Then rewrite the core logic into a highly compressed internal language using:
- Topic-anchored semantics
- Layered operators
- Words with deliberate double meanings
Omit anything implied by the topic.

Output strictly as JSON: {{"topic": "...", "compressed": "...", "operators": "..."}}

Raw text:
{raw_text}
"""

    response = ollama.generate(model=MODEL, prompt=prompt)
    try:
        data = json.loads(response['response'])
    except json.JSONDecodeError:
        # Clean markdown wrappers
        cleaned = response['response'].replace("```json", "").replace("```", "").strip()
        data = json.loads(cleaned)

    output_file = Path(OUTPUT_FOLDER) / f"{file_path.stem}_summary.json"
    with open(output_file, "w") as f:
        json.dump(data, f, indent=2)

    print(f"Saved: {output_file}")

#!/usr/bin/env python3
"""
build_knowledge_base.py
Extracts "How-to" Q&A pairs from all raw documents for Tier 1 KB
"""

import os
import json
import ollama
from pathlib import Path

RAW_FOLDER = "./raw_docs"
OUTPUT_FILE = "./knowledge_base/kb.json"
MODEL = "phi3.5:3.8b"

Path("./knowledge_base").mkdir(exist_ok=True)

# Combine all raw texts
all_text = ""
for file_path in Path(RAW_FOLDER).glob("*.*"):
    all_text += file_path.read_text(encoding="utf-8", errors="ignore") + "\n\n"

# Truncate to avoid overflow
all_text = all_text[:15000]

prompt = f"""
Extract all explicit "How to" questions and their exact terminal commands, code fixes,
or step-by-step actions from this technical log.

Output a JSON list: [{{"question": "...", "answer": "..."}}].
Only include pairs that contain a concrete command or code change.
No explanations.

Log:
{all_text}
"""

response = ollama.generate(model=MODEL, prompt=prompt)

try:
    kb_data = json.loads(response['response'])
except json.JSONDecodeError:
    cleaned = response['response'].replace("```json", "").replace("```", "").strip()
    kb_data = json.loads(cleaned)

with open(OUTPUT_FILE, "w") as f:
    json.dump(kb_data, f, indent=2)

print(f"Saved {len(kb_data)} Q&A pairs to {OUTPUT_FILE}")

#!/usr/bin/env python3
"""
build_embedding_index.py
Splits raw texts into chunks and generates embeddings using all-minilm:latest
"""

import json
import numpy as np
from sentence_transformers import SentenceTransformer
from pathlib import Path

RAW_FOLDER = "./raw_docs"
OUTPUT_FILE = "./vector_index/tier3_raw_chunks.json"
EMBED_MODEL = "all-MiniLM-L6-v2"  # Matches all-minilm:latest

Path("./vector_index").mkdir(exist_ok=True)

print("Loading embedding model...")
model = SentenceTransformer(EMBED_MODEL)

chunks = []
ids = []

for file_path in Path(RAW_FOLDER).glob("*.*"):
    text = file_path.read_text(encoding="utf-8", errors="ignore")

    # Chunk: 500 chars, 50-char overlap
    chunk_size = 500
    overlap = 50
    for i in range(0, len(text), chunk_size - overlap):
        chunk = text[i:i + chunk_size]
        if len(chunk) < 50:
            continue
        chunks.append(chunk)
        ids.append(f"{file_path.stem}_{i}")

print(f"Created {len(chunks)} chunks. Generating embeddings...")

embeddings = model.encode(chunks, show_progress_bar=True)
embedding_list = [emb.tolist() for emb in embeddings]

tier3_data = [
    {"id": cid, "text": chunk, "embedding": emb}
    for cid, chunk, emb in zip(ids, chunks, embedding_list)
]

with open(OUTPUT_FILE, "w") as f:
    json.dump(tier3_data, f)

print(f"Saved {len(tier3_data)} chunks to {OUTPUT_FILE}")

#!/usr/bin/env python3
"""
cyberdeck_shell.py
Main RAG router: Tier 1 (KB) → Tier 2 (Compressed) → Tier 3 (Raw)
"""

import json
import numpy as np
import ollama
from sentence_transformers import SentenceTransformer
from pathlib import Path

# Configuration
KB_FILE = "./knowledge_base/kb.json"
SUMMARY_FOLDER = "./summaries"
RAW_INDEX_FILE = "./vector_index/tier3_raw_chunks.json"
GENERATIVE_MODEL = "phi3.5:3.8b"
EMBED_MODEL = "all-MiniLM-L6-v2"

# Load embedding model
print("Loading embedding model...")
embedder = SentenceTransformer(EMBED_MODEL)

# --- Load Tier 1: Knowledge Base ---
print("Loading Tier 1 (KB)...")
with open(KB_FILE, "r") as f:
    kb = json.load(f)

# Pre-compute embeddings for KB questions
kb_questions = [item["question"] for item in kb]
kb_embeddings = embedder.encode(kb_questions).tolist()

# --- Load Tier 2: Compressed Summaries ---
print("Loading Tier 2 (Compressed Summaries)...")
summaries = []
for json_path in Path(SUMMARY_FOLDER).glob("*_summary.json"):
    with open(json_path, "r") as f:
        summaries.append(json.load(f))

# --- Load Tier 3: Raw Chunks with Embeddings ---
print("Loading Tier 3 (Raw Chunks)...")
with open(RAW_INDEX_FILE, "r") as f:
    raw_chunks = json.load(f)

# Convert embeddings back to numpy for fast cosine similarity
raw_embeddings = np.array([chunk["embedding"] for chunk in raw_chunks])
raw_texts = [chunk["text"] for chunk in raw_chunks]

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def query_tier1(query_embedding, threshold=0.85):
    """Tier 1: Deterministic KB lookup"""
    best_score = -1
    best_idx = -1
    for i, emb in enumerate(kb_embeddings):
        score = cosine_similarity(query_embedding, emb)
        if score > best_score:
            best_score = score
            best_idx = i
    if best_score >= threshold:
        return kb[best_idx]["answer"]
    return None

def query_tier2(query):
    """Tier 2: Compressed summary → generate search keys"""
    compressed_text = "\n".join([s.get("compressed", "") for s in summaries])

    prompt = f"""
You are a Search-Key Compiler. Read the compressed system summaries below.
Based on the user query, output ONLY a JSON list of 3–5 concrete search terms
(words, file names, or command fragments) that are likely to appear verbatim
in the raw logs.

Output: {{"keys": ["term1", "term2", ...]}}
Do not add explanations.

Compressed summaries:
{compressed_text}

User query: {query}
"""

    response = ollama.generate(model=GENERATIVE_MODEL, prompt=prompt)
    try:
        data = json.loads(response['response'])
        return data.get("keys", [])
    except:
        cleaned = response['response'].replace("```json", "").replace("```", "").strip()
        data = json.loads(cleaned)
        return data.get("keys", [])

def query_tier3(query_embedding, keys, top_k=5):
    """Tier 3: Retrieve raw chunks by cosine similarity + key filtering"""
    scores = []
    for i, emb in enumerate(raw_embeddings):
        score = cosine_similarity(query_embedding, emb)
        # Boost chunks containing search keys
        text_lower = raw_texts[i].lower()
        key_match = any(k.lower() in text_lower for k in keys)
        if key_match:
            score += 0.1  # slight boost
        scores.append((i, score))

    # Sort by score descending
    scores.sort(key=lambda x: x[1], reverse=True)
    top_indices = [idx for idx, _ in scores[:top_k]]
    return [raw_texts[idx] for idx in top_indices]

def generate_final_answer(query, context_chunks):
    """Generate final answer using the generative model"""
    context = "\n\n---\n\n".join(context_chunks)

    prompt = f"""
You are a Cyberdeck AI assistant. Answer the user query using ONLY the provided raw logs.
If the answer is a command, write it verbatim.
If the logs contain multiple solutions, list the most relevant one first.
Be concise.

Logs:
{context}

Query: {query}
"""

    response = ollama.generate(model=GENERATIVE_MODEL, prompt=prompt)
    return response['response'].strip()

def main():
    print("\n=== CYBERDECK AI KNOWLEDGE SYSTEM ===\n")
    print("Type 'exit' to quit. Type 'reload' to reload knowledge base.\n")

    while True:
        try:
            query = input("\nCyberdeck> ").strip()
            if not query:
                continue
            if query.lower() == "exit":
                break
            if query.lower() == "reload":
                # Reload logic would go here
                print("Reloading knowledge base...")
                continue

            # Embed the query
            query_embedding = embedder.encode(query).tolist()

            # --- Tier 1: Deterministic KB ---
            kb_answer = query_tier1(query_embedding)
            if kb_answer:
                print(f"\n[KB] {kb_answer}")
                continue

            # --- Tier 2: Compressed → Search Keys ---
            print("Generating search keys from compressed summaries...")
            search_keys = query_tier2(query)
            print(f"[KEYS] {search_keys}")

            # --- Tier 3: Raw chunk retrieval ---
            chunks = query_tier3(query_embedding, search_keys, top_k=5)

            # --- Final answer ---
            answer = generate_final_answer(query, chunks)
            print(f"\n[ANSWER]\n{answer}")

        except KeyboardInterrupt:
            print("\nSession terminated.")
            break
        except Exception as e:
            print(f"\n[ERROR] {str(e)}")

if __name__ == "__main__":
    main()

---
title: Cyberdeck-Ai-Project-Summary
converted_from: Cyberdeck-Ai-Project-Summary.md
conversion_date: 2025-10-23
---

---
title: deepseek-chat-2025-06-22T03-49-56-961Z
date: 2025-06-22
tags:
  - Obsidian
  - knowledge_management
  - AI_assistant
concepts:
  - Cyberdeck_AI
  - Beowulf_cluster
  - natural_language_understanding
  - self-learning
  - file_operations
  - command_generation
  - feedback_analysis
meta_tags:
  - [[Artificial Intelligence]]
  - [[Cybersecurity]]
  - [[Knowledge Management]]
meta_keyword: [[Intelligence]]
---

## Summary
This content discusses the development of an AI assistant for a Beowulf cluster, focusing on the Cyberdeck AI project. 
The conversation explores the technical limitations of the system and offers practical solutions to reduce user effort.

---

## Content
Can we continue from a former chat or do I have to start all new

Thought for 13 seconds

Hmm, the user is asking whether we can continue from a previous chat or if they have to start fresh.
Okay, first I need to acknowledge that this is a common concern—users often worry about losing context when interacting 
with AI systems. The user seems slightly anxious about having to repeat information, which is totally understandable.
Looking at how they phrased it—“former chat” suggests they might have had a substantial previous conversation they want 
to reference. The “do I have to start all new” part carries a hint of reluctance, like they're dreading re-explaining things.
Right, so my response should accomplish three things:
First, clearly explain the technical limitation (no memory between sessions) but soften the blow.
Second, offer a practical solution (copy-pasting context) to reduce their effort.
Third, reassure them that I'm still eager to help despite the limitation.
The exclamation marks and emoji in my draft reply might seem excessive, but for this context it feels appropriate—it lightens 
the mood when delivering disappointing news. The “happy to dive back in” phrasing turns the focus toward future collaboration 
rather than the limitation.
I wonder if they're asking because they had a particularly complex previous chat. Maybe I should prompt them to share what 
they want to continue? That's why I ended with an open question—it invites them to restart the conversation efficiently.
 

Great question! **DeepSeek-R1 doesn't have persistent memory between sessions** , so every time you start a new chat (like 
this one), I won't remember our previous conversations unless you remind me or share context from them.

But here’s how we can work around it:

✅ **You can:**  
➜ Copy and paste relevant parts from our previous chat into this one  
➜ Summarize what we were discussing  
➜ Upload a file or document we were working on before  
➜ Give me a quick recap so I can pick up where we left off

❌ **I can't:**  
➜ Automatically recall past chats  
➜ Access your chat history unless you paste it here  
➜ Remember personal details you've shared before

So **no need to start all new** — just give me a little context, and I’m happy to dive back in! 🚀  
What were we working on last time? 😊

Ok. We working an an AI assistant for this little Beowulf Cluster of an Acer and Lenvo Laptop using Linux mint, Raspi5 touchscreen 
and the Enlightment GUI and raspi4 headless with only kodi installed. The theme is Shdowrun so the project name is Cyberdeck AI. 
The Gui once are connected with Barrier and a TV screen is added as a second screens. It is an old hardware set up , or scrap matel 
interface in shadowrun slang I guess. The head is cyberdeck_ai.py running in a python environement and its code sohuld give you an 
idea on what is going on. The system now needs to understand natural language and perfrom file operations over the clusters 
individual computers like showing all music on raspberry4's USB or copy all jpgs from Lenovo420 to iboacer. It also should have 
selflearning capabilities and serve well done information remembering successful tasks. Ideally it should be able to process menuals 
of e.g. linux. GNU nano 2.9.3 cyberdeck_ai.py #!/usr/bin/env python3 # MONOCHROME Cyberdeck Interface (Stable Version) import os 
import sys import logging import platform import socket import subprocess import paramiko import yaml import ollama import readline 
from pathlib import Path from datetime import datetime from cluster_manager import ClusterManager from command_generator import 
.......