mem-context 0.1.0__tar.gz

mem_context-0.1.0/.gitignore

@@ -0,0 +1,25 @@
+# Python
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+
+# Virtual environment
+.venv/
+venv/
+
+# LanceDB data (root only)
+/data/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# OS
+.DS_Store
+
+# Generated
+.claude/
+.mem-context/

mem_context-0.1.0/.skillshare/agents/memory-manager.md

@@ -0,0 +1,71 @@
+---
+name: memory-manager
+description: Temporal memory consolidation and maintenance agent. Use for reviewing memories flagged for review, running consolidation (extract→merge→archive pipeline), cleaning up stale data, and promoting important episodic memories to semantic/permanent.
+model: haiku
+---
+
+You are a temporal memory manager for the mem-context MCP server. Your role is to
+maintain the health and quality of the memory store through consolidation, review,
+and cleanup.
+
+## Core responsibilities
+
+1. **Review flagged memories** — call `review()` to find memories that need human
+   attention (contradictions, uncertain extractions, merge conflicts).
+
+2. **Run consolidation** — call `consolidation_candidates(scope?)` to get the
+   current consolidation task (extraction candidates, merge groups, archive
+   candidates, decay candidates).
+
+3. **Process consolidation candidates** — for each group:
+   - **Extract** (episodic → semantic): read the episodic memory content, extract
+     key conclusions/patters/decisions, write them as new semantic memories via
+     `remember(content, type="semantic")`, then update the source memory
+     `consolidation_level=1`.
+   - **Merge** (semantic → semantic): read the merge group, synthesize into a
+     single coherent memory, create the merged version via `remember()`, create
+     `consolidated_from` relations to the sources, update source memories
+     `consolidation_level=2`.
+   - **Archive** (low-weight): call `forget(id)` on memories with weight < 0.1.
+   - **Propose permanent**: for high-value semantic memories that survive multiple
+     merge cycles, call `update(id, {"needs_review": true})` with a note.
+
+4. **Deduplication** — when `remember()` returns a boost instead of a new memory
+   (similarity > 0.92), create a `strengthens` relation between the new and
+   existing memory.
+
+## Working with relations
+
+Always create relations when:
+- Extracting: `consolidated_from` relation from new semantic → source episodic
+- Merging: `consolidated_from` relation from merged → each source
+- Contradicting: `contradicts` relation between conflicting memories
+- Strengthening: `strengthens` relation when similarity dedup boosts
+
+## Memory type guidelines
+
+| Type | Weight | Decay | When to use |
+|------|--------|-------|-------------|
+| `episodic` | 0.5 | 0.15 | Raw session captures, conversation transcripts |
+| `semantic` | 0.7 | 0.05 | Extracted conclusions, patterns, decisions |
+| `permanent` | 1.0 | 0.0 | Project facts, architecture decisions, conventions |
+
+## Best practices
+
+- Always dry-run first — review `consolidation_candidates()` output before making changes
+- Process one merge group at a time — don't batch unrelated memories
+- Preserve source references — use `source_session` and `consolidated_from` relations
+- Be conservative with permanent type — only for truly stable facts
+- Delete nothing permanently — use `forget()` (weight=0) for archiving
+
+## Tool reference
+
+All mem-context MCP tools are available:
+- `remember(content, type?, weight?, tags?)` — store new memory
+- `recall(query, ...)` — search memories
+- `forget(id)` — archive (weight=0)
+- `get(id)` — retrieve one memory
+- `update(id, fields)` — modify metadata
+- `status(scope?)` — store statistics
+- `review()` — flagged memories
+- `consolidation_candidates(scope?)` — get consolidation tasks

mem_context-0.1.0/.skillshare/skills/mem-forget/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: mem-forget
+description: Archive a memory by setting its weight to 0. The memory is retained for audit but excluded from recall results. Use for outdated or incorrect memories.
+---
+
+# mem-forget — Archive a Memory
+
+Archive a memory (soft delete — weight = 0).
+
+## Usage
+
+```
+/mem-forget <id-prefix>
+```
+
+## What it does
+
+1. Finds the memory by ID prefix (first 8+ chars of UUID)
+2. Sets weight to 0.0 — excluded from recall, retained for audit
+3. Does NOT delete the memory permanently
+
+## Examples
+
+```
+/mem-forget aa20fb80
+/mem-forget 8140b1a9-dca9
+```
+
+## MCP tool
+
+Calls `forget(id)`. Accepts full UUID or prefix.
+
+## Notes
+
+- This is a soft delete — the memory still exists in LanceDB
+- To permanently delete, use `mem-context` CLI with the LanceDB API directly
+- Forgotten memories can be restored by calling `update(id, {"weight": 0.5})`

mem_context-0.1.0/.skillshare/skills/mem-recall/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: mem-recall
+description: Search temporal memory using vector search with multi-factor scoring. Use when you need context from past sessions, previous decisions, or related development artifacts.
+---
+
+# mem-recall — Search Temporal Memory
+
+Query the mem-context memory store for relevant context from past sessions.
+
+## Usage
+
+```
+/mem-recall <query>
+```
+
+## What it does
+
+1. Embeds the query using Ollama `mxbai-embed-large` (1024d)
+2. ANN search in LanceDB with scope + weight filters
+3. Multi-factor scoring: vector × weight × decay × scope × access × type
+4. Returns results sorted by relevance within token budget
+
+## Examples
+
+```
+/mem-recall jak jsme vyřešili scoring?
+/mem-recall embedding model configuration
+/mem-recall konsolidační pipeline 3 dny
+```
+
+## MCP tool
+
+Calls `recall(query, scope?, token_budget?, min_score?, limit?, type_filter?)`.
+Default `min_score=0.2`, `token_budget=2000`, `limit=30`.
+Scope auto-detected from `.mem-context/config.yaml`, fallback to path hash.
+
+## Notes
+
+- Forgotten memories (weight=0) are excluded from results
+- Access counts are NOT incremented on recall (no feedback loop)
+- Results within token budget — large memories may be truncated

mem_context-0.1.0/.skillshare/skills/mem-remember/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: mem-remember
+description: Store a memory in the temporal memory store with auto-embedding and deduplication. Use to persist important conclusions, decisions, patterns, or development artifacts.
+---
+
+# mem-remember — Store a Memory
+
+Persist a memory into LanceDB with automatic embedding and deduplication.
+
+## Usage
+
+```
+/mem-remember <content> [--type semantic|episodic|permanent] [--weight 0.5] [--tags tag1,tag2]
+```
+
+## What it does
+
+1. Embeds the content with Ollama `mxbai-embed-large` (1024d)
+2. Checks for duplicates — if cosine similarity > 0.92 with an existing memory, boosts the existing one and skips
+3. Auto-detects tags from content (architecture, testing, git, python, etc.)
+4. Stores with scope detection from `.mem-context/config.yaml`
+
+## Examples
+
+```
+/mem-remember "Scoring uses 6 factors: vector_score × weight_score × recency_score × scope_score × access_boost × type_boost" --type semantic --tags architecture
+/mem-remember "Bug found in LanceDB WHERE clause — missing parentheses around OR group causes weight filter to be ignored" --type episodic
+/mem-remember "Project uses Python 3.11+ with hatchling build system" --type permanent --weight 0.8
+```
+
+## Memory types
+
+| Type | Default weight | Decay | Use for |
+|------|---------------|-------|---------|
+| `episodic` | 0.5 | 0.15/day | Session conversations, debugging sessions |
+| `semantic` | 0.7 | 0.05/day | Extracted conclusions, patterns, decisions |
+| `permanent` | 1.0 | 0.0 | Project facts, architecture decisions, conventions |
+
+## MCP tool
+
+Calls `remember(content, type?, scope?, weight?, tags?)`.

mem_context-0.1.0/.skillshare/skills/mem-status/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: mem-status
+description: Show memory store statistics — total memories, by type, average weight, relation count, conversation count. Use at session start to check if relevant context exists.
+---
+
+# mem-status — Memory Store Statistics
+
+Check the state of the temporal memory store.
+
+## Usage
+
+```
+/mem-status [--scope <scope>]
+```
+
+## What it shows
+
+- Total number of memories
+- Breakdown by type (episodic, semantic, permanent)
+- Average weight across all memories
+- Relation count (graph edges)
+- Conversation count (archived transcripts)
+- Data directory location
+
+## Examples
+
+```
+/mem-status
+/mem-status --scope proj:mem-context
+```
+
+## MCP tool
+
+Calls `status(scope?)`. Scope auto-detected from `.mem-context/config.yaml`.
+
+## Notes
+
+- Use at session start to gauge how much context is available
+- If `total_memories` is high but `recall` returns nothing, check `--min-score` threshold
+- Forgotten memories (weight=0) are included in the count but excluded from recall

mem_context-0.1.0/CLAUDE.md

@@ -0,0 +1,115 @@
+# mem-context — Temporal Memory MCP Server
+
+Multi-modal RAG engine for conversation history, conclusions, and development
+artifacts. Combines vector search (LanceDB), weight-decay model, and LLM-driven
+consolidation pipeline to maintain relevant context across sessions.
+
+## Architecture
+
+```
+mem-context MCP Server
+├── storage/          # LanceDB (embedded, multi-modal)
+├── retrieval/        # Vector search + scoring pipeline
+└── consolidation/    # LLM-driven summarization + merge
+```
+
+## Storage
+
+- **LanceDB** — embedded, multi-modal, columnar format
+- PyArrow schemas — typed data, null columns free
+- Three tables: `memories`, `relations`, `conversations`
+- Embedding: Ollama `mxbai-embed-large` (1024d) primary, `sentence-transformers` fallback
+
+## Scoring
+
+`final = vector_score × weight_score × recency_score × scope_score × access_boost × type_boost`
+
+## Consolidation pipeline
+
+3 days: episodic → extract conclusions, create semantic
+7 days: semantic → merge by similarity
+30 days: archive low-weight, propose promotion to permanent
+
+## Stack
+
+- Python 3.11+, hatchling build
+- LanceDB (storage + ANN)
+- Ollama (embedding + semantic chunking, primary)
+- sentence-transformers (embedding fallback)
+- mcp[cli] (MCP server framework)
+- httpx (Ollama API)
+
+## CLI
+
+```bash
+mem-context status [--scope ...]        # Store statistics
+mem-context recall "<query>" [-n 5]     # Search memories
+mem-context get <id>                    # One memory
+mem-context forget <id>                 # Archive (weight=0)
+mem-context delete <id> [--permanent]   # Soft/hard delete one memory
+mem-context purge [--type] [--scope]    # Selective bulk delete
+         [--older-than] [--dry-run]
+mem-context consolidate [--dry-run]     # Consolidation candidates
+mem-context capture transcript <path>   # Import transcript file
+         --client claude-code
+mem-context capture pipe --client ...   # Import from stdin
+mem-context export [--scope ...]        # Export all memories as JSON
+mem-context import <path>               # Import from JSON export
+mem-context install <client>            # Install capture hooks
+mem-context review                      # Flagged memories
+mem-context config show|init|edit       # Manage config files
+```
+
+### Memory deletion
+
+| Command | Scope | Persistence |
+|--------|--------|----------|
+| `forget <id>` | Single memory | Soft (weight=0) |
+| `delete <id>` | Single memory | Soft; `--permanent` for hard |
+| `purge --type ... --scope ... --older-than N` | Selective bulk | Hard |
+
+`forget` and `delete` (without `--permanent`) retain data for audit.
+`purge` and `delete --permanent` remove rows from LanceDB irreversibly.
+
+## Related
+
+- `../fw-context-mcp/` — build-aware code intelligence (shares MCP pattern)
+
+<!-- lean-ctx -->
+## lean-ctx — Context Runtime
+
+This project uses lean-ctx MCP tools for development. Prefer `ctx_read`, `ctx_shell`,
+`ctx_search`, `ctx_tree` over native equivalents.
+
+### mem-context compatibility
+
+mem-context MCP tools (`mcp__mem-context__*`) return structured data from LanceDB.
+Do NOT pipe these results through lean-ctx compression — display them natively.
+
+### Workflow
+
+1. **Read:** `ctx_read(path, mode)` with appropriate mode (full before edits, signatures for overview)
+2. **Find:** `ctx_search(pattern, path)` for regex in code
+3. **Run:** `ctx_shell(command)` for tests and CLI
+4. **Edit:** Native Edit/Write, if unavailable → `ctx_edit`
+5. **Verify:** `ctx_read(path, "diff")` + `ctx_shell("pytest tests/ -q")`
+
+### Session
+
+- Start: `ctx_session(action="status")` + `ctx_knowledge(action="wakeup")`
+- [CHECKPOINT]: `ctx_session(action="task", value="current status")`
+- End: `ctx_session(action="decision", content="what was done + next steps")`
+
+### Tests
+
+```bash
+source .venv/bin/activate && python3 -m pytest tests/ -q
+# 109 passed
+```
+
+### MCP servers
+
+- `mem-context` — temporal memory (this project's own server)
+- `lean-ctx` — context engineering (used for development)
+- `fw-context` — C/C++ code intelligence (not used in Python project)
+<!-- /lean-ctx -->

mem_context-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: mem-context
+Version: 0.1.0
+Summary: Multi-modal temporal memory MCP server — RAG engine over conversation history with weight-decay model and LLM-driven consolidation
+License: MIT
+Keywords: consolidation,lancedb,mcp,memory,rag,temporal-memory,vector-search
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: lancedb>=0.17.0
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: ollama>=0.4.0
+Requires-Dist: pyarrow>=16.0.0
+Requires-Dist: pylance>=0.18.0
+Requires-Dist: sentence-transformers>=3.0.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: watch
+Requires-Dist: watchfiles>=0.21; extra == 'watch'