memu-py 1.3.0__tar.gz → 1.4.0__tar.gz

{memu_py-1.3.0 → memu_py-1.4.0}/.github/workflows/build.yml

@@ -11,7 +11,7 @@ jobs:
         python-version: ["3.13"]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install uv & set Python
         uses: astral-sh/setup-uv@v7

{memu_py-1.3.0 → memu_py-1.4.0}/.github/workflows/release-please.yml

@@ -58,7 +58,7 @@ jobs:
             extra-args: ""
             python-version: "3.13"
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install uv
         uses: astral-sh/setup-uv@v7
@@ -85,7 +85,7 @@ jobs:
           CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
 
       - name: Upload wheel artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: wheels-${{ matrix.label }}
           path: dist/*.whl
@@ -97,7 +97,7 @@ jobs:
     needs: release-please
     if: ${{ needs.release-please.outputs.releases_created == 'true' && needs.release-please.outputs.tag_name != '' }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install uv
         uses: astral-sh/setup-uv@v7
@@ -114,7 +114,7 @@ jobs:
         run: uvx maturin sdist --out dist
 
       - name: Upload sdist artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
         with:
           name: sdist
           path: dist/*.tar.gz
@@ -134,14 +134,14 @@ jobs:
       contents: write
     steps:
       - name: Download wheel artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
         with:
           pattern: wheels-*
           merge-multiple: true
           path: dist
 
       - name: Download sdist artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
         with:
           name: sdist
           path: dist

{memu_py-1.3.0 → memu_py-1.4.0}/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.4.0](https://github.com/NevaMind-AI/memU/compare/v1.3.0...v1.4.0) (2026-02-06)
+
+
+### Features
+
+* Add inline memory item references in category summaries ([#202](https://github.com/NevaMind-AI/memU/issues/202)) ([#205](https://github.com/NevaMind-AI/memU/issues/205)) ([5213571](https://github.com/NevaMind-AI/memU/commit/5213571b218d85784e0771f7a721eafd7da1c1ff))
+* Add salience-aware memory with reinforcement tracking ([#186](https://github.com/NevaMind-AI/memU/issues/186)) ([#206](https://github.com/NevaMind-AI/memU/issues/206)) ([2bdbcce](https://github.com/NevaMind-AI/memU/commit/2bdbcce1a87ae1017d5930901fb0ae8d2924dcee))
+* Add Tool Memory type with specialized metadata and statistics ([#247](https://github.com/NevaMind-AI/memU/issues/247)) ([4e8a035](https://github.com/NevaMind-AI/memU/commit/4e8a03578641afd0e07f9700629dff8d91d2b3fb))
+
+
+### Bug Fixes
+
+* add chat() API and stop misusing summarize() ([#208](https://github.com/NevaMind-AI/memU/issues/208)) ([be0a5c7](https://github.com/NevaMind-AI/memU/commit/be0a5c73250f0a21ad5e0d39b0e66e3018809e0f))
+* remove unused type: ignore comment and add lazyllm mypy override ([#275](https://github.com/NevaMind-AI/memU/issues/275)) ([0e490f7](https://github.com/NevaMind-AI/memU/commit/0e490f7333feecffaef0901cccb1c9a5dbb7bafb))
+* **video:** cleanup temp files on extraction failure ([#295](https://github.com/NevaMind-AI/memU/issues/295)) ([16b65e5](https://github.com/NevaMind-AI/memU/commit/16b65e54aef69dfe617835ca534c12752e06eda8))
+
+
+### Documentation
+
+* file system in readme ([#301](https://github.com/NevaMind-AI/memU/issues/301)) ([ee27d8a](https://github.com/NevaMind-AI/memU/commit/ee27d8aa5e42d249963b08d5775338080b0255f8))
+* fix name ([#291](https://github.com/NevaMind-AI/memU/issues/291)) ([fd0d179](https://github.com/NevaMind-AI/memU/commit/fd0d17998f6c0c9ba5c7e91964c39ee909f2b366))
+* fix readme lint ([#290](https://github.com/NevaMind-AI/memU/issues/290)) ([a7a5516](https://github.com/NevaMind-AI/memU/commit/a7a55169ecbc1579ae87dc68c5e09b1d62f07b56))
+* lint error ([#287](https://github.com/NevaMind-AI/memU/issues/287)) ([7f61dc7](https://github.com/NevaMind-AI/memU/commit/7f61dc72ffbadf849f227cf314bba7ce7964761b))
+* readme memubot ([#289](https://github.com/NevaMind-AI/memU/issues/289)) ([2f30798](https://github.com/NevaMind-AI/memU/commit/2f30798367e3591107e1e66a184d0dd4ad6c2f93))
+* Update README.md ([#300](https://github.com/NevaMind-AI/memU/issues/300)) ([1075d7c](https://github.com/NevaMind-AI/memU/commit/1075d7c9ec3a272846c9fdb8c22ec58ff73cf6e7))
+
 ## [1.3.0](https://github.com/NevaMind-AI/memU/compare/v1.2.0...v1.3.0) (2026-01-29)
 
 

{memu_py-1.3.0 → memu_py-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memu-py
-Version: 1.3.0
+Version: 1.4.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -40,7 +40,7 @@ Project-URL: Homepage, https://github.com/NevaMind-AI/MemU
 
 # memU
 
-### Always-On Proactive Memory for AI Agents
+### 24/7 Always-On Proactive Memory for AI Agents
 
 [![PyPI version](https://badge.fury.io/py/memu-py.svg)](https://badge.fury.io/py/memu-py)
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
@@ -60,7 +60,54 @@ memU is a memory framework built for **24/7 proactive agents**.
 It is designed for long-running use and greatly **reduces the LLM token cost** of keeping agents always online, making always-on, evolving agents practical in production systems.
 memU **continuously captures and understands user intent**. Even without a command, the agent can tell what you are about to do and act on it by itself.
 
-check our [memU bot](https://memu.bot)
+---
+
+## 🤖 [OpenClaw (Moltbot, Clawdbot) Alternative](https://memu.bot)
+
+<img width="100%" src="https://github.com/NevaMind-AI/memU/blob/main/assets/memUbot.png" />
+
+- **Download-and-use and simple** to get started.
+- Builds long-term memory to **understand user intent** and act proactively.
+- **Cuts LLM token cost** with smaller context.
+
+Try now: [memU bot](https://memu.bot)
+
+---
+
+## 🗃️ Memory as File System, File System as Memory
+
+memU treats **memory like a file system**—structured, hierarchical, and instantly accessible.
+
+| File System | memU Memory |
+|-------------|-------------|
+| 📁 Folders | 🏷️ Categories (auto-organized topics) |
+| 📄 Files | 🧠 Memory Items (extracted facts, preferences, skills) |
+| 🔗 Symlinks | 🔄 Cross-references (related memories linked) |
+| 📂 Mount points | 📥 Resources (conversations, documents, images) |
+
+**Why this matters:**
+- **Navigate memories** like browsing directories—drill down from broad categories to specific facts
+- **Mount new knowledge** instantly—conversations and documents become queryable memory
+- **Cross-link everything**—memories reference each other, building a connected knowledge graph
+- **Persistent & portable**—export, backup, and transfer memory like files
+
+```
+memory/
+├── preferences/
+│   ├── communication_style.md
+│   └── topic_interests.md
+├── relationships/
+│   ├── contacts/
+│   └── interaction_history/
+├── knowledge/
+│   ├── domain_expertise/
+│   └── learned_skills/
+└── context/
+    ├── recent_conversations/
+    └── pending_tasks/
+```
+
+Just as a file system turns raw bytes into organized data, memU transforms raw interactions into **structured, searchable, proactive intelligence**.
 
 ---
 
@@ -94,35 +141,53 @@ python proactive.py
 
 ### Proactive Memory Lifecycle
 ```
-┌─────────────────────────────────────────────────┐
-│  1. USER INITIAL QUERY                          │
-│  └─ User input, context, or any trigger event   │
-│     Conversation starts here                    │
-└─────────────────────────────────────────────────┘
-                      ↓
-    ┌─────────────────────────────────────────────────┐
-    │  2. AGENT PLANNING / ACTIONS                    │
-    │  └─ Analyze request, execute tasks              │
-    │     Retrieve relevant memories for context      │
-    └─────────────────────────────────────────────────┘
-                          ↓
-    ┌─────────────────────────────────────────────────┐
-    │  3. MEMORIZE & UPDATE TODOLIST                  │
-    │  └─ Store new insights, facts, preferences      │
-    │     Modify task list based on progress          │
-    └─────────────────────────────────────────────────┘
-                          ↓
-    ┌─────────────────────────────────────────────────┐
-    │  4. PREDICT USER INTENT                         │
-    │  └─ Anticipate next steps and needs             │
-    │     Proactively prepare relevant context        │
-    └─────────────────────────────────────────────────┘
-                          ↓
-    ┌─────────────────────────────────────────────────┐
-    │  5. LOOP (2 → 4)                                │
-    │  └─ Continuous iteration until task complete    │
-    │     Agent-driven proactive workflow             │
-    └─────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────────────────────────────────────────────┐
+│                                         USER QUERY                                               │
+└──────────────────────────────────────────────────────────────────────────────────────────────────┘
+                 │                                                           │
+                 ▼                                                           ▼
+┌────────────────────────────────────────┐         ┌────────────────────────────────────────────────┐
+│         🤖 MAIN AGENT                  │         │              🧠 MEMU BOT                       │
+│                                        │         │                                                │
+│  Handle user queries & execute tasks   │  ◄───►  │  Monitor, memorize & proactive intelligence   │
+├────────────────────────────────────────┤         ├────────────────────────────────────────────────┤
+│                                        │         │                                                │
+│  ┌──────────────────────────────────┐  │         │  ┌──────────────────────────────────────────┐  │
+│  │  1. RECEIVE USER INPUT           │  │         │  │  1. MONITOR INPUT/OUTPUT                 │  │
+│  │     Parse query, understand      │  │   ───►  │  │     Observe agent interactions           │  │
+│  │     context and intent           │  │         │  │     Track conversation flow              │  │
+│  └──────────────────────────────────┘  │         │  └──────────────────────────────────────────┘  │
+│                 │                      │         │                    │                           │
+│                 ▼                      │         │                    ▼                           │
+│  ┌──────────────────────────────────┐  │         │  ┌──────────────────────────────────────────┐  │
+│  │  2. PLAN & EXECUTE               │  │         │  │  2. MEMORIZE & EXTRACT                   │  │
+│  │     Break down tasks             │  │   ◄───  │  │     Store insights, facts, preferences   │  │
+│  │     Call tools, retrieve data    │  │  inject │  │     Extract skills & knowledge           │  │
+│  │     Generate responses           │  │  memory │  │     Update user profile                  │  │
+│  └──────────────────────────────────┘  │         │  └──────────────────────────────────────────┘  │
+│                 │                      │         │                    │                           │
+│                 ▼                      │         │                    ▼                           │
+│  ┌──────────────────────────────────┐  │         │  ┌──────────────────────────────────────────┐  │
+│  │  3. RESPOND TO USER              │  │         │  │  3. PREDICT USER INTENT                  │  │
+│  │     Deliver answer/result        │  │   ───►  │  │     Anticipate next steps                │  │
+│  │     Continue conversation        │  │         │  │     Identify upcoming needs              │  │
+│  └──────────────────────────────────┘  │         │  └──────────────────────────────────────────┘  │
+│                 │                      │         │                    │                           │
+│                 ▼                      │         │                    ▼                           │
+│  ┌──────────────────────────────────┐  │         │  ┌──────────────────────────────────────────┐  │
+│  │  4. LOOP                         │  │         │  │  4. RUN PROACTIVE TASKS                  │  │
+│  │     Wait for next user input     │  │   ◄───  │  │     Pre-fetch relevant context           │  │
+│  │     or proactive suggestions     │  │  suggest│  │     Prepare recommendations              │  │
+│  └──────────────────────────────────┘  │         │  │     Update todolist autonomously         │  │
+│                                        │         │  └──────────────────────────────────────────┘  │
+└────────────────────────────────────────┘         └────────────────────────────────────────────────┘
+                 │                                                           │
+                 └───────────────────────────┬───────────────────────────────┘
+                                             ▼
+                              ┌──────────────────────────────┐
+                              │     CONTINUOUS SYNC LOOP     │
+                              │  Agent ◄──► MemU Bot ◄──► DB │
+                              └──────────────────────────────┘
 ```
 
 ---
@@ -378,6 +443,7 @@ See [`examples/example_4_openrouter_memory.py`](examples/example_4_openrouter_me
 Processes inputs in real-time and immediately updates memory:
 
 <img width="100%" alt="memorize" src="assets/memorize.png" />
+
 ```python
 result = await service.memorize(
     resource_url="path/to/file.json",  # File path or URL
@@ -455,8 +521,6 @@ result = await service.retrieve(
 - `where={"agent_id__in": ["1", "2"]}` - Multi-agent coordination
 - Omit `where` for global context awareness
 
-> 📚 **For complete API documentation**, see [SERVICE_API.md](docs/SERVICE_API.md) - includes proactive workflow patterns, pipeline configuration, and real-time update handling.
-
 ---
 
 ## 💡 Proactive Scenarios

{memu_py-1.3.0 → memu_py-1.4.0}/README.md

@@ -4,7 +4,7 @@
 
 # memU
 
-### Always-On Proactive Memory for AI Agents
+### 24/7 Always-On Proactive Memory for AI Agents
 
 [![PyPI version](https://badge.fury.io/py/memu-py.svg)](https://badge.fury.io/py/memu-py)
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
@@ -24,7 +24,54 @@ memU is a memory framework built for **24/7 proactive agents**.
 It is designed for long-running use and greatly **reduces the LLM token cost** of keeping agents always online, making always-on, evolving agents practical in production systems.
 memU **continuously captures and understands user intent**. Even without a command, the agent can tell what you are about to do and act on it by itself.
 
-check our [memU bot](https://memu.bot)
+---
+
+## 🤖 [OpenClaw (Moltbot, Clawdbot) Alternative](https://memu.bot)
+
+<img width="100%" src="https://github.com/NevaMind-AI/memU/blob/main/assets/memUbot.png" />
+
+- **Download-and-use and simple** to get started.
+- Builds long-term memory to **understand user intent** and act proactively.
+- **Cuts LLM token cost** with smaller context.
+
+Try now: [memU bot](https://memu.bot)
+
+---
+
+## 🗃️ Memory as File System, File System as Memory
+
+memU treats **memory like a file system**—structured, hierarchical, and instantly accessible.
+
+| File System | memU Memory |
+|-------------|-------------|
+| 📁 Folders | 🏷️ Categories (auto-organized topics) |
+| 📄 Files | 🧠 Memory Items (extracted facts, preferences, skills) |
+| 🔗 Symlinks | 🔄 Cross-references (related memories linked) |
+| 📂 Mount points | 📥 Resources (conversations, documents, images) |
+
+**Why this matters:**
+- **Navigate memories** like browsing directories—drill down from broad categories to specific facts
+- **Mount new knowledge** instantly—conversations and documents become queryable memory
+- **Cross-link everything**—memories reference each other, building a connected knowledge graph
+- **Persistent & portable**—export, backup, and transfer memory like files
+
+```
+memory/
+├── preferences/
+│   ├── communication_style.md
+│   └── topic_interests.md
+├── relationships/
+│   ├── contacts/
+│   └── interaction_history/
+├── knowledge/
+│   ├── domain_expertise/
+│   └── learned_skills/
+└── context/
+    ├── recent_conversations/
+    └── pending_tasks/
+```
+
+Just as a file system turns raw bytes into organized data, memU transforms raw interactions into **structured, searchable, proactive intelligence**.
 
 ---
 
@@ -58,35 +105,53 @@ python proactive.py
 
 ### Proactive Memory Lifecycle
 ```
-┌─────────────────────────────────────────────────┐
-│  1. USER INITIAL QUERY                          │
-│  └─ User input, context, or any trigger event   │
-│     Conversation starts here                    │
-└─────────────────────────────────────────────────┘
-                      ↓
-    ┌─────────────────────────────────────────────────┐
-    │  2. AGENT PLANNING / ACTIONS                    │
-    │  └─ Analyze request, execute tasks              │
-    │     Retrieve relevant memories for context      │
-    └─────────────────────────────────────────────────┘
-                          ↓
-    ┌─────────────────────────────────────────────────┐
-    │  3. MEMORIZE & UPDATE TODOLIST                  │
-    │  └─ Store new insights, facts, preferences      │
-    │     Modify task list based on progress          │
-    └─────────────────────────────────────────────────┘
-                          ↓
-    ┌─────────────────────────────────────────────────┐
-    │  4. PREDICT USER INTENT                         │
-    │  └─ Anticipate next steps and needs             │
-    │     Proactively prepare relevant context        │
-    └─────────────────────────────────────────────────┘
-                          ↓
-    ┌─────────────────────────────────────────────────┐
-    │  5. LOOP (2 → 4)                                │
-    │  └─ Continuous iteration until task complete    │
-    │     Agent-driven proactive workflow             │
-    └─────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────────────────────────────────────────────┐
+│                                         USER QUERY                                               │
+└──────────────────────────────────────────────────────────────────────────────────────────────────┘
+                 │                                                           │
+                 ▼                                                           ▼
+┌────────────────────────────────────────┐         ┌────────────────────────────────────────────────┐
+│         🤖 MAIN AGENT                  │         │              🧠 MEMU BOT                       │
+│                                        │         │                                                │
+│  Handle user queries & execute tasks   │  ◄───►  │  Monitor, memorize & proactive intelligence   │
+├────────────────────────────────────────┤         ├────────────────────────────────────────────────┤
+│                                        │         │                                                │
+│  ┌──────────────────────────────────┐  │         │  ┌──────────────────────────────────────────┐  │
+│  │  1. RECEIVE USER INPUT           │  │         │  │  1. MONITOR INPUT/OUTPUT                 │  │
+│  │     Parse query, understand      │  │   ───►  │  │     Observe agent interactions           │  │
+│  │     context and intent           │  │         │  │     Track conversation flow              │  │
+│  └──────────────────────────────────┘  │         │  └──────────────────────────────────────────┘  │
+│                 │                      │         │                    │                           │
+│                 ▼                      │         │                    ▼                           │
+│  ┌──────────────────────────────────┐  │         │  ┌──────────────────────────────────────────┐  │
+│  │  2. PLAN & EXECUTE               │  │         │  │  2. MEMORIZE & EXTRACT                   │  │
+│  │     Break down tasks             │  │   ◄───  │  │     Store insights, facts, preferences   │  │
+│  │     Call tools, retrieve data    │  │  inject │  │     Extract skills & knowledge           │  │
+│  │     Generate responses           │  │  memory │  │     Update user profile                  │  │
+│  └──────────────────────────────────┘  │         │  └──────────────────────────────────────────┘  │
+│                 │                      │         │                    │                           │
+│                 ▼                      │         │                    ▼                           │
+│  ┌──────────────────────────────────┐  │         │  ┌──────────────────────────────────────────┐  │
+│  │  3. RESPOND TO USER              │  │         │  │  3. PREDICT USER INTENT                  │  │
+│  │     Deliver answer/result        │  │   ───►  │  │     Anticipate next steps                │  │
+│  │     Continue conversation        │  │         │  │     Identify upcoming needs              │  │
+│  └──────────────────────────────────┘  │         │  └──────────────────────────────────────────┘  │
+│                 │                      │         │                    │                           │
+│                 ▼                      │         │                    ▼                           │
+│  ┌──────────────────────────────────┐  │         │  ┌──────────────────────────────────────────┐  │
+│  │  4. LOOP                         │  │         │  │  4. RUN PROACTIVE TASKS                  │  │
+│  │     Wait for next user input     │  │   ◄───  │  │     Pre-fetch relevant context           │  │
+│  │     or proactive suggestions     │  │  suggest│  │     Prepare recommendations              │  │
+│  └──────────────────────────────────┘  │         │  │     Update todolist autonomously         │  │
+│                                        │         │  └──────────────────────────────────────────┘  │
+└────────────────────────────────────────┘         └────────────────────────────────────────────────┘
+                 │                                                           │
+                 └───────────────────────────┬───────────────────────────────┘
+                                             ▼
+                              ┌──────────────────────────────┐
+                              │     CONTINUOUS SYNC LOOP     │
+                              │  Agent ◄──► MemU Bot ◄──► DB │
+                              └──────────────────────────────┘
 ```
 
 ---
@@ -342,6 +407,7 @@ See [`examples/example_4_openrouter_memory.py`](examples/example_4_openrouter_me
 Processes inputs in real-time and immediately updates memory:
 
 <img width="100%" alt="memorize" src="assets/memorize.png" />
+
 ```python
 result = await service.memorize(
     resource_url="path/to/file.json",  # File path or URL
@@ -419,8 +485,6 @@ result = await service.retrieve(
 - `where={"agent_id__in": ["1", "2"]}` - Multi-agent coordination
 - Omit `where` for global context awareness
 
-> 📚 **For complete API documentation**, see [SERVICE_API.md](docs/SERVICE_API.md) - includes proactive workflow patterns, pipeline configuration, and real-time update handling.
-
 ---
 
 ## 💡 Proactive Scenarios

memu_py-1.4.0/docs/HACKATHON_ISSUE_DRAFT.md

@@ -0,0 +1,68 @@
+# GitHub Issue Draft: Memory Types + Tool Memory
+
+## Title
+`[2026NewYearChallenge] Specialized Memory Types with Tool Learning`
+
+---
+
+## Description
+
+### What will this task implement?
+
+This PR enhances MemU's memory type system to support specialized memory structures with type-specific metadata and introduces Tool Memory for agent self-improvement.
+
+**Current State:** MemU has a `memory_type` field with 5 types (profile, event, knowledge, behavior, skill) and uses different LLM prompts to extract each type. However, after extraction, all memories share the same storage schema - just `summary` and `embedding`. There's no type-specific metadata, no type-aware retrieval, and no way for agents to learn from their tool usage.
+
+**Enhancement:** Extend the memory system to support:
+- Type-specific metadata fields (e.g., `when_to_use` for smarter retrieval)
+- Tool Memory type for tracking tool execution history
+- Tool usage statistics for agent self-improvement
+- Type-aware retrieval filtering
+
+**Key Benefits:**
+- Agents can learn from their own tool usage patterns
+- Smarter retrieval based on memory context
+- Foundation for agents that improve over time
+- Better alignment with agentic application needs
+
+---
+
+## Requirements
+
+- [x] Type-specific metadata schema with `when_to_use` field
+- [x] Tool Memory implementation with execution tracking
+- [x] Tool statistics (success_rate, avg_time_cost, avg_score)
+- [ ] Type-aware retrieval filtering
+- [x] Tests for Tool Memory CRUD and statistics
+- [ ] Documentation and usage examples
+
+---
+
+## Review Criteria
+
+- Correctness: All tests pass, no regressions
+- Quality: Clean code, follows existing patterns
+- DX: Clear documentation and examples
+- Impact: Enables agent self-improvement use cases
+
+---
+
+## Implementation Summary
+
+### Files Modified:
+1. `src/memu/database/models.py` - Added `ToolCallResult` model, extended `MemoryItem` with `when_to_use`, `metadata`, `tool_calls` fields
+2. `src/memu/database/repositories/memory_item.py` - Updated interface with new fields
+3. `src/memu/database/inmemory/repositories/memory_item_repo.py` - Updated implementation
+4. `src/memu/database/postgres/repositories/memory_item_repo.py` - Updated implementation
+5. `src/memu/database/postgres/models.py` - Added JSON columns for new fields
+6. `src/memu/prompts/memory_type/__init__.py` - Added tool type
+7. `src/memu/prompts/memory_type/tool.py` - New prompt for tool memory extraction
+
+### Files Added:
+1. `tests/test_tool_memory.py` - 14 unit tests for Tool Memory feature
+
+---
+
+## Notes
+
+This builds on MemU's existing memory type foundation while adding the specialized structures needed for agentic applications. The Tool Memory feature is particularly valuable for agents that need to learn which tools work best in different situations.