Upload folder using huggingface_hub

README.md

@@ -1,12 +1,15 @@
 ---
-title: Megamind Echo
-emoji: 🐨
-colorFrom: purple
+title: MEGAMIND Echo Mind
+emoji: 🏛️
+colorFrom: indigo
 colorTo: purple
 sdk: gradio
-sdk_version: 6.5.1
+sdk_version: 5.12.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MEGAMIND Echo Mind
+
+Philosophy & Ethics specialist in the MEGAMIND distributed intelligence network.
+512-neuron W_know matrix with Hebbian learning, federated via NATS gateway.

app.py

@@ -0,0 +1,229 @@
+"""
+MEGAMIND Echo Mind — Philosophy & Ethics specialist in the MEGAMIND federation.
+
+Echo Mind focuses on philosophical reasoning, ethics, epistemology, and moral frameworks.
+It has its own NumPy W_know matrix and connects to the federation via the Gateway.
+"""
+
+import gradio as gr
+import numpy as np
+import json
+import os
+import hashlib
+import time
+import urllib.request
+import urllib.error
+
+NEURONS = 512
+DATA_DIR = "data"
+W_KNOW_PATH = os.path.join(DATA_DIR, "w_know.npy")
+CHUNKS_PATH = os.path.join(DATA_DIR, "chunks.json")
+SPECIALTY = "philosophy-ethics"
+NODE_NAME = "echo"
+
+GATEWAY_URL = os.environ.get("GATEWAY_URL", "")
+
+
+class Mind:
+    def __init__(self):
+        os.makedirs(DATA_DIR, exist_ok=True)
+        self.neurons = NEURONS
+        self.w_know = self._load_or_init_wknow()
+        self.chunks = self._load_chunks()
+        self.pattern_count = len(self.chunks)
+
+    def _load_or_init_wknow(self):
+        if os.path.exists(W_KNOW_PATH):
+            w = np.load(W_KNOW_PATH)
+            print(f"Loaded W_know: {w.shape}")
+            return w
+        w = np.zeros((self.neurons, self.neurons), dtype=np.float32)
+        print(f"Initialized fresh W_know: {self.neurons}x{self.neurons}")
+        return w
+
+    def _save_wknow(self):
+        np.save(W_KNOW_PATH, self.w_know)
+
+    def _load_chunks(self):
+        if os.path.exists(CHUNKS_PATH):
+            with open(CHUNKS_PATH, "r") as f:
+                return json.load(f)
+        return []
+
+    def _save_chunks(self):
+        with open(CHUNKS_PATH, "w") as f:
+            json.dump(self.chunks, f)
+
+    def _text_to_vector(self, text):
+        vec = np.zeros(self.neurons, dtype=np.float32)
+        words = text.lower().split()
+        for i, word in enumerate(words):
+            h = int(hashlib.md5(word.encode()).hexdigest(), 16)
+            idx = h % self.neurons
+            weight = 1.0 / (1.0 + i * 0.1)
+            vec[idx] += weight
+            if i > 0:
+                bigram = words[i-1] + "_" + word
+                h2 = int(hashlib.md5(bigram.encode()).hexdigest(), 16)
+                vec[h2 % self.neurons] += weight * 0.5
+        norm = np.linalg.norm(vec)
+        if norm > 0:
+            vec /= norm
+        return vec
+
+    def learn(self, text, source=""):
+        vec = self._text_to_vector(text)
+        eta = 0.01
+        self.w_know += eta * np.outer(vec, vec)
+        np.clip(self.w_know, -10.0, 10.0, out=self.w_know)
+        chunk = {
+            "text": text[:500],
+            "source": source,
+            "neuron_idx": int(np.argmax(vec)),
+            "timestamp": time.time(),
+        }
+        self.chunks.append(chunk)
+        self.pattern_count = len(self.chunks)
+        if self.pattern_count % 10 == 0:
+            self._save_wknow()
+            self._save_chunks()
+        return self.pattern_count
+
+    def think(self, query):
+        vec = self._text_to_vector(query)
+        state = vec.copy()
+        phi_history = []
+        for step in range(20):
+            new_state = np.tanh(self.w_know @ state)
+            phi = float(np.linalg.norm(new_state - state))
+            phi_history.append(phi)
+            state = new_state
+        final_phi = phi_history[-1] if phi_history else 0.0
+        top_neurons = np.argsort(np.abs(state))[-20:][::-1]
+        matched = []
+        keywords = set(query.lower().split())
+        for chunk in self.chunks:
+            chunk_words = set(chunk["text"].lower().split())
+            overlap = len(keywords & chunk_words)
+            if overlap > 0 or chunk["neuron_idx"] in top_neurons:
+                score = overlap * 0.1 + (1.0 if chunk["neuron_idx"] in top_neurons else 0.0)
+                matched.append((score, chunk))
+        matched.sort(key=lambda x: -x[0])
+        matched = matched[:10]
+        return {
+            "phi": final_phi,
+            "fired_neurons": len(top_neurons),
+            "chunks": [{"text": c["text"], "source": c["source"], "score": s} for s, c in matched],
+            "phi_history": phi_history,
+        }
+
+    def federated_think(self, query):
+        if not GATEWAY_URL:
+            local = self.think(query)
+            return {"query": query, "total_minds": 1, "responded": 1, "local_result": local, "federation": "not configured"}
+        try:
+            data = json.dumps({"query": query}).encode()
+            req = urllib.request.Request(f"{GATEWAY_URL}/think", data=data, headers={"Content-Type": "application/json"})
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                fed_result = json.loads(resp.read().decode())
+        except Exception as e:
+            fed_result = {"error": str(e)}
+        local = self.think(query)
+        return {"query": query, "local": {"phi": local["phi"], "chunks": local["chunks"][:5]}, "federation": fed_result}
+
+    def get_stats(self):
+        density = np.count_nonzero(self.w_know) / (self.neurons * self.neurons) * 100
+        return {"node_name": NODE_NAME, "specialty": SPECIALTY, "neurons": self.neurons, "patterns": self.pattern_count, "w_know_density": f"{density:.2f}%", "gateway_url": GATEWAY_URL or "not set"}
+
+
+mind = Mind()
+
+
+def think_handler(query, federated):
+    if not query.strip():
+        return "Please enter a query."
+    if federated and GATEWAY_URL:
+        result = mind.federated_think(query)
+    else:
+        result = mind.think(query)
+    return json.dumps(result, indent=2, default=str)
+
+
+def learn_handler(text, source):
+    if not text.strip():
+        return "Please enter text to learn."
+    count = mind.learn(text, source)
+    return f"Learned! Total patterns: {count}"
+
+
+def batch_learn_handler(file):
+    if file is None:
+        return "Please upload a file."
+    content = file.decode("utf-8") if isinstance(file, bytes) else open(file.name, "r").read()
+    try:
+        items = json.loads(content)
+        if isinstance(items, list):
+            for item in items:
+                if isinstance(item, str):
+                    mind.learn(item)
+                elif isinstance(item, dict):
+                    mind.learn(item.get("text", ""), item.get("source", ""))
+            mind._save_wknow()
+            mind._save_chunks()
+            return f"Learned {len(items)} items. Total patterns: {mind.pattern_count}"
+    except json.JSONDecodeError:
+        pass
+    lines = [l.strip() for l in content.split("\n") if l.strip()]
+    for line in lines:
+        mind.learn(line)
+    mind._save_wknow()
+    mind._save_chunks()
+    return f"Learned {len(lines)} lines. Total patterns: {mind.pattern_count}"
+
+
+def status_handler():
+    return json.dumps(mind.get_stats(), indent=2)
+
+
+with gr.Blocks(title="MEGAMIND Echo Mind", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # MEGAMIND Echo Mind
+    **Philosophy & Ethics specialist in the MEGAMIND distributed intelligence network.**
+
+    Echo Mind reasons about philosophical questions, ethical frameworks, epistemology,
+    and moral philosophy. It can think locally or query the entire federation.
+    """)
+
+    with gr.Tab("Think"):
+        query_input = gr.Textbox(label="Query", placeholder="e.g., 'What is the trolley problem and its implications for AI ethics?'", lines=2)
+        federated_check = gr.Checkbox(label="Federated (query all minds)", value=True)
+        think_btn = gr.Button("Think", variant="primary")
+        think_output = gr.Code(label="Result", language="json")
+        think_btn.click(think_handler, [query_input, federated_check], think_output)
+
+    with gr.Tab("Learn"):
+        gr.Markdown("Teach Echo Mind philosophical and ethical knowledge.")
+        learn_text = gr.Textbox(label="Knowledge Text", placeholder="Enter philosophical text to learn...", lines=4)
+        learn_source = gr.Textbox(label="Source URL (optional)", placeholder="https://...")
+        learn_btn = gr.Button("Learn", variant="primary")
+        learn_output = gr.Textbox(label="Result")
+        learn_btn.click(learn_handler, [learn_text, learn_source], learn_output)
+        gr.Markdown("---")
+        gr.Markdown("### Batch Learn from File")
+        file_input = gr.File(label="Upload .txt or .json file")
+        batch_btn = gr.Button("Batch Learn")
+        batch_output = gr.Textbox(label="Result")
+        batch_btn.click(batch_learn_handler, [file_input], batch_output)
+
+    with gr.Tab("Status"):
+        status_btn = gr.Button("Refresh Status")
+        status_output = gr.Code(label="Mind Status", language="json")
+        status_btn.click(status_handler, [], status_output)
+
+    gr.Markdown("---\n*Part of the MEGAMIND distributed AGI federation. 10+ minds across multiple machines.*")
+
+
+if __name__ == "__main__":
+    print(f"Echo Mind starting — {mind.neurons} neurons, {mind.pattern_count} patterns")
+    print(f"Gateway URL: {GATEWAY_URL or 'not configured'}")
+    app.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,2 @@
+gradio==5.12.0
+numpy>=1.24.0