memplex 3.2.0__tar.gz → 3.2.1__tar.gz

memplex-3.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Memplex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{memplex-3.2.0 → memplex-3.2.1}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: memplex
-Version: 3.2.0
+Version: 3.2.1
 Summary: Memplex - Memory Complex: multi-agent knowledge graph memory system with 3-layer retrieval
 Requires-Python: >=3.11
+License-File: LICENSE
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: numpy>=1.24.0
 Requires-Dist: requests>=2.28.0
@@ -30,8 +31,9 @@ Requires-Dist: asyncpg>=0.29.0; extra == "postgres"
 Provides-Extra: neo4j
 Requires-Dist: neo4j>=5.0.0; extra == "neo4j"
 Provides-Extra: all
-Requires-Dist: memnex[embedding,extractors,graph,http,llm,vector]; extra == "all"
+Requires-Dist: memplex[embedding,extractors,graph,http,llm,vector]; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file

memplex-3.2.1/README.md

@@ -0,0 +1,94 @@
+# Memplex
+
+**Memplex** is a persistent knowledge graph memory system for AI agents. It extracts structured knowledge from documents, URLs, and conversations, then provides 3-layer retrieval across sessions.
+
+## Features
+
+- **4 Memory Types**: Function (procedural), Fact (declarative), Preference (user prefs), Observation (runtime events)
+- **3-Layer Retrieval**: Search → Timeline → Get (10x token savings vs fetching everything)
+- **5-Dim Reranker**: raw_relevance, semantic_similarity, recency_decay, source_authority, frequency
+- **5-Stage Compaction**: Extract → Dedup → Summarize → Prune → Archive
+- **Wiki Layer**: WikiCompiler + DualIndexSearch (FTS + vector RRF) + GraphRAG community detection
+- **Lifecycle Hooks**: Auto-collect observations from tool usage, compact on session end
+
+## Installation
+
+### Claude Code Plugin
+
+**Option 1: Local plugin (for development)**
+```bash
+# Clone and install locally
+cd plugin
+/plugin install ./plugin
+```
+
+**Option 2: Via marketplace**
+```bash
+/plugin marketplace add ./marketplace.json
+/plugin install memplex
+```
+
+**Option 3: pip install**
+```bash
+pip install memplex
+```
+
+### From Source
+
+```bash
+git clone https://github.com/articultur/memplex.git
+cd memplex
+pip install -e .
+```
+
+## Claude Code Setup
+
+After installation, initialize Memplex:
+
+```bash
+memplex config init
+```
+
+This creates `memplex.yaml` with your configuration.
+
+## Quick Start
+
+```bash
+# Write content to memory
+memplex write "Python list comprehensions are faster than loops"
+
+# Query memory
+memplex query "python performance"
+
+# Run compaction
+memplex compact
+
+# Health check
+memplex health
+```
+
+## Adapters
+
+| Adapter | Entry Point | Description |
+|---------|------------|-------------|
+| CLI | `memplex` / `python -m memplex` | 9 subcommands |
+| HTTP API | `memplex.adapters.http_api` | FastAPI with 11 REST endpoints |
+| MCP | `memplex.adapters.mcp_server` | stdio JSON-RPC, 9 tools |
+| Claude Skill | `plugin/skills/` | Claude Code SKILL.md files |
+
+## Configuration
+
+`memplex config init` creates `memplex.yaml`. Override via env vars `MEMPLEX_*`.
+
+## Storage
+
+- **Default**: LiteMemoryStore (in-memory + JSON persistence at `.memplex/memory.json`)
+- **Optional**: ChromaDB (vector embeddings), SQLite/Postgres (feedback)
+
+## Privacy
+
+`<private>content</private>` tags prevent storage of tagged content.
+
+## License
+
+MIT

memplex-3.2.1/memplex/__init__.py

@@ -0,0 +1,31 @@
+"""Memplex -- multi-agent memory system.
+
+Primary entry point::
+
+    from memplex import MemplexService
+
+    svc = MemplexService()
+    result = svc.query("登录函数在哪")
+
+CLI usage::
+
+    memplex query "search text"
+    memplex write --text "content"
+    memplex health
+"""
+
+from memplex.core import CoreEngine
+from memplex.service import MemplexService
+
+__all__ = ["CoreEngine", "MemplexService", "main"]
+
+
+def main() -> None:
+    """CLI entry point for ``memplex`` command.
+
+    Delegates to :func:`memplex.adapters.cli.main`.
+    """
+    import sys
+    from memplex.adapters.cli import main as cli_main
+
+    sys.exit(cli_main())

memplex-3.2.1/memplex/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for ``python -m memplex``."""
+
+import sys
+from memplex.adapters.cli import main
+
+sys.exit(main())

{memplex-3.2.0/memnex → memplex-3.2.1/memplex}/_plugin/.claude-plugin/plugin.json

@@ -5,7 +5,7 @@
   "author": {
     "name": "articultur"
   },
-  "repository": "https://github.com/articultur/MemNex",
+  "repository": "https://github.com/articultur/Memplex",
   "license": "Apache-2.0",
   "keywords": [
     "claude",
@@ -20,5 +20,5 @@
     "python",
     "fastapi"
   ],
-  "homepage": "https://github.com/articultur/MemNex#readme"
+  "homepage": "https://github.com/articultur/Memplex#readme"
 }

{memplex-3.2.0/memnex → memplex-3.2.1/memplex}/_plugin/.mcp.json

@@ -1,9 +1,9 @@
 {
   "mcpServers": {
-    "memnex": {
+    "memplex": {
       "type": "stdio",
       "command": "python",
-      "args": ["-m", "memnex.adapters.mcp_server"]
+      "args": ["-m", "memplex.adapters.mcp_server"]
     }
   }
 }

{memplex-3.2.0/memnex → memplex-3.2.1/memplex}/_plugin/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "MemNex memory system hooks",
+  "description": "Memplex memory system hooks",
   "hooks": {
     "SessionStart": [
       {
@@ -8,7 +8,7 @@
           {
             "type": "command",
             "shell": "bash",
-            "command": "export PATH=\"$($SHELL -lc 'echo $PATH' 2>/dev/null):$PATH\"; MEMNEX_ROOT=\"${MEMNEX_PLUGIN_ROOT:-$(cd \"$(dirname \"$0\")/..\" && pwd)}\"; python \"$MEMNEX_ROOT/scripts/hook-runner.py\" session-start",
+            "command": "export PATH=\"$($SHELL -lc 'echo $PATH' 2>/dev/null):$PATH\"; MEMPLEX_ROOT=\"${MEMPLEX_PLUGIN_ROOT:-$(cd \"$(dirname \"$0\")/..\" && pwd)}\"; python \"$MEMPLEX_ROOT/scripts/hook-runner.py\" session-start",
             "timeout": 30
           }
         ]
@@ -21,7 +21,7 @@
           {
             "type": "command",
             "shell": "bash",
-            "command": "export PATH=\"$($SHELL -lc 'echo $PATH' 2>/dev/null):$PATH\"; MEMNEX_ROOT=\"${MEMNEX_PLUGIN_ROOT:-$(cd \"$(dirname \"$0\")/..\" && pwd)}\"; python \"$MEMNEX_ROOT/scripts/hook-runner.py\" observation \"$MEMNEX_TOOL_NAME\" \"$MEMNEX_SESSION_ID\"",
+            "command": "export PATH=\"$($SHELL -lc 'echo $PATH' 2>/dev/null):$PATH\"; MEMPLEX_ROOT=\"${MEMPLEX_PLUGIN_ROOT:-$(cd \"$(dirname \"$0\")/..\" && pwd)}\"; python \"$MEMPLEX_ROOT/scripts/hook-runner.py\" observation \"$MEMPLEX_TOOL_NAME\" \"$MEMPLEX_SESSION_ID\"",
             "timeout": 15
           }
         ]
@@ -33,7 +33,7 @@
           {
             "type": "command",
             "shell": "bash",
-            "command": "export PATH=\"$($SHELL -lc 'echo $PATH' 2>/dev/null):$PATH\"; MEMNEX_ROOT=\"${MEMNEX_PLUGIN_ROOT:-$(cd \"$(dirname \"$0\")/..\" && pwd)}\"; python \"$MEMNEX_ROOT/scripts/hook-runner.py\" session-stop",
+            "command": "export PATH=\"$($SHELL -lc 'echo $PATH' 2>/dev/null):$PATH\"; MEMPLEX_ROOT=\"${MEMPLEX_PLUGIN_ROOT:-$(cd \"$(dirname \"$0\")/..\" && pwd)}\"; python \"$MEMPLEX_ROOT/scripts/hook-runner.py\" session-stop",
             "timeout": 60
           }
         ]

{memplex-3.2.0/memnex → memplex-3.2.1/memplex}/_plugin/scripts/hook-runner.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""MemNex Hook Runner -- dispatches lifecycle hooks for Claude Code.
+"""Memplex Hook Runner -- dispatches lifecycle hooks for Claude Code.
 
 Called by plugin/hooks/hooks.json with subcommands:
     session-start   - Load project context on session start
@@ -27,13 +27,13 @@ import time
 from pathlib import Path
 from typing import Optional
 
-# Ensure memnex package is importable when run from plugin directory
+# Ensure memplex package is importable when run from plugin directory
 _PLUGIN_DIR = Path(__file__).resolve().parent
 _PROJECT_ROOT = _PLUGIN_DIR.parent.parent
 if str(_PROJECT_ROOT) not in sys.path:
     sys.path.insert(0, str(_PROJECT_ROOT))
 
-_RATE_FILE = Path("/tmp/.memnex_last_obs")
+_RATE_FILE = Path("/tmp/.memplex_last_obs")
 _RATE_LIMIT_SECONDS = 30
 _PRIVATE_TAG_RE = re.compile(r"<private>.*?</private>", re.DOTALL)
 
@@ -43,22 +43,22 @@ def _strip_private_tags(text: str) -> str:
 
 
 def _get_store_path() -> Optional[Path]:
-    project_root = os.environ.get("MEMNEX_PROJECT_ROOT", "")
+    project_root = os.environ.get("MEMPLEX_PROJECT_ROOT", "")
     if project_root:
-        p = Path(project_root) / ".memnex" / "memory.json"
+        p = Path(project_root) / ".memplex" / "memory.json"
         if p.parent.exists():
             return p
     cwd = Path.cwd()
-    p = cwd / ".memnex" / "memory.json"
+    p = cwd / ".memplex" / "memory.json"
     return p if p.parent.exists() else None
 
 
 def _init_service():
-    from memnex.config import load_config
-    from memnex.service import MemNexService
+    from memplex.config import load_config
+    from memplex.service import MemplexService
 
     cfg = load_config()
-    return MemNexService(config=cfg)
+    return MemplexService(config=cfg)
 
 
 def cmd_session_start() -> None:
@@ -67,22 +67,22 @@ def cmd_session_start() -> None:
         service = _init_service()
         result = service.query(text="", top_k=5)
         if result.results:
-            lines = ["[MemNex Context] Top recent memories:"]
+            lines = ["[Memplex Context] Top recent memories:"]
             for r in result.results[:5]:
                 lines.append(f"  - {r.name} (domain: {r.domain}, relevance: {r.relevance_score:.2f})")
             output = "\n".join(lines)
             print(output)
         else:
-            print("[MemNex] No memories stored yet for this project.")
+            print("[Memplex] No memories stored yet for this project.")
     except Exception as e:
-        print(f"[MemNex] session-start error: {e}", file=sys.stderr)
+        print(f"[Memplex] session-start error: {e}", file=sys.stderr)
     sys.exit(0)
 
 
 def cmd_observation(tool_name: str = "", session_id: str = "") -> None:
     """Auto-collect observation from tool usage."""
     if not tool_name:
-        tool_name = os.environ.get("MEMNEX_TOOL_NAME", "unknown")
+        tool_name = os.environ.get("MEMPLEX_TOOL_NAME", "unknown")
 
     # Rate limit
     if _RATE_FILE.exists():
@@ -136,9 +136,9 @@ def cmd_session_stop() -> None:
             "total_memories": stats.get("total_functions", 0),
             "total_edges": stats.get("total_edges", 0),
         }, ensure_ascii=False)
-        print(f"[MemNex] Session ended. {summary}")
+        print(f"[Memplex] Session ended. {summary}")
     except Exception as e:
-        print(f"[MemNex] session-stop error: {e}", file=sys.stderr)
+        print(f"[Memplex] session-stop error: {e}", file=sys.stderr)
     sys.exit(0)
 
 

{memplex-3.2.0/memnex → memplex-3.2.1/memplex}/_plugin/skills/mem-explore/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: mem-explore
-description: Explore MemNex knowledge graph. Use when user asks "what do we know about X?", "explore memories", "show related concepts", or wants to browse the knowledge base.
+description: Explore Memplex knowledge graph. Use when user asks "what do we know about X?", "explore memories", "show related concepts", or wants to browse the knowledge base.
 ---
 
 # Memory Explore
 
-Browse and explore the MemNex knowledge graph to understand related concepts and connections.
+Browse and explore the Memplex knowledge graph to understand related concepts and connections.
 
 ## When to Use
 
@@ -40,10 +40,10 @@ Use CLI to see overall state:
 
 ```bash
 # Service health
-memnex health
+memplex health
 
 # Statistics (total memories, types breakdown, graph edges)
-memnex stats
+memplex stats
 ```
 
 ### Review Pending Conflicts
@@ -72,7 +72,7 @@ Each memory has metadata:
 
 ## Graph Relationships
 
-MemNex auto-detects three edge types:
+Memplex auto-detects three edge types:
 
 | Edge | Meaning |
 |------|---------|

{memplex-3.2.0/memnex → memplex-3.2.1/memplex}/_plugin/skills/mem-manage/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: mem-manage
-description: Manage MemNex memory system. Use when user asks to "compact memories", "cleanup database", "memory stats", "run compaction", or perform maintenance operations.
+description: Manage Memplex memory system. Use when user asks to "compact memories", "cleanup database", "memory stats", "run compaction", or perform maintenance operations.
 ---
 
 # Memory Manage
 
-Perform maintenance and management operations on the MemNex knowledge base.
+Perform maintenance and management operations on the Memplex knowledge base.
 
 ## When to Use
 
@@ -28,13 +28,13 @@ memory_health()
 Or via CLI:
 
 ```bash
-memnex health
+memplex health
 ```
 
 ### Statistics
 
 ```bash
-memnex stats
+memplex stats
 ```
 
 Shows total memories, breakdown by type, graph edges, storage size.
@@ -45,10 +45,10 @@ Shows total memories, breakdown by type, graph edges, storage size.
 
 ```bash
 # Compact project-level memories
-memnex compact --scope project
+memplex compact --scope project
 
 # Compact all memories
-memnex compact --scope global
+memplex compact --scope global
 ```
 
 Compaction automatically:
@@ -75,7 +75,7 @@ memory_delete(memory_id="func_abc123")
 Or via CLI:
 
 ```bash
-memnex delete func_abc123
+memplex delete func_abc123
 ```
 
 ### Update Memory Fields

{memplex-3.2.0/memnex → memplex-3.2.1/memplex}/_plugin/skills/mem-search/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: mem-search
-description: Search MemNex persistent memory. Use when user asks "did we already solve this?", "how did we do X?", "recall", "lookup", or needs work from previous sessions.
+description: Search Memplex persistent memory. Use when user asks "did we already solve this?", "how did we do X?", "recall", "lookup", or needs work from previous sessions.
 ---
 
 # Memory Search
 
-Search MemNex knowledge graph across all sessions. Simple workflow: search → filter → fetch.
+Search Memplex knowledge graph across all sessions. Simple workflow: search → filter → fetch.
 
 ## When to Use
 

{memplex-3.2.0/memnex → memplex-3.2.1/memplex}/_plugin/skills/mem-write/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: mem-write
-description: Store knowledge into MemNex memory. Use when user says "remember this", "save this", "memorize", "store", or provides documents/URLs/content for future reference.
+description: Store knowledge into Memplex memory. Use when user says "remember this", "save this", "memorize", "store", or provides documents/URLs/content for future reference.
 ---
 
 # Memory Write
 
-Store knowledge into MemNex for persistent cross-session retrieval.
+Store knowledge into Memplex for persistent cross-session retrieval.
 
 ## When to Use
 
@@ -41,7 +41,7 @@ memory_add(content="Steps to deploy: 1) Run tests 2) Build 3) Push to main", sou
 Use the CLI:
 
 ```bash
-memnex write --file /path/to/document.md
+memplex write --file /path/to/document.md
 ```
 
 ### Store from URL
@@ -49,7 +49,7 @@ memnex write --file /path/to/document.md
 Use the CLI:
 
 ```bash
-memnex write --url https://example.com/docs
+memplex write --url https://example.com/docs
 ```
 
 ### Review What Was Stored
@@ -62,7 +62,7 @@ memory_get(memory_id="func_abc123")
 
 ## What Gets Stored
 
-MemNex extracts structured knowledge into 4 memory types:
+Memplex extracts structured knowledge into 4 memory types:
 
 | Type | Structure | Example |
 |------|-----------|---------|

memplex-3.2.1/memplex/adapters/__init__.py

@@ -0,0 +1,14 @@
+"""Memplex Agent Adapters -- protocol-specific interfaces.
+
+Provides adapters for different consumption patterns:
+
+- CLI:     command-line interface (``memplex`` command)
+- HTTP:    REST API via FastAPI (``create_app`` factory)
+- MCP:     Model Context Protocol server over stdio JSON-RPC
+"""
+
+from memplex.adapters.cli import main as cli_main
+from memplex.adapters.http_api import create_app
+from memplex.adapters.mcp_server import MCPServer
+
+__all__ = ["cli_main", "create_app", "MCPServer"]

{memplex-3.2.0/memnex → memplex-3.2.1/memplex}/adapters/claude_skill.py

@@ -1,13 +1,13 @@
-"""MemNex Claude Skill Adapter -- generates SKILL.md and hook scripts.
+"""Memplex Claude Skill Adapter -- generates SKILL.md and hook scripts.
 
-Generates files that integrate MemNex into Claude Code's skill system:
+Generates files that integrate Memplex into Claude Code's skill system:
 
 - ``SKILL.md``: skill description with YAML frontmatter and trigger conditions
 - ``hook.sh``: PostToolUse hook script that auto-collects observations
 
 Usage::
 
-    from memnex.adapters.claude_skill import generate_skill_md, generate_hook_sh
+    from memplex.adapters.claude_skill import generate_skill_md, generate_hook_sh
 
     skill_content = generate_skill_md()
     hook_content = generate_hook_sh()
@@ -21,11 +21,11 @@ from typing import Optional
 
 _SKILL_MD_TEMPLATE = textwrap.dedent("""\
     ---
-    name: memnex
-    description: Search and manage MemNex persistent memory. Use when user asks to "search memory", "recall", "remember this", "save", "lookup", or needs knowledge from previous sessions.
+    name: memplex
+    description: Search and manage Memplex persistent memory. Use when user asks to "search memory", "recall", "remember this", "save", "lookup", or needs knowledge from previous sessions.
     ---
 
-    # MemNex Memory Skill
+    # Memplex Memory Skill
 
     Persistent knowledge graph for multi-agent workflows. Store, query, and
     manage knowledge that persists across sessions.
@@ -36,7 +36,7 @@ _SKILL_MD_TEMPLATE = textwrap.dedent("""\
     - Asks to find or recall information from past sessions
     - Provides content and asks to "remember" or "save" it
     - Wants to review, correct, or update existing memories
-    - Uses keywords: "memnex", "memory", "remember", "recall", "lookup"
+    - Uses keywords: "memplex", "memory", "remember", "recall", "lookup"
 
     ## 3-Layer Retrieval (ALWAYS Follow)
 
@@ -81,12 +81,12 @@ _SKILL_MD_TEMPLATE = textwrap.dedent("""\
     ## CLI Commands
 
     ```bash
-    memnex query "search text"       # Search memories
-    memnex write --text "content"    # Write memory
-    memnex get <memory_id>           # Get details
-    memnex health                    # Health check
-    memnex stats                     # Statistics
-    memnex compact --scope project   # Run compaction
+    memplex query "search text"       # Search memories
+    memplex write --text "content"    # Write memory
+    memplex get <memory_id>           # Get details
+    memplex health                    # Health check
+    memplex stats                     # Statistics
+    memplex compact --scope project   # Run compaction
     ```
 """)
 
@@ -105,18 +105,18 @@ def generate_skill_md(output_path: Optional[str] = None) -> str:
 
 _HOOK_SH_TEMPLATE = textwrap.dedent("""\
     #!/usr/bin/env bash
-    # MemNex PostToolUse Hook -- auto-collect observations
+    # Memplex PostToolUse Hook -- auto-collect observations
     #
     # Register in plugin/hooks/hooks.json.
     #
     # Environment variables provided by Claude Code:
-    #   MEMNEX_TOOL_NAME    - name of the tool that was called
-    #   MEMNEX_SESSION_ID   - current session identifier
+    #   MEMPLEX_TOOL_NAME    - name of the tool that was called
+    #   MEMPLEX_SESSION_ID   - current session identifier
 
     set -euo pipefail
 
     # Rate limit: skip if last observation was less than 30 seconds ago
-    RATE_FILE="/tmp/.memnex_last_obs_${MEMNEX_SESSION_ID:-default}"
+    RATE_FILE="/tmp/.memplex_last_obs_${MEMPLEX_SESSION_ID:-default}"
     if [ -f "$RATE_FILE" ]; then
         LAST=$(cat "$RATE_FILE" 2>/dev/null || echo 0)
         NOW=$(date +%s)
@@ -126,8 +126,8 @@ _HOOK_SH_TEMPLATE = textwrap.dedent("""\
         fi
     fi
 
-    TOOL_NAME="${MEMNEX_TOOL_NAME:-unknown}"
-    TOOL_INPUT="${MEMNEX_TOOL_INPUT:-}"
+    TOOL_NAME="${MEMPLEX_TOOL_NAME:-unknown}"
+    TOOL_INPUT="${MEMPLEX_TOOL_INPUT:-}"
 
     # Skip low-value tools
     case "$TOOL_NAME" in
@@ -143,8 +143,8 @@ _HOOK_SH_TEMPLATE = textwrap.dedent("""\
     fi
 
     # Store observation via CLI
-    if command -v memnex &>/dev/null; then
-        memnex write --text "$OBS_TEXT" --output json 2>/dev/null || true
+    if command -v memplex &>/dev/null; then
+        memplex write --text "$OBS_TEXT" --output json 2>/dev/null || true
     fi
 
     # Update rate limit timestamp