neural-memory 0.2.0__tar.gz → 0.4.0__tar.gz

{neural_memory-0.2.0 → neural_memory-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neural-memory
-Version: 0.2.0
+Version: 0.4.0
 Summary: Reflex-based memory system for AI agents - retrieval through activation, not search
 Project-URL: Homepage, https://github.com/nhadaututtheky/neural-memory
 Project-URL: Documentation, https://github.com/nhadaututtheky/neural-memory#readme

{neural_memory-0.2.0 → neural_memory-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "neural-memory"
-version = "0.2.0"
+version = "0.4.0"
 description = "Reflex-based memory system for AI agents - retrieval through activation, not search"
 readme = "README.md"
 license = "MIT"

{neural_memory-0.2.0 → neural_memory-0.4.0}/src/neural_memory/__init__.py

@@ -13,7 +13,7 @@ from neural_memory.core.synapse import Direction, Synapse, SynapseType
 from neural_memory.engine.encoder import EncodingResult, MemoryEncoder
 from neural_memory.engine.retrieval import DepthLevel, ReflexPipeline, RetrievalResult
 
-__version__ = "0.2.0"
+__version__ = "0.4.0"
 
 __all__ = [
     "__version__",

{neural_memory-0.2.0 → neural_memory-0.4.0}/src/neural_memory/cli/main.py

@@ -2768,6 +2768,207 @@ def prompt(
         typer.echo(text)
 
 
+@app.command(name="export")
+def export_brain_cmd(
+    output: Annotated[
+        str, typer.Argument(help="Output file path (e.g., my-brain.json)")
+    ],
+    brain: Annotated[
+        str | None, typer.Option("--brain", "-b", help="Brain to export (default: current)")
+    ] = None,
+) -> None:
+    """Export brain to JSON file for backup or sharing.
+
+    Examples:
+        nmem export backup.json           # Export current brain
+        nmem export work.json -b work     # Export specific brain
+    """
+    from pathlib import Path
+
+    from neural_memory.unified_config import get_config, get_shared_storage
+
+    async def _export() -> None:
+        config = get_config()
+        brain_name = brain or config.current_brain
+        storage = await get_shared_storage(brain_name)
+
+        snapshot = await storage.export_brain(brain_name)
+
+        output_path = Path(output)
+        export_data = {
+            "brain_id": snapshot.brain_id,
+            "brain_name": snapshot.brain_name,
+            "exported_at": snapshot.exported_at.isoformat(),
+            "version": snapshot.version,
+            "neurons": snapshot.neurons,
+            "synapses": snapshot.synapses,
+            "fibers": snapshot.fibers,
+            "config": snapshot.config,
+            "metadata": snapshot.metadata,
+        }
+
+        output_path.write_text(json.dumps(export_data, indent=2, default=str))
+
+        typer.echo(f"Exported brain '{brain_name}' to {output_path}")
+        typer.echo(f"  Neurons: {len(snapshot.neurons)}")
+        typer.echo(f"  Synapses: {len(snapshot.synapses)}")
+        typer.echo(f"  Fibers: {len(snapshot.fibers)}")
+
+    asyncio.run(_export())
+
+
+@app.command(name="import")
+def import_brain_cmd(
+    input_file: Annotated[
+        str, typer.Argument(help="Input file path (e.g., my-brain.json)")
+    ],
+    brain: Annotated[
+        str | None, typer.Option("--brain", "-b", help="Target brain name (default: from file)")
+    ] = None,
+    merge: Annotated[
+        bool, typer.Option("--merge", "-m", help="Merge with existing brain")
+    ] = False,
+) -> None:
+    """Import brain from JSON file.
+
+    Examples:
+        nmem import backup.json           # Import as original brain name
+        nmem import backup.json -b new    # Import as 'new' brain
+        nmem import backup.json --merge   # Merge into existing brain
+    """
+    from pathlib import Path
+
+    from neural_memory.core.brain import BrainSnapshot
+    from neural_memory.unified_config import get_shared_storage
+
+    async def _import() -> None:
+        input_path = Path(input_file)
+        if not input_path.exists():
+            typer.echo(f"Error: File not found: {input_path}", err=True)
+            raise typer.Exit(1)
+
+        data = json.loads(input_path.read_text())
+
+        brain_name = brain or data.get("brain_name", "imported")
+        storage = await get_shared_storage(brain_name)
+
+        snapshot = BrainSnapshot(
+            brain_id=data.get("brain_id", brain_name),
+            brain_name=data["brain_name"],
+            exported_at=datetime.fromisoformat(data["exported_at"]),
+            version=data["version"],
+            neurons=data["neurons"],
+            synapses=data["synapses"],
+            fibers=data["fibers"],
+            config=data["config"],
+            metadata=data.get("metadata", {}),
+        )
+
+        imported_id = await storage.import_brain(snapshot, brain_name)
+
+        typer.echo(f"Imported brain '{brain_name}' from {input_path}")
+        typer.echo(f"  Neurons: {len(snapshot.neurons)}")
+        typer.echo(f"  Synapses: {len(snapshot.synapses)}")
+        typer.echo(f"  Fibers: {len(snapshot.fibers)}")
+
+    asyncio.run(_import())
+
+
+@app.command()
+def serve(
+    host: Annotated[
+        str, typer.Option("--host", "-h", help="Host to bind to")
+    ] = "127.0.0.1",
+    port: Annotated[
+        int, typer.Option("--port", "-p", help="Port to bind to")
+    ] = 8000,
+    reload: Annotated[
+        bool, typer.Option("--reload", "-r", help="Enable auto-reload for development")
+    ] = False,
+) -> None:
+    """Run the NeuralMemory API server.
+
+    Examples:
+        nmem serve                    # Run on localhost:8000
+        nmem serve -p 9000            # Run on port 9000
+        nmem serve --host 0.0.0.0     # Expose to network
+        nmem serve --reload           # Development mode
+    """
+    try:
+        import uvicorn
+    except ImportError:
+        typer.echo("Error: uvicorn not installed. Run: pip install neural-memory[server]", err=True)
+        raise typer.Exit(1)
+
+    typer.echo(f"Starting NeuralMemory API server on http://{host}:{port}")
+    typer.echo(f"  UI:   http://{host}:{port}/ui")
+    typer.echo(f"  Docs: http://{host}:{port}/docs")
+
+    uvicorn.run(
+        "neural_memory.server.app:create_app",
+        host=host,
+        port=port,
+        reload=reload,
+        factory=True,
+    )
+
+
+@app.command()
+def decay(
+    brain: Annotated[
+        str | None, typer.Option("--brain", "-b", help="Brain to apply decay to")
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", "-n", help="Preview changes without applying")
+    ] = False,
+    prune_threshold: Annotated[
+        float, typer.Option("--prune", "-p", help="Prune below this activation level")
+    ] = 0.01,
+) -> None:
+    """Apply memory decay to simulate forgetting.
+
+    Memories that haven't been accessed recently will have their
+    activation levels reduced following the Ebbinghaus forgetting curve.
+
+    Examples:
+        nmem decay                    # Apply decay to current brain
+        nmem decay -b work            # Apply to specific brain
+        nmem decay --dry-run          # Preview without changes
+        nmem decay --prune 0.05       # More aggressive pruning
+    """
+    from neural_memory.engine.lifecycle import DecayManager
+    from neural_memory.unified_config import get_config, get_shared_storage
+
+    async def _decay() -> None:
+        config = get_config()
+        brain_name = brain or config.current_brain
+
+        typer.echo(f"Applying decay to brain '{brain_name}'...")
+        if dry_run:
+            typer.echo("(dry run - no changes will be saved)")
+
+        storage = await get_shared_storage(brain_name)
+
+        manager = DecayManager(
+            decay_rate=config.brain.decay_rate,
+            prune_threshold=prune_threshold,
+        )
+
+        report = await manager.apply_decay(storage, dry_run=dry_run)
+
+        typer.echo("")
+        typer.echo(report.summary())
+
+        if report.neurons_pruned > 0 or report.synapses_pruned > 0:
+            typer.echo("")
+            typer.echo(
+                f"Pruned {report.neurons_pruned} neurons and "
+                f"{report.synapses_pruned} synapses below threshold {prune_threshold}"
+            )
+
+    asyncio.run(_decay())
+
+
 @app.command()
 def version() -> None:
     """Show version information."""

neural_memory-0.4.0/src/neural_memory/engine/lifecycle.py

@@ -0,0 +1,233 @@
+"""Memory lifecycle management - decay, reinforcement, compression.
+
+Implements the Ebbinghaus forgetting curve for natural memory decay
+and reinforcement for frequently accessed memories.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from neural_memory.storage.base import NeuralStorage
+
+
+@dataclass
+class DecayReport:
+    """Report of decay operation results."""
+
+    neurons_processed: int = 0
+    neurons_decayed: int = 0
+    neurons_pruned: int = 0
+    synapses_processed: int = 0
+    synapses_decayed: int = 0
+    synapses_pruned: int = 0
+    duration_ms: float = 0.0
+    reference_time: datetime = field(default_factory=datetime.now)
+
+    def summary(self) -> str:
+        """Generate human-readable summary."""
+        lines = [
+            f"Decay Report ({self.reference_time.strftime('%Y-%m-%d %H:%M')})",
+            f"  Neurons: {self.neurons_decayed}/{self.neurons_processed} decayed, {self.neurons_pruned} pruned",
+            f"  Synapses: {self.synapses_decayed}/{self.synapses_processed} decayed, {self.synapses_pruned} pruned",
+            f"  Duration: {self.duration_ms:.1f}ms",
+        ]
+        return "\n".join(lines)
+
+
+class DecayManager:
+    """Manage memory decay using Ebbinghaus forgetting curve.
+
+    Decay formula: retention = e^(-decay_rate * days_since_access)
+
+    Memories that haven't been accessed recently will have their
+    activation levels reduced. Memories below the prune threshold
+    can be marked as dormant or removed.
+    """
+
+    def __init__(
+        self,
+        decay_rate: float = 0.1,
+        prune_threshold: float = 0.01,
+        min_age_days: float = 1.0,
+    ):
+        """Initialize decay manager.
+
+        Args:
+            decay_rate: Rate of decay per day (0.1 = 10% per day)
+            prune_threshold: Activation level below which to prune
+            min_age_days: Minimum age before applying decay
+        """
+        self.decay_rate = decay_rate
+        self.prune_threshold = prune_threshold
+        self.min_age_days = min_age_days
+
+    async def apply_decay(
+        self,
+        storage: NeuralStorage,
+        reference_time: datetime | None = None,
+        dry_run: bool = False,
+    ) -> DecayReport:
+        """Apply decay to all neurons and synapses in storage.
+
+        Args:
+            storage: Storage instance to apply decay to
+            reference_time: Reference time for decay calculation (default: now)
+            dry_run: If True, calculate but don't save changes
+
+        Returns:
+            DecayReport with statistics
+        """
+        import time
+
+        start_time = time.perf_counter()
+        reference_time = reference_time or datetime.now()
+        report = DecayReport(reference_time=reference_time)
+
+        # Get all neuron states
+        states = await storage.get_all_neuron_states()
+        report.neurons_processed = len(states)
+
+        for state in states:
+            if state.last_activated is None:
+                continue
+
+            # Calculate time since last activation
+            time_diff = reference_time - state.last_activated
+            days_elapsed = time_diff.total_seconds() / 86400
+
+            # Skip if too recent
+            if days_elapsed < self.min_age_days:
+                continue
+
+            # Calculate decay
+            decay_factor = math.exp(-self.decay_rate * days_elapsed)
+            new_level = state.activation_level * decay_factor
+
+            if new_level < state.activation_level:
+                report.neurons_decayed += 1
+
+                if new_level < self.prune_threshold:
+                    report.neurons_pruned += 1
+                    new_level = 0.0
+
+                if not dry_run:
+                    # Update the neuron state
+                    updated_state = state.with_activation(new_level)
+                    updated_state = type(state)(
+                        neuron_id=state.neuron_id,
+                        activation_level=new_level,
+                        access_frequency=state.access_frequency,
+                        last_activated=state.last_activated,
+                        decay_rate=state.decay_rate,
+                        created_at=state.created_at,
+                    )
+                    await storage.update_neuron_state(updated_state)
+
+        # Get all synapses and apply decay
+        synapses = await storage.get_all_synapses()
+        report.synapses_processed = len(synapses)
+
+        for synapse in synapses:
+            if synapse.last_activated is None:
+                continue
+
+            time_diff = reference_time - synapse.last_activated
+            days_elapsed = time_diff.total_seconds() / 86400
+
+            if days_elapsed < self.min_age_days:
+                continue
+
+            # Decay synapse weight
+            decay_factor = math.exp(-self.decay_rate * days_elapsed)
+            new_weight = synapse.weight * decay_factor
+
+            if new_weight < synapse.weight:
+                report.synapses_decayed += 1
+
+                if new_weight < self.prune_threshold:
+                    report.synapses_pruned += 1
+                    if not dry_run:
+                        # Could delete synapse here, but just set weight to 0 for now
+                        pass
+
+                if not dry_run and new_weight >= self.prune_threshold:
+                    decayed_synapse = synapse.decay(decay_factor)
+                    await storage.update_synapse(decayed_synapse)
+
+        report.duration_ms = (time.perf_counter() - start_time) * 1000
+        return report
+
+
+class ReinforcementManager:
+    """Strengthen frequently accessed memory paths.
+
+    When memories are accessed, their activation levels and
+    synapse weights are increased (reinforced).
+    """
+
+    def __init__(
+        self,
+        reinforcement_delta: float = 0.05,
+        max_activation: float = 1.0,
+        max_weight: float = 1.0,
+    ):
+        """Initialize reinforcement manager.
+
+        Args:
+            reinforcement_delta: Amount to increase on each access
+            max_activation: Maximum activation level
+            max_weight: Maximum synapse weight
+        """
+        self.reinforcement_delta = reinforcement_delta
+        self.max_activation = max_activation
+        self.max_weight = max_weight
+
+    async def reinforce(
+        self,
+        storage: NeuralStorage,
+        neuron_ids: list[str],
+        synapse_ids: list[str] | None = None,
+    ) -> int:
+        """Reinforce accessed neurons and synapses.
+
+        Args:
+            storage: Storage instance
+            neuron_ids: List of accessed neuron IDs
+            synapse_ids: Optional list of accessed synapse IDs
+
+        Returns:
+            Number of items reinforced
+        """
+        reinforced = 0
+
+        for neuron_id in neuron_ids:
+            state = await storage.get_neuron_state(neuron_id)
+            if state:
+                new_level = min(
+                    state.activation_level + self.reinforcement_delta,
+                    self.max_activation,
+                )
+                activated_state = state.activate(new_level - state.activation_level)
+                await storage.update_neuron_state(activated_state)
+                reinforced += 1
+
+        if synapse_ids:
+            for synapse_id in synapse_ids:
+                synapse = await storage.get_synapse(synapse_id)
+                if synapse:
+                    new_weight = min(
+                        synapse.weight + self.reinforcement_delta,
+                        self.max_weight,
+                    )
+                    reinforced_synapse = synapse.reinforce(
+                        new_weight - synapse.weight
+                    )
+                    await storage.update_synapse(reinforced_synapse)
+                    reinforced += 1
+
+        return reinforced

{neural_memory-0.2.0 → neural_memory-0.4.0}/src/neural_memory/mcp/server.py

@@ -603,7 +603,7 @@ async def handle_message(server: MCPServer, message: dict[str, Any]) -> dict[str
             "id": msg_id,
             "result": {
                 "protocolVersion": "2024-11-05",
-                "serverInfo": {"name": "neural-memory", "version": "0.2.0"},
+                "serverInfo": {"name": "neural-memory", "version": "0.4.0"},
                 "capabilities": {"tools": {}, "resources": {}},
             },
         }

{neural_memory-0.2.0 → neural_memory-0.4.0}/src/neural_memory/server/app.py

@@ -4,15 +4,21 @@ from __future__ import annotations
 
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
+from pathlib import Path
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
 
 from neural_memory import __version__
 from neural_memory.server.models import HealthResponse
 from neural_memory.server.routes import brain_router, memory_router, sync_router
 from neural_memory.storage.memory_store import InMemoryStorage
 
+# Static files directory
+STATIC_DIR = Path(__file__).parent / "static"
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
@@ -90,8 +96,70 @@ def create_app(
             "version": __version__,
             "docs": "/docs",
             "health": "/health",
+            "ui": "/ui",
+        }
+
+    # Graph visualization API
+    @app.get("/api/graph", tags=["visualization"])
+    async def get_graph_data() -> dict:
+        """Get graph data for visualization."""
+        from neural_memory.unified_config import get_shared_storage
+
+        storage = await get_shared_storage()
+
+        # Get all data
+        neurons = await storage.find_neurons()
+        synapses = await storage.get_all_synapses()
+        fibers = await storage.get_fibers(limit=1000)
+
+        stats = {
+            "neuron_count": len(neurons),
+            "synapse_count": len(synapses),
+            "fiber_count": len(fibers),
         }
 
+        return {
+            "neurons": [
+                {
+                    "id": n.id,
+                    "type": n.type.value,
+                    "content": n.content,
+                    "metadata": n.metadata,
+                }
+                for n in neurons
+            ],
+            "synapses": [
+                {
+                    "id": s.id,
+                    "source_id": s.source_id,
+                    "target_id": s.target_id,
+                    "type": s.type.value,
+                    "weight": s.weight,
+                    "direction": s.direction.value,
+                }
+                for s in synapses
+            ],
+            "fibers": [
+                {
+                    "id": f.id,
+                    "summary": f.summary,
+                    "neuron_count": len(f.neuron_ids) if f.neuron_ids else 0,
+                }
+                for f in fibers
+            ],
+            "stats": stats,
+        }
+
+    # UI endpoint
+    @app.get("/ui", tags=["visualization"])
+    async def ui() -> FileResponse:
+        """Serve the visualization UI."""
+        return FileResponse(STATIC_DIR / "index.html")
+
+    # Mount static files (for potential future assets)
+    if STATIC_DIR.exists():
+        app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+
     return app
 
 

neural_memory-0.4.0/src/neural_memory/server/static/index.html

@@ -0,0 +1,403 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>NeuralMemory - Brain Visualization</title>
+    <script src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+            background: #1a1a2e;
+            color: #eee;
+        }
+        .container {
+            display: flex;
+            height: 100vh;
+        }
+        .sidebar {
+            width: 300px;
+            background: #16213e;
+            padding: 20px;
+            overflow-y: auto;
+        }
+        .main {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+        }
+        .header {
+            background: #0f3460;
+            padding: 15px 20px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        .header h1 {
+            font-size: 1.5rem;
+            color: #e94560;
+        }
+        .stats {
+            display: flex;
+            gap: 20px;
+        }
+        .stat {
+            text-align: center;
+        }
+        .stat-value {
+            font-size: 1.5rem;
+            font-weight: bold;
+            color: #e94560;
+        }
+        .stat-label {
+            font-size: 0.8rem;
+            color: #aaa;
+        }
+        #graph {
+            flex: 1;
+            background: #1a1a2e;
+        }
+        .sidebar h2 {
+            color: #e94560;
+            margin-bottom: 15px;
+            font-size: 1.1rem;
+        }
+        .sidebar h3 {
+            color: #aaa;
+            margin: 15px 0 10px;
+            font-size: 0.9rem;
+            text-transform: uppercase;
+        }
+        .brain-select {
+            width: 100%;
+            padding: 10px;
+            background: #0f3460;
+            border: 1px solid #e94560;
+            color: #eee;
+            border-radius: 5px;
+            margin-bottom: 15px;
+        }
+        .btn {
+            width: 100%;
+            padding: 10px;
+            background: #e94560;
+            border: none;
+            color: white;
+            border-radius: 5px;
+            cursor: pointer;
+            margin-bottom: 10px;
+            font-size: 0.9rem;
+        }
+        .btn:hover {
+            background: #ff6b6b;
+        }
+        .btn-secondary {
+            background: #0f3460;
+            border: 1px solid #e94560;
+        }
+        .btn-secondary:hover {
+            background: #16213e;
+        }
+        .node-info {
+            background: #0f3460;
+            padding: 15px;
+            border-radius: 5px;
+            margin-top: 15px;
+        }
+        .node-info p {
+            margin: 5px 0;
+            font-size: 0.85rem;
+        }
+        .node-info .label {
+            color: #aaa;
+        }
+        .node-info .value {
+            color: #eee;
+        }
+        .legend {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            margin-top: 15px;
+        }
+        .legend-item {
+            display: flex;
+            align-items: center;
+            gap: 5px;
+            font-size: 0.75rem;
+        }
+        .legend-color {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+        }
+        .loading {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100%;
+            font-size: 1.2rem;
+            color: #aaa;
+        }
+        .error {
+            color: #ff6b6b;
+            padding: 10px;
+            background: rgba(255,107,107,0.1);
+            border-radius: 5px;
+            margin-top: 10px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <aside class="sidebar">
+            <h2>NeuralMemory</h2>
+
+            <select id="brainSelect" class="brain-select">
+                <option value="">Loading brains...</option>
+            </select>
+
+            <button class="btn" onclick="loadGraph()">Refresh Graph</button>
+            <button class="btn btn-secondary" onclick="resetView()">Reset View</button>
+
+            <h3>Statistics</h3>
+            <div class="stats" style="flex-direction: column; gap: 10px;">
+                <div class="stat" style="text-align: left;">
+                    <span class="stat-label">Neurons: </span>
+                    <span class="stat-value" id="neuronCount">0</span>
+                </div>
+                <div class="stat" style="text-align: left;">
+                    <span class="stat-label">Synapses: </span>
+                    <span class="stat-value" id="synapseCount">0</span>
+                </div>
+                <div class="stat" style="text-align: left;">
+                    <span class="stat-label">Fibers: </span>
+                    <span class="stat-value" id="fiberCount">0</span>
+                </div>
+            </div>
+
+            <h3>Selected Node</h3>
+            <div class="node-info" id="nodeInfo">
+                <p><span class="label">Click a node to see details</span></p>
+            </div>
+
+            <h3>Legend</h3>
+            <div class="legend">
+                <div class="legend-item">
+                    <div class="legend-color" style="background: #e94560;"></div>
+                    <span>Concept</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="background: #4ecdc4;"></div>
+                    <span>Entity</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="background: #ffe66d;"></div>
+                    <span>Time</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="background: #95e1d3;"></div>
+                    <span>Action</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="background: #f38181;"></div>
+                    <span>State</span>
+                </div>
+                <div class="legend-item">
+                    <div class="legend-color" style="background: #aa96da;"></div>
+                    <span>Other</span>
+                </div>
+            </div>
+        </aside>
+
+        <main class="main">
+            <header class="header">
+                <h1>Brain Visualization</h1>
+                <div class="stats">
+                    <div class="stat">
+                        <div class="stat-value" id="visibleNodes">0</div>
+                        <div class="stat-label">Visible Nodes</div>
+                    </div>
+                    <div class="stat">
+                        <div class="stat-value" id="visibleEdges">0</div>
+                        <div class="stat-label">Visible Edges</div>
+                    </div>
+                </div>
+            </header>
+            <div id="graph">
+                <div class="loading">Loading graph...</div>
+            </div>
+        </main>
+    </div>
+
+    <script>
+        const API_BASE = window.location.origin;
+        let network = null;
+        let allNodes = [];
+        let allEdges = [];
+
+        const COLORS = {
+            concept: '#e94560',
+            entity: '#4ecdc4',
+            time: '#ffe66d',
+            action: '#95e1d3',
+            state: '#f38181',
+            spatial: '#45b7d1',
+            sensory: '#96ceb4',
+            intent: '#dda0dd',
+            default: '#aa96da'
+        };
+
+        async function loadBrains() {
+            try {
+                // For now, use default brain from unified config
+                const select = document.getElementById('brainSelect');
+                select.innerHTML = '<option value="default">default</option>';
+            } catch (error) {
+                console.error('Error loading brains:', error);
+            }
+        }
+
+        async function loadGraph() {
+            const graphContainer = document.getElementById('graph');
+            graphContainer.innerHTML = '<div class="loading">Loading graph...</div>';
+
+            try {
+                const response = await fetch(`${API_BASE}/api/graph`);
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const data = await response.json();
+
+                // Update stats
+                document.getElementById('neuronCount').textContent = data.stats.neuron_count;
+                document.getElementById('synapseCount').textContent = data.stats.synapse_count;
+                document.getElementById('fiberCount').textContent = data.stats.fiber_count;
+
+                // Convert to vis.js format
+                allNodes = data.neurons.map(n => ({
+                    id: n.id,
+                    label: truncate(n.content, 20),
+                    title: n.content,
+                    color: COLORS[n.type] || COLORS.default,
+                    type: n.type,
+                    content: n.content,
+                    metadata: n.metadata
+                }));
+
+                allEdges = data.synapses.map(s => ({
+                    id: s.id,
+                    from: s.source_id,
+                    to: s.target_id,
+                    label: s.type,
+                    title: `${s.type} (weight: ${s.weight.toFixed(2)})`,
+                    arrows: s.direction === 'uni' ? 'to' : 'to, from',
+                    width: Math.max(1, s.weight * 3),
+                    color: { color: '#555', highlight: '#e94560' }
+                }));
+
+                renderGraph();
+
+            } catch (error) {
+                console.error('Error loading graph:', error);
+                graphContainer.innerHTML = `<div class="error">Error loading graph: ${error.message}<br>Make sure the server is running with UI enabled.</div>`;
+            }
+        }
+
+        function renderGraph() {
+            const container = document.getElementById('graph');
+            container.innerHTML = '';
+
+            const nodes = new vis.DataSet(allNodes);
+            const edges = new vis.DataSet(allEdges);
+
+            document.getElementById('visibleNodes').textContent = allNodes.length;
+            document.getElementById('visibleEdges').textContent = allEdges.length;
+
+            const options = {
+                nodes: {
+                    shape: 'dot',
+                    size: 16,
+                    font: {
+                        size: 12,
+                        color: '#eee'
+                    },
+                    borderWidth: 2,
+                    shadow: true
+                },
+                edges: {
+                    font: {
+                        size: 10,
+                        color: '#888',
+                        strokeWidth: 0
+                    },
+                    smooth: {
+                        type: 'continuous'
+                    }
+                },
+                physics: {
+                    stabilization: {
+                        iterations: 100
+                    },
+                    barnesHut: {
+                        gravitationalConstant: -2000,
+                        springLength: 150
+                    }
+                },
+                interaction: {
+                    hover: true,
+                    tooltipDelay: 200
+                }
+            };
+
+            network = new vis.Network(container, { nodes, edges }, options);
+
+            network.on('selectNode', function(params) {
+                if (params.nodes.length > 0) {
+                    const nodeId = params.nodes[0];
+                    const node = allNodes.find(n => n.id === nodeId);
+                    showNodeInfo(node);
+                }
+            });
+
+            network.on('deselectNode', function() {
+                document.getElementById('nodeInfo').innerHTML =
+                    '<p><span class="label">Click a node to see details</span></p>';
+            });
+        }
+
+        function showNodeInfo(node) {
+            if (!node) return;
+
+            const infoDiv = document.getElementById('nodeInfo');
+            infoDiv.innerHTML = `
+                <p><span class="label">Type:</span> <span class="value">${node.type}</span></p>
+                <p><span class="label">Content:</span> <span class="value">${node.content}</span></p>
+                <p><span class="label">ID:</span> <span class="value" style="font-size:0.7rem">${node.id}</span></p>
+            `;
+        }
+
+        function resetView() {
+            if (network) {
+                network.fit();
+            }
+        }
+
+        function truncate(str, len) {
+            if (!str) return '';
+            return str.length > len ? str.substring(0, len) + '...' : str;
+        }
+
+        // Initialize
+        document.addEventListener('DOMContentLoaded', () => {
+            loadBrains();
+            loadGraph();
+        });
+    </script>
+</body>
+</html>

{neural_memory-0.2.0 → neural_memory-0.4.0}/src/neural_memory/storage/sqlite_store.py

@@ -396,6 +396,18 @@ class SQLiteStorage(NeuralStorage):
             created_at=datetime.fromisoformat(row["created_at"]),
         )
 
+    async def get_all_neuron_states(self) -> list[NeuronState]:
+        """Get all neuron states for current brain."""
+        conn = self._ensure_conn()
+        brain_id = self._get_brain_id()
+
+        async with conn.execute(
+            "SELECT * FROM neuron_states WHERE brain_id = ?",
+            (brain_id,),
+        ) as cursor:
+            rows = await cursor.fetchall()
+            return [self._row_to_neuron_state(row) for row in rows]
+
     # ========== Synapse Operations ==========
 
     async def add_synapse(self, synapse: Synapse) -> str:
@@ -486,6 +498,10 @@ class SQLiteStorage(NeuralStorage):
             rows = await cursor.fetchall()
             return [self._row_to_synapse(row) for row in rows]
 
+    async def get_all_synapses(self) -> list[Synapse]:
+        """Get all synapses for current brain."""
+        return await self.get_synapses()
+
     async def update_synapse(self, synapse: Synapse) -> None:
         conn = self._ensure_conn()
         brain_id = self._get_brain_id()