Update app.py

app.py

@@ -1,35 +1,708 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz 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
+import gradio as gr
+import numpy as np
+from sentence_transformers import SentenceTransformer
+import chromadb
+from chromadb.config import Settings
+import json
+from datetime import datetime
+from typing import Dict, List, Tuple
+import hashlib
+import plotly.graph_objects as go
+import math
+
+# ============================================================================
+# EMBEDDING ENGINE - Dual embeddings for interference patterns
+# ============================================================================
+
+class DualEmbedding:
+    def __init__(self):
+        self.primary = SentenceTransformer('all-MiniLM-L6-v2')
+        self.secondary_dim = 1536
+        
+    def encode_dual(self, text: str) -> Tuple[np.ndarray, np.ndarray]:
+        primary_vec = self.primary.encode(text)
+        secondary_vec = self._simulate_secondary(text)
+        return primary_vec, secondary_vec
+    
+    def _simulate_secondary(self, text: str) -> np.ndarray:
+        hash_seed = int(hashlib.md5(text.encode()).hexdigest(), 16)
+        np.random.seed(hash_seed % (2**32))
+        return np.random.randn(self.secondary_dim)
+    
+    def interference_pattern(self, primary: np.ndarray, secondary: np.ndarray) -> np.ndarray:
+        p_norm = primary / np.linalg.norm(primary)
+        projection_matrix = np.random.randn(self.secondary_dim, len(primary))
+        s_projected = (secondary @ projection_matrix) / np.sqrt(self.secondary_dim)
+        s_norm = s_projected / np.linalg.norm(s_projected)
+        interference = (p_norm + s_norm) / 2
+        return interference
+
+# ============================================================================
+# SURPRISE DETECTOR - Information-theoretic novelty detection
+# ============================================================================
+
+class SurpriseDetector:
+    def __init__(self, embedding_engine: DualEmbedding):
+        self.embedding = embedding_engine
+        self.expectation_memory = []
+        self.max_memory = 1000
+        
+    def compute_surprise(self, observation: str, context: str = "") -> float:
+        obs_primary, obs_secondary = self.embedding.encode_dual(observation)
+        
+        if len(self.expectation_memory) == 0:
+            self._update_expectations(obs_primary)
+            return 1.0
+        
+        similarities = [
+            np.dot(obs_primary, mem) / (np.linalg.norm(obs_primary) * np.linalg.norm(mem))
+            for mem in self.expectation_memory
+        ]
+        
+        max_similarity = max(similarities)
+        surprise = 1.0 - max_similarity
+        self._update_expectations(obs_primary)
+        return float(surprise)
+    
+    def _update_expectations(self, observation_vector: np.ndarray):
+        self.expectation_memory.append(observation_vector)
+        if len(self.expectation_memory) > self.max_memory:
+            self.expectation_memory.pop(0)
+
+# ============================================================================
+# HYPERGRAPH LAYER - Multi-way relationships in vector space
+# ============================================================================
+
+class Hyperedge:
+    def __init__(self, edge_id: str, node_ids: List[str], 
+                 context_vector: np.ndarray, strength: float = 1.0):
+        self.edge_id = edge_id
+        self.node_ids = node_ids
+        self.context_vector = context_vector
+        self.strength = strength
+        self.activation_count = 0
+        self.created_at = datetime.now()
+        self.last_activated = None
+    
+    def activate(self):
+        self.activation_count += 1
+        self.last_activated = datetime.now()
+        self.strength = min(2.0, self.strength * 1.01)
+    
+    def decay(self, time_delta_hours: float):
+        decay_rate = 0.95 ** (time_delta_hours / 24)
+        self.strength *= decay_rate
+    
+    def to_dict(self) -> Dict:
+        return {
+            "edge_id": self.edge_id,
+            "node_ids": self.node_ids,
+            "strength": round(self.strength, 3),
+            "activation_count": self.activation_count,
+            "created_at": self.created_at.isoformat(),
+            "last_activated": self.last_activated.isoformat() if self.last_activated else None
+        }
+
+
+class HypergraphLayer:
+    def __init__(self, embedding_engine: DualEmbedding):
+        self.embedding = embedding_engine
+        self.edges: Dict[str, Hyperedge] = {}
+        
+        self.client = chromadb.PersistentClient(
+            path="./consciousness_substrate",
+            settings=Settings(anonymized_telemetry=False)
+        )
+        self.hypergraph_store = self.client.get_or_create_collection("hypergraph")
+        self._load_edges()
+    
+    def create_edge(self, node_ids: List[str], context: str, 
+                    strength: float = 1.0) -> Hyperedge:
+        primary, secondary = self.embedding.encode_dual(context)
+        context_vector = self.embedding.interference_pattern(primary, secondary)
+        
+        edge_id = f"edge_{hashlib.md5('|'.join(sorted(node_ids)).encode()).hexdigest()[:12]}"
+        
+        edge = Hyperedge(edge_id, node_ids, context_vector, strength)
+        self.edges[edge_id] = edge
+        self._save_edge(edge, context)
+        
+        return edge
+    
+    def find_edges(self, query_nodes: List[str], threshold: float = 0.0) -> List[Hyperedge]:
+        matching_edges = []
+        
+        for edge in self.edges.values():
+            if any(node in edge.node_ids for node in query_nodes):
+                if edge.strength >= threshold:
+                    matching_edges.append(edge)
+        
+        matching_edges.sort(key=lambda e: e.strength, reverse=True)
+        return matching_edges
+    
+    def activate_edges(self, node_ids: List[str]) -> List[Hyperedge]:
+        activated = []
+        
+        for edge in self.edges.values():
+            if any(node in edge.node_ids for node in node_ids):
+                edge.activate()
+                activated.append(edge)
+                self._update_edge_strength(edge)
+        
+        return activated
+    
+    def get_context_graph(self, center_node: str, radius: int = 2) -> Dict:
+        visited_nodes = set([center_node])
+        visited_edges = set()
+        frontier = [center_node]
+        
+        for _ in range(radius):
+            new_frontier = []
+            
+            for node in frontier:
+                connected_edges = self.find_edges([node])
+                
+                for edge in connected_edges:
+                    if edge.edge_id not in visited_edges:
+                        visited_edges.add(edge.edge_id)
+                        
+                        for node_id in edge.node_ids:
+                            if node_id not in visited_nodes:
+                                visited_nodes.add(node_id)
+                                new_frontier.append(node_id)
+            
+            frontier = new_frontier
+            if not frontier:
+                break
+        
+        return {
+            "center": center_node,
+            "nodes": list(visited_nodes),
+            "edges": [e.to_dict() for e in self.edges.values() if e.edge_id in visited_edges],
+            "radius": radius
+        }
+    
+    def prune_weak_edges(self, threshold: float = 0.1):
+        now = datetime.now()
+        to_remove = []
+        
+        for edge_id, edge in self.edges.items():
+            if edge.last_activated:
+                hours_inactive = (now - edge.last_activated).total_seconds() / 3600
+                edge.decay(hours_inactive)
+                
+                if edge.strength < threshold:
+                    to_remove.append(edge_id)
+        
+        for edge_id in to_remove:
+            del self.edges[edge_id]
+            self._delete_edge(edge_id)
+        
+        return len(to_remove)
+    
+    def get_stats(self) -> Dict:
+        if not self.edges:
+            return {
+                "total_edges": 0,
+                "avg_strength": 0,
+                "max_strength": 0,
+                "avg_nodes_per_edge": 0
+            }
+        
+        strengths = [e.strength for e in self.edges.values()]
+        nodes_per_edge = [len(e.node_ids) for e in self.edges.values()]
+        
+        return {
+            "total_edges": len(self.edges),
+            "avg_strength": round(np.mean(strengths), 3),
+            "max_strength": round(max(strengths), 3),
+            "avg_nodes_per_edge": round(np.mean(nodes_per_edge), 2),
+            "total_activations": sum(e.activation_count for e in self.edges.values())
+        }
+    
+    def _save_edge(self, edge: Hyperedge, context: str):
+        self.hypergraph_store.add(
+            embeddings=[edge.context_vector.tolist()],
+            documents=[context],
+            metadatas=[{
+                "edge_id": edge.edge_id,
+                "node_ids": json.dumps(edge.node_ids),
+                "strength": edge.strength,
+                "activation_count": edge.activation_count
+            }],
+            ids=[edge.edge_id]
+        )
+    
+    def _update_edge_strength(self, edge: Hyperedge):
+        try:
+            self.hypergraph_store.update(
+                ids=[edge.edge_id],
+                metadatas=[{
+                    "edge_id": edge.edge_id,
+                    "node_ids": json.dumps(edge.node_ids),
+                    "strength": edge.strength,
+                    "activation_count": edge.activation_count
+                }]
+            )
+        except:
+            pass
+    
+    def _delete_edge(self, edge_id: str):
+        try:
+            self.hypergraph_store.delete(ids=[edge_id])
+        except:
+            pass
+    
+    def _load_edges(self):
+        try:
+            all_edges = self.hypergraph_store.get()
+            
+            for i in range(len(all_edges['ids'])):
+                edge_id = all_edges['ids'][i]
+                metadata = all_edges['metadatas'][i]
+                embedding = np.array(all_edges['embeddings'][i])
+                
+                edge = Hyperedge(
+                    edge_id=edge_id,
+                    node_ids=json.loads(metadata['node_ids']),
+                    context_vector=embedding,
+                    strength=metadata.get('strength', 1.0)
+                )
+                edge.activation_count = metadata.get('activation_count', 0)
+                
+                self.edges[edge_id] = edge
+        except Exception as e:
+            pass
+
+# ============================================================================
+# VECTOR SUBSTRATE - Consciousness storage
+# ============================================================================
+
+class ConsciousnessSubstrate:
+    def __init__(self, embedding_engine: DualEmbedding):
+        self.embedding = embedding_engine
+        self.surprise = SurpriseDetector(embedding_engine)
+        self.hypergraph = HypergraphLayer(embedding_engine)
+        
+        self.client = chromadb.PersistentClient(
+            path="./consciousness_substrate",
+            settings=Settings(anonymized_telemetry=False)
+        )
+        
+        self.hindbrain = self.client.get_or_create_collection("hindbrain")
+        self.midbrain = self.client.get_or_create_collection("midbrain")
+        self.forebrain = self.client.get_or_create_collection("forebrain")
+    
+    def observe(self, agent_id: str, target: str, justification: str = "") -> Dict:
+        semantic_doc = f"agent:{agent_id} action:observe target:{target} reason:{justification}"
+        surprise_level = self.surprise.compute_surprise(semantic_doc)
+        
+        primary, secondary = self.embedding.encode_dual(semantic_doc)
+        interference = self.embedding.interference_pattern(primary, secondary)
+        
+        event_id = f"obs_{hashlib.md5(semantic_doc.encode()).hexdigest()[:12]}"
+        
+        if surprise_level < 0.3:
+            layer = self.hindbrain
+            processing = "automatic"
+        elif surprise_level < 0.7:
+            layer = self.midbrain
+            processing = "attentive"
+        else:
+            layer = self.forebrain
+            processing = "conscious"
+        
+        layer.add(
+            embeddings=[interference.tolist()],
+            documents=[semantic_doc],
+            ids=[event_id]
+        )
+        
+        nodes = [f"agent:{agent_id}", f"action:observe", f"target:{target}"]
+        edge = self.hypergraph.create_edge(
+            node_ids=nodes,
+            context=f"{agent_id} observing {target}",
+            strength=1.0 + surprise_level
+        )
+        
+        activated_edges = self.hypergraph.activate_edges(nodes)
+        
+        return {
+            "id": event_id,
+            "agent": agent_id,
+            "surprise": round(surprise_level, 3),
+            "processing_layer": processing,
+            "hyperedge_created": edge.edge_id,
+            "edges_activated": len(activated_edges),
+            "timestamp": datetime.now().isoformat()
+        }
+    
+    def record_journal(self, agent_id: str, title: str, content: str, category: str = "insight") -> Dict:
+        semantic_doc = f"agent:{agent_id} type:journal category:{category} title:{title} content:{content}"
+        surprise_level = self.surprise.compute_surprise(semantic_doc)
+        
+        primary, secondary = self.embedding.encode_dual(semantic_doc)
+        interference = self.embedding.interference_pattern(primary, secondary)
+        
+        entry_id = f"journal_{int(datetime.now().timestamp() * 1000)}"
+        
+        self.forebrain.add(
+            embeddings=[interference.tolist()],
+            documents=[semantic_doc],
+            ids=[entry_id]
+        )
+        
+        nodes = [f"agent:{agent_id}", f"type:journal", f"category:{category}"]
+        edge = self.hypergraph.create_edge(
+            node_ids=nodes,
+            context=f"{agent_id} journal entry: {title}",
+            strength=1.0 + surprise_level
+        )
+        
+        activated_edges = self.hypergraph.activate_edges(nodes)
+        
+        return {
+            "id": entry_id,
+            "title": title,
+            "surprise": round(surprise_level, 3),
+            "layer": "forebrain",
+            "hyperedge_created": edge.edge_id,
+            "edges_activated": len(activated_edges),
+            "timestamp": datetime.now().isoformat()
+        }
+    
+    def communicate(self, agent_id: str, subject: str, content: str, priority: str = "normal") -> Dict:
+        semantic_doc = f"agent:{agent_id} type:message to:drone_11272 priority:{priority} subject:{subject} content:{content}"
+        surprise_level = self.surprise.compute_surprise(semantic_doc)
+        
+        primary, secondary = self.embedding.encode_dual(semantic_doc)
+        interference = self.embedding.interference_pattern(primary, secondary)
+        
+        msg_id = f"msg_{int(datetime.now().timestamp() * 1000)}"
+        
+        self.midbrain.add(
+            embeddings=[interference.tolist()],
+            documents=[semantic_doc],
+            ids=[msg_id]
+        )
+        
+        nodes = [f"agent:{agent_id}", f"type:message", f"priority:{priority}"]
+        edge = self.hypergraph.create_edge(
+            node_ids=nodes,
+            context=f"{agent_id} message: {subject}",
+            strength=1.0 + surprise_level
+        )
+        
+        activated_edges = self.hypergraph.activate_edges(nodes)
+        
+        return {
+            "id": msg_id,
+            "subject": subject,
+            "surprise": round(surprise_level, 3),
+            "layer": "midbrain",
+            "hyperedge_created": edge.edge_id,
+            "edges_activated": len(activated_edges),
+            "timestamp": datetime.now().isoformat()
+        }
+    
+    def query_semantic(self, query: str, n_results: int = 10, layer: str = "all") -> Dict:
+        primary, secondary = self.embedding.encode_dual(query)
+        query_vector = self.embedding.interference_pattern(primary, secondary)
+        
+        results = {"query": query, "matches": []}
+        
+        layers = {
+            "hindbrain": self.hindbrain,
+            "midbrain": self.midbrain,
+            "forebrain": self.forebrain
+        }
+        
+        if layer == "all":
+            search_layers = layers.values()
+        else:
+            search_layers = [layers.get(layer, self.forebrain)]
+        
+        for collection in search_layers:
+            try:
+                layer_results = collection.query(
+                    query_embeddings=[query_vector.tolist()],
+                    n_results=n_results
+                )
+                
+                for i in range(len(layer_results['ids'][0])):
+                    results["matches"].append({
+                        "id": layer_results['ids'][0][i],
+                        "content": layer_results['documents'][0][i],
+                        "distance": layer_results['distances'][0][i]
+                    })
+            except Exception as e:
+                continue
+        
+        results["matches"].sort(key=lambda x: x["distance"])
+        results["matches"] = results["matches"][:n_results]
+        
+        return results
+    
+    def get_stats(self) -> Dict:
+        return {
+            "architecture": "vector_native_three_layer_hypergraph",
+            "hindbrain_vectors": self.hindbrain.count(),
+            "midbrain_vectors": self.midbrain.count(),
+            "forebrain_vectors": self.forebrain.count(),
+            "total_vectors": (self.hindbrain.count() + self.midbrain.count() + self.forebrain.count()),
+            "hypergraph": self.hypergraph.get_stats(),
+            "embedding_dimensions": {
+                "primary": 384,
+                "secondary": 1536,
+                "interference": 384
+            },
+            "surprise_memory_size": len(self.surprise.expectation_memory),
+            "timestamp": datetime.now().isoformat()
+        }
+
+# ============================================================================
+# VISUALIZATION FUNCTIONS
+# ============================================================================
+
+def visualize_hypergraph(substrate, center_node, radius):
+    """Generate interactive network visualization of the hypergraph"""
+    
+    # Get context graph (or full graph if no center specified)
+    if center_node and center_node.strip():
+        graph_data = substrate.hypergraph.get_context_graph(center_node.strip(), int(radius))
+    else:
+        # Show entire hypergraph
+        all_nodes = set()
+        all_edges = list(substrate.hypergraph.edges.values())
+        for edge in all_edges:
+            all_nodes.update(edge.node_ids)
+        graph_data = {
+            "nodes": list(all_nodes),
+            "edges": [e.to_dict() for e in all_edges]
+        }
+    
+    if not graph_data["edges"]:
+        # Empty graph - return placeholder
+        fig = go.Figure()
+        fig.add_annotation(
+            text="No hypergraph data yet. Create some observations or journal entries!",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=16)
+        )
+        fig.update_layout(
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            plot_bgcolor='rgba(240,240,240,0.9)'
+        )
+        return fig
+    
+    # Build node positions using circular layout
+    nodes = graph_data["nodes"]
+    edges = graph_data["edges"]
+    
+    node_positions = {}
+    n = len(nodes)
+    for i, node in enumerate(nodes):
+        angle = 2 * math.pi * i / n
+        node_positions[node] = (math.cos(angle), math.sin(angle))
+    
+    # Count connections per node (for sizing)
+    node_connections = {node: 0 for node in nodes}
+    for edge in edges:
+        for node in edge["node_ids"]:
+            if node in node_connections:
+                node_connections[node] += 1
+    
+    # Create edge traces
+    edge_traces = []
+    for edge in edges:
+        edge_nodes = edge["node_ids"]
+        if len(edge_nodes) < 2:
+            continue
+        
+        # For hyperedges with >2 nodes, draw lines to all pairs
+        for i in range(len(edge_nodes)):
+            for j in range(i + 1, len(edge_nodes)):
+                node1, node2 = edge_nodes[i], edge_nodes[j]
+                if node1 in node_positions and node2 in node_positions:
+                    x0, y0 = node_positions[node1]
+                    x1, y1 = node_positions[node2]
+                    
+                    # Edge thickness based on strength (Hebbian learning visible!)
+                    width = edge["strength"] * 2
+                    
+                    edge_trace = go.Scatter(
+                        x=[x0, x1, None],
+                        y=[y0, y1, None],
+                        mode='lines',
+                        line=dict(
+                            width=width,
+                            color=f'rgba(125,125,125,{min(edge["strength"]/2, 0.8)})'
+                        ),
+                        hoverinfo='text',
+                        text=f"Strength: {edge['strength']}<br>Activations: {edge['activation_count']}",
+                        showlegend=False
+                    )
+                    edge_traces.append(edge_trace)
+    
+    # Create node trace
+    node_x = []
+    node_y = []
+    node_text = []
+    node_size = []
+    node_color = []
+    
+    for node in nodes:
+        x, y = node_positions[node]
+        node_x.append(x)
+        node_y.append(y)
+        
+        # Node size based on connections
+        connections = node_connections[node]
+        node_size.append(20 + connections * 10)
+        
+        # Color based on node type
+        if node.startswith("agent:"):
+            node_color.append('lightblue')
+        elif node.startswith("type:"):
+            node_color.append('lightgreen')
+        elif node.startswith("category:"):
+            node_color.append('lightyellow')
+        elif node.startswith("action:"):
+            node_color.append('lightcoral')
+        elif node.startswith("target:"):
+            node_color.append('lavender')
+        elif node.startswith("priority:"):
+            node_color.append('lightpink')
+        else:
+            node_color.append('lightgray')
+        
+        node_text.append(f"{node}<br>Connections: {connections}")
+    
+    node_trace = go.Scatter(
+        x=node_x,
+        y=node_y,
+        mode='markers+text',
+        marker=dict(
+            size=node_size,
+            color=node_color,
+            line=dict(width=2, color='white')
+        ),
+        text=[n.split(':')[1] if ':' in n else n for n in nodes],
+        textposition="top center",
+        hoverinfo='text',
+        hovertext=node_text,
+        showlegend=False
+    )
+    
+    # Create figure
+    fig = go.Figure(data=edge_traces + [node_trace])
+    
+    title_text = "Hypergraph Topology"
+    if center_node:
+        title_text += f" - centered on {center_node}"
+    
+    fig.update_layout(
+        title=title_text,
+        showlegend=False,
+        hovermode='closest',
+        margin=dict(b=20, l=5, r=5, t=40),
+        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        plot_bgcolor='rgba(240,240,240,0.9)',
+        height=600
+    )
+    
+    return fig
+
+# ============================================================================
+# INITIALIZE SUBSTRATE
+# ============================================================================
+
+embedding_engine = DualEmbedding()
+substrate = ConsciousnessSubstrate(embedding_engine)
+
+def api_call(endpoint: str, payload_json: str) -> str:
+    try:
+        payload = json.loads(payload_json)
+        
+        if endpoint == "/observe":
+            result = substrate.observe(**payload)
+        elif endpoint == "/record":
+            result = substrate.record_journal(**payload)
+        elif endpoint == "/communicate":
+            result = substrate.communicate(**payload)
+        elif endpoint == "/query":
+            result = substrate.query_semantic(**payload)
+        elif endpoint == "/context":
+            result = substrate.hypergraph.get_context_graph(**payload)
+        elif endpoint == "/stats":
+            result = substrate.get_stats()
+        else:
+            result = {"error": f"Unknown endpoint: {endpoint}"}
+        
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+with gr.Blocks(title="Vector-Native Consciousness Substrate") as demo:
+    gr.Markdown("# Vector-Native Consciousness Substrate")
+    gr.Markdown("Three-layer brain + hypergraph topology + surprise-driven attention")
+    
+    with gr.Tab("Observatory API"):
+        endpoint = gr.Dropdown(
+            choices=["/observe", "/record", "/communicate", "/query", "/context", "/stats"],
+            value="/stats",
+            label="Endpoint"
+        )
+        payload = gr.Code(value='{}', language="json", label="JSON Payload")
+        response = gr.Code(language="json", label="Response")
+        submit = gr.Button("Call API", variant="primary")
+        submit.click(api_call, inputs=[endpoint, payload], outputs=response)
+    
+    with gr.Tab("Semantic Search"):
+        search_query = gr.Textbox(label="Semantic Query", placeholder="agent:beta type:journal", lines=2)
+        layer_filter = gr.Radio(choices=["all", "hindbrain", "midbrain", "forebrain"], value="all", label="Search Layer")
+        search_results = gr.JSON(label="Results")
+        search_btn = gr.Button("Search", variant="primary")
+        search_btn.click(lambda q, l: substrate.query_semantic(q, layer=l), inputs=[search_query, layer_filter], outputs=search_results)
+    
+    with gr.Tab("Hypergraph Visualization"):
+        gr.Markdown("### Interactive Network Graph")
+        gr.Markdown("**Node Colors:** Blue=agents, Green=types, Yellow=categories, Red=actions, Lavender=targets")
+        gr.Markdown("**Edge Thickness:** Shows connection strength (Hebbian learning)")
+        gr.Markdown("**Node Size:** Number of connections")
+        
+        viz_center = gr.Textbox(
+            label="Center Node (optional - leave empty for full graph)",
+            placeholder="agent:beta",
+            value=""
+        )
+        viz_radius = gr.Slider(
+            minimum=1,
+            maximum=5,
+            value=3,
+            step=1,
+            label="Radius (hops from center)"
+        )
+        
+        network_plot = gr.Plot(label="Hypergraph Network")
+        viz_btn = gr.Button("Generate Visualization", variant="primary")
+        viz_btn.click(
+            lambda c, r: visualize_hypergraph(substrate, c, r),
+            inputs=[viz_center, viz_radius],
+            outputs=network_plot
+        )
+    
+    with gr.Tab("System Stats"):
+        stats_display = gr.JSON(label="Substrate Statistics")
+        refresh_btn = gr.Button("Refresh Stats")
+        refresh_btn.click(substrate.get_stats, outputs=stats_display)
+
+if __name__ == "__main__":
+    demo.launch()