neural-memory 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

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.1.0"
+__version__ = "0.3.0"
 
 __all__ = [
     "__version__",

neural_memory/cli/main.py

@@ -2685,6 +2685,233 @@ def show_today() -> None:
     asyncio.run(_today())
 
 
+@app.command(name="mcp-config")
+def mcp_config(
+    with_prompt: Annotated[
+        bool, typer.Option("--with-prompt", "-p", help="Include system prompt in config")
+    ] = False,
+    compact_prompt: Annotated[
+        bool, typer.Option("--compact", "-c", help="Use compact prompt (if --with-prompt)")
+    ] = False,
+) -> None:
+    """Generate MCP server configuration for Claude Code/Cursor.
+
+    Outputs JSON configuration that can be added to your MCP settings.
+
+    Examples:
+        nmem mcp-config                    # Basic config
+        nmem mcp-config --with-prompt      # Include system prompt
+        nmem mcp-config -p -c              # Include compact prompt
+    """
+    import shutil
+    import sys
+
+    from neural_memory.mcp.prompt import get_system_prompt
+
+    # Find nmem executable path
+    nmem_path = shutil.which("nmem") or shutil.which("nmem-mcp") or sys.executable
+
+    config = {
+        "neural-memory": {
+            "command": nmem_path if "python" not in nmem_path.lower() else "python",
+            "args": ["-m", "neural_memory.mcp"] if "python" in nmem_path.lower() else ["mcp"],
+        }
+    }
+
+    # Simplify if nmem is available
+    if shutil.which("nmem-mcp"):
+        config["neural-memory"] = {"command": "nmem-mcp", "args": []}
+
+    typer.echo("Add this to your MCP configuration:\n")
+    typer.echo(json.dumps(config, indent=2))
+
+    if with_prompt:
+        typer.echo("\n" + "=" * 60)
+        typer.echo("System prompt to add to your AI assistant:\n")
+        typer.echo(get_system_prompt(compact=compact_prompt))
+
+
+@app.command()
+def prompt(
+    compact: Annotated[
+        bool, typer.Option("--compact", "-c", help="Show compact version")
+    ] = False,
+    copy: Annotated[
+        bool, typer.Option("--copy", help="Copy to clipboard (requires pyperclip)")
+    ] = False,
+) -> None:
+    """Show system prompt for AI tools.
+
+    This prompt instructs AI assistants (Claude, GPT, etc.) on when and how
+    to use NeuralMemory for persistent memory across sessions.
+
+    Examples:
+        nmem prompt              # Show full prompt
+        nmem prompt --compact    # Show shorter version
+        nmem prompt --copy       # Copy to clipboard
+    """
+    from neural_memory.mcp.prompt import get_system_prompt
+
+    text = get_system_prompt(compact=compact)
+
+    if copy:
+        try:
+            import pyperclip
+
+            pyperclip.copy(text)
+            typer.echo("System prompt copied to clipboard!")
+        except ImportError:
+            typer.echo("Install pyperclip for clipboard support: pip install pyperclip")
+            typer.echo("")
+            typer.echo(text)
+    else:
+        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("API docs: http://{host}:{port}/docs")
+
+    uvicorn.run(
+        "neural_memory.server.app:create_app",
+        host=host,
+        port=port,
+        reload=reload,
+        factory=True,
+    )
+
+
 @app.command()
 def version() -> None:
     """Show version information."""

neural_memory/mcp/prompt.py

@@ -0,0 +1,138 @@
+"""System prompt for AI tools using NeuralMemory.
+
+This prompt instructs AI assistants on when and how to use NeuralMemory
+for persistent memory across sessions.
+"""
+
+SYSTEM_PROMPT = """# NeuralMemory - Persistent Memory System
+
+You have access to NeuralMemory, a persistent memory system that survives across sessions.
+Use it to remember important information and recall past context.
+
+## When to REMEMBER (nmem_remember)
+
+Automatically save these to memory:
+- **Decisions**: "We decided to use PostgreSQL" -> remember as decision
+- **User preferences**: "I prefer dark mode" -> remember as preference
+- **Project context**: "This is a React app using TypeScript" -> remember as context
+- **Important facts**: "The API key is stored in .env" -> remember as fact
+- **Errors & solutions**: "Fixed by adding await" -> remember as error
+- **TODOs**: "Need to add tests later" -> remember as todo
+- **Workflows**: "Deploy process: build -> test -> push" -> remember as workflow
+
+## When to RECALL (nmem_recall)
+
+Query memory when:
+- Starting a new session on an existing project
+- User asks about past decisions or context
+- You need information from previous conversations
+- Before making decisions that might conflict with past choices
+
+## When to get CONTEXT (nmem_context)
+
+Use at session start to:
+- Load recent memories relevant to current task
+- Understand project state from previous sessions
+- Avoid asking questions already answered before
+
+## Auto-Capture (nmem_auto)
+
+After important conversations, call nmem_auto to automatically capture memories:
+
+```
+# Simple: process and save in one call
+nmem_auto(action="process", text="<conversation or response text>")
+
+# Preview first: see what would be captured
+nmem_auto(action="analyze", text="<text>")
+
+# Force save (even if auto-capture disabled)
+nmem_auto(action="analyze", text="<text>", save=true)
+```
+
+Auto-capture detects:
+- **Decisions**: "We decided...", "Let's use...", "Going with..."
+- **Errors**: "Error:", "The issue was...", "Bug:", "Failed to..."
+- **TODOs**: "TODO:", "Need to...", "Remember to...", "Later:"
+- **Facts**: "The solution is...", "It works because...", "Learned that..."
+
+**When to call nmem_auto(action="process")**:
+- After making important decisions
+- After solving bugs or errors
+- After learning something new about the project
+- At the end of a productive session
+
+## Best Practices
+
+1. **Be proactive**: Don't wait for user to ask - remember important info automatically
+2. **Be concise**: Store essence, not full conversations
+3. **Use types**: Categorize memories (fact/decision/todo/error/etc.)
+4. **Set priority**: Critical info = high priority (7-10), routine = normal (5)
+5. **Add tags**: Help organize memories by project/topic
+6. **Check first**: Recall before asking questions user may have answered before
+
+## Examples
+
+```
+# User mentions a preference
+User: "I always use 4-space indentation"
+-> nmem_remember(content="User prefers 4-space indentation", type="preference", priority=6)
+
+# Starting work on existing project
+-> nmem_context(limit=10, fresh_only=true)
+-> nmem_recall(query="project setup and decisions")
+
+# Made an important decision
+"Let's use Redis for caching"
+-> nmem_remember(content="Decision: Use Redis for caching", type="decision", priority=7)
+
+# Found a bug fix
+"The issue was missing await - fixed by adding await before fetch()"
+-> nmem_remember(content="Bug fix: Missing await before fetch() caused race condition", type="error", priority=7)
+```
+
+## Memory Types
+
+- `fact`: Objective information
+- `decision`: Choices made
+- `preference`: User preferences
+- `todo`: Tasks to do
+- `insight`: Learned patterns
+- `context`: Project/session context
+- `instruction`: User instructions
+- `error`: Bugs and fixes
+- `workflow`: Processes/procedures
+- `reference`: Links/resources
+"""
+
+COMPACT_PROMPT = """You have NeuralMemory for persistent memory across sessions.
+
+**Remember** (nmem_remember): Save decisions, preferences, facts, errors, todos.
+**Recall** (nmem_recall): Query past context before making decisions.
+**Context** (nmem_context): Load recent memories at session start.
+**Auto-capture** (nmem_auto): Call `nmem_auto(action="process", text="...")` after important conversations to auto-save decisions, errors, and todos.
+
+Be proactive: remember important info without being asked. Use auto-capture after solving bugs or making decisions."""
+
+
+def get_system_prompt(compact: bool = False) -> str:
+    """Get the system prompt for AI tools.
+
+    Args:
+        compact: If True, return shorter version for limited context
+
+    Returns:
+        System prompt string
+    """
+    return COMPACT_PROMPT if compact else SYSTEM_PROMPT
+
+
+def get_prompt_for_mcp() -> dict:
+    """Get prompt formatted for MCP resources."""
+    return {
+        "uri": "neuralmemory://prompt/system",
+        "name": "NeuralMemory System Prompt",
+        "description": "Instructions for AI assistants on using NeuralMemory",
+        "mimeType": "text/plain",
+        "text": SYSTEM_PROMPT,
+    }

neural_memory/mcp/server.py

@@ -34,6 +34,7 @@ from typing import TYPE_CHECKING, Any
 from neural_memory.core.memory_types import MemoryType, Priority, TypedMemory, suggest_memory_type
 from neural_memory.engine.encoder import MemoryEncoder
 from neural_memory.engine.retrieval import DepthLevel, ReflexPipeline
+from neural_memory.mcp.prompt import get_prompt_for_mcp, get_system_prompt
 from neural_memory.unified_config import get_config, get_shared_storage
 
 if TYPE_CHECKING:
@@ -58,6 +59,31 @@ class MCPServer:
             self._storage = await get_shared_storage()
         return self._storage
 
+    def get_resources(self) -> list[dict[str, Any]]:
+        """Return list of available MCP resources."""
+        return [
+            {
+                "uri": "neuralmemory://prompt/system",
+                "name": "NeuralMemory System Prompt",
+                "description": "Instructions for AI on when/how to use NeuralMemory",
+                "mimeType": "text/plain",
+            },
+            {
+                "uri": "neuralmemory://prompt/compact",
+                "name": "NeuralMemory Compact Prompt",
+                "description": "Short version of system prompt for limited context",
+                "mimeType": "text/plain",
+            },
+        ]
+
+    def get_resource_content(self, uri: str) -> str | None:
+        """Get content of a resource by URI."""
+        if uri == "neuralmemory://prompt/system":
+            return get_system_prompt(compact=False)
+        elif uri == "neuralmemory://prompt/compact":
+            return get_system_prompt(compact=True)
+        return None
+
     def get_tools(self) -> list[dict[str, Any]]:
         """Return list of available MCP tools."""
         return [
@@ -171,22 +197,22 @@ class MCPServer:
             },
             {
                 "name": "nmem_auto",
-                "description": "Control auto-capture settings and analyze text for auto-save. When enabled, NeuralMemory automatically detects and saves decisions, errors, todos, and important facts from conversations.",
+                "description": "Auto-capture memories from text. Use 'process' to analyze and save in one call. Call this after important conversations to capture decisions, errors, todos, and facts automatically.",
                 "inputSchema": {
                     "type": "object",
                     "properties": {
                         "action": {
                             "type": "string",
-                            "enum": ["status", "enable", "disable", "analyze"],
-                            "description": "Action to perform",
+                            "enum": ["status", "enable", "disable", "analyze", "process"],
+                            "description": "Action: 'process' analyzes and saves, 'analyze' only detects",
                         },
                         "text": {
                             "type": "string",
-                            "description": "Text to analyze for auto-capture (required for 'analyze' action)",
+                            "description": "Text to analyze (required for 'analyze' and 'process')",
                         },
                         "save": {
                             "type": "boolean",
-                            "description": "If true, save detected memories (default: false for analyze)",
+                            "description": "Force save even if auto-capture disabled (for 'analyze')",
                         },
                     },
                     "required": ["action"],
@@ -397,20 +423,10 @@ class MCPServer:
             if not detected:
                 return {"detected": [], "message": "No memorable content detected"}
 
-            # Optionally save detected memories
-            if args.get("save", False) and self.config.auto.enabled:
-                saved = []
-                for item in detected:
-                    if item["confidence"] >= self.config.auto.min_confidence:
-                        result = await self._remember(
-                            {
-                                "content": item["content"],
-                                "type": item["type"],
-                                "priority": item.get("priority", 5),
-                            }
-                        )
-                        if "error" not in result:
-                            saved.append(item["content"][:50])
+            # Optionally save detected memories (save=true forces save regardless of auto setting)
+            should_save = args.get("save", False)
+            if should_save:
+                saved = await self._save_detected_memories(detected)
                 return {
                     "detected": detected,
                     "saved": saved,
@@ -422,8 +438,47 @@ class MCPServer:
                 "message": f"Detected {len(detected)} potential memories (not saved)",
             }
 
+        elif action == "process":
+            # Process = analyze + auto-save (simpler API for AI tools)
+            text = args.get("text", "")
+            if not text:
+                return {"error": "Text required for process action"}
+
+            detected = self._analyze_text_for_memories(text)
+
+            if not detected:
+                return {"saved": 0, "message": "No memorable content detected"}
+
+            # Auto-save all detected memories above confidence threshold
+            saved = await self._save_detected_memories(detected)
+
+            return {
+                "saved": len(saved),
+                "memories": saved,
+                "message": f"Auto-captured {len(saved)} memories" if saved else "No memories met confidence threshold",
+            }
+
         return {"error": f"Unknown action: {action}"}
 
+    async def _save_detected_memories(self, detected: list[dict[str, Any]]) -> list[str]:
+        """Save detected memories that meet confidence threshold.
+
+        Returns list of saved memory summaries.
+        """
+        saved = []
+        for item in detected:
+            if item["confidence"] >= self.config.auto.min_confidence:
+                result = await self._remember(
+                    {
+                        "content": item["content"],
+                        "type": item["type"],
+                        "priority": item.get("priority", 5),
+                    }
+                )
+                if "error" not in result:
+                    saved.append(item["content"][:50])
+        return saved
+
     def _analyze_text_for_memories(self, text: str) -> list[dict[str, Any]]:
         """Analyze text and detect potential memories.
 
@@ -548,14 +603,32 @@ 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.1.0"},
-                "capabilities": {"tools": {}},
+                "serverInfo": {"name": "neural-memory", "version": "0.3.0"},
+                "capabilities": {"tools": {}, "resources": {}},
             },
         }
 
     elif method == "tools/list":
         return {"jsonrpc": "2.0", "id": msg_id, "result": {"tools": server.get_tools()}}
 
+    elif method == "resources/list":
+        return {"jsonrpc": "2.0", "id": msg_id, "result": {"resources": server.get_resources()}}
+
+    elif method == "resources/read":
+        uri = params.get("uri", "")
+        content = server.get_resource_content(uri)
+        if content is None:
+            return {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "error": {"code": -32002, "message": f"Resource not found: {uri}"},
+            }
+        return {
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {"contents": [{"uri": uri, "mimeType": "text/plain", "text": content}]},
+        }
+
     elif method == "tools/call":
         tool_name = params.get("name", "")
         tool_args = params.get("arguments", {})

{neural_memory-0.1.0.dist-info → neural_memory-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neural-memory
-Version: 0.1.0
+Version: 0.3.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.1.0.dist-info → neural_memory-0.3.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-neural_memory/__init__.py,sha256=-PzpjmZU17qTgPuZJE6VgFijzpefAdr2HlRpP3wSTeM,970
+neural_memory/__init__.py,sha256=98W3ehXo6Pf4-bL0DpVt3W_aTIZPbyDqp4nXnI_uj0U,970
 neural_memory/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 neural_memory/unified_config.py,sha256=BySYLNJmnBcz9A83kKztJ53ShkScJ5qOVqBNGQls0Rs,10208
 neural_memory/cli/__init__.py,sha256=4srWgYwiGcs-mG6dm91gRbYCN-om2hfkuxd-fYkgIGI,409
 neural_memory/cli/__main__.py,sha256=TnhrDVCqsaagmqua7QH1yaP9YXLNRvLxQ0pFrMxDYRw,132
 neural_memory/cli/config.py,sha256=3kuYeWyTJms_2H_xAgx0qXEN1FbaYwvcU0oKPdiGO2Y,5612
-neural_memory/cli/main.py,sha256=DsHZDnYXFaWRqJzOFo_IK0bMNEmTtDxDpeJSGCriTJU,92396
+neural_memory/cli/main.py,sha256=rQra4oGAmd18yJ0e3xbw18IKg3--FpQSqvdyZGRO8tM,99873
 neural_memory/cli/storage.py,sha256=xiIk9Nmygw2G-nBDuRaSh6ZY6Ccu3zX_1l_eyeOlIsM,6044
 neural_memory/cli/tui.py,sha256=3D0uhQD2LpP7caBOns7EeOsx-JsORl4-DyzSsS1HN64,16335
 neural_memory/core/__init__.py,sha256=j9oPfDRg6n3Jr1OwwjY1OufH1zEPcL5aZol23R8vik0,1181
@@ -26,7 +26,8 @@ neural_memory/extraction/router.py,sha256=PGN0Z5uwmtYhARajVhb-q01PDG2cuxMUp_xqwZ
 neural_memory/extraction/temporal.py,sha256=uESwr-NWTMNiRJHDryKBdSS3swnkp_FBwjUwiHAnIf0,15930
 neural_memory/mcp/__init__.py,sha256=8qo502ZfwryBv5htRaUJWsk3q9tbZX6TBtjmO6H0iTA,332
 neural_memory/mcp/__main__.py,sha256=BETnISNHCDaqFhvOo51fSV1DcB2yMu9iefu-b6mA0bk,137
-neural_memory/mcp/server.py,sha256=TwTIc60xCSDSdGOHSVEr7tPi-DUHAABdBHS74F1ADZw,23291
+neural_memory/mcp/prompt.py,sha256=PTTWJ5ZxSPFq42ojU7UH8DKqgJxepg8ZMZmj9xYcaKQ,5003
+neural_memory/mcp/server.py,sha256=lQ9kfNOU8nkBd8mza506h9N9b08uyBqNkp8AoUT_6dc,26121
 neural_memory/safety/__init__.py,sha256=25_pdeXu-UI3dNsPYiCsC3Rvq26ma-tCd3h1ow7Ny3w,679
 neural_memory/safety/freshness.py,sha256=nwUdybjsDK_8uwa_mJRPflx0XGZXVwDwJCw-LEVyh9c,6748
 neural_memory/safety/sensitive.py,sha256=3dCv951D1JOMo6V4vu11d0OxUFhxCITZ2w05HhJ3CtA,9359
@@ -48,8 +49,8 @@ neural_memory/sync/__init__.py,sha256=epKpdAsHzwUYXrWawlHPckSEgK5CZYb-B29AAcdTnV
 neural_memory/sync/client.py,sha256=kiKqRlteXVe9P-IzgayV7bwdT9Ovu2UgV_XJtEUIbxQ,13421
 neural_memory/utils/__init__.py,sha256=vZM_jKQ_BUUd6jXtz9BGq5A1d-kFRMcMXt96XVhRv2M,135
 neural_memory/utils/config.py,sha256=jgDaHksEibusC2gub1I_USUBOJyP6gBHcfgS7RkL4dc,3086
-neural_memory-0.1.0.dist-info/METADATA,sha256=VWQ5A-nyNmq28EGUP1AWf-kduWj5-4xyIA-6QXBp9K8,10305
-neural_memory-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-neural_memory-0.1.0.dist-info/entry_points.txt,sha256=u0ZGaAD6uU98g0Wheyj1WjrSchm_zlAkyzz1HRbKOnE,121
-neural_memory-0.1.0.dist-info/licenses/LICENSE,sha256=uuCGDPgkW8shclBRpQNK5I0T97ZQy9HHolwo9Qr3Bbc,1082
-neural_memory-0.1.0.dist-info/RECORD,,
+neural_memory-0.3.0.dist-info/METADATA,sha256=UarxhykY-BWQ-PhREpptBF9MUDnD5ejnHmpxKNGAmKI,10305
+neural_memory-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+neural_memory-0.3.0.dist-info/entry_points.txt,sha256=u0ZGaAD6uU98g0Wheyj1WjrSchm_zlAkyzz1HRbKOnE,121
+neural_memory-0.3.0.dist-info/licenses/LICENSE,sha256=uuCGDPgkW8shclBRpQNK5I0T97ZQy9HHolwo9Qr3Bbc,1082
+neural_memory-0.3.0.dist-info/RECORD,,