memry 0.2.3__tar.gz → 0.2.4__tar.gz

{memry-0.2.3 → memry-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memry
-Version: 0.2.3
+Version: 0.2.4
 Summary: The open, self-hostable memory layer for AI agents. MCP-native, local-first, research-grade.
 Project-URL: Homepage, https://memry.tech
 Project-URL: Repository, https://github.com/cosmin-novac/memry

{memry-0.2.3 → memry-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memry"
-version = "0.2.3"
+version = "0.2.4"
 description = "The open, self-hostable memory layer for AI agents. MCP-native, local-first, research-grade."
 readme = "README.md"
 license = "Apache-2.0"

{memry-0.2.3 → memry-0.2.4}/src/memry/__init__.py

@@ -14,7 +14,7 @@ from .models import (
 )
 from .store import MemoryStore
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"
 
 __all__ = [
     "MemoryStore",

{memry-0.2.3 → memry-0.2.4}/src/memry/cli.py

@@ -259,25 +259,10 @@ def main(argv: list[str] | None = None) -> int:
             ):
                 print(memory.model_dump_json())
         elif args.command == "import":
-            count = 0
             with open(args.path, encoding="utf-8") as fh:
-                for line in fh:
-                    line = line.strip()
-                    if not line:
-                        continue
-                    record = json.loads(line)
-                    store.add(
-                        record["content"],
-                        user_id=record.get("user_id"),
-                        agent_id=record.get("agent_id"),
-                        run_id=record.get("run_id"),
-                        infer=False,
-                        memory_type=record.get("memory_type", "semantic"),
-                        importance=float(record.get("importance", 0.5)),
-                        categories=record.get("categories"),
-                    )
-                    count += 1
-            _print({"imported": count})
+                rows = [json.loads(line) for line in fh if line.strip()]
+            result = store.import_verbatim(rows)
+            _print({k: v for k, v in result.items() if k != "memory_ids"})
     finally:
         store.close()
     return 0

{memry-0.2.3 → memry-0.2.4}/src/memry/mcp_server.py

@@ -10,8 +10,10 @@ Cursor, Windsurf, Codex, ...) over stdio or streamable HTTP.
 from __future__ import annotations
 
 import json
+from functools import partial
 from typing import Any
 
+import anyio.to_thread
 from mcp.server.fastmcp import FastMCP
 from mcp.server.transport_security import TransportSecuritySettings
 
@@ -70,8 +72,14 @@ def create_server(
     def _uid(user_id: str) -> str | None:
         return user_id or default_user
 
+    # Store calls are synchronous (SQLite + provider HTTP). FastMCP runs sync
+    # tools directly on the event loop, so every tool below is async and hops
+    # to a worker thread - one slow LLM call must not stall the whole server.
+    async def _threaded(fn, /, **kwargs):
+        return await anyio.to_thread.run_sync(partial(fn, **kwargs))
+
     @mcp.tool()
-    def save_memories(
+    async def save_memories(
         content: str,
         user_id: str = "",
         agent_id: str = "",
@@ -84,8 +92,9 @@ def create_server(
         reconciled against existing memories (duplicates skipped, contradictions
         superseded). With infer=false the text is saved verbatim as one memory.
         """
-        result = store.add(
-            content,
+        result = await _threaded(
+            store.add,
+            content=content,
             user_id=_uid(user_id),
             agent_id=agent_id or None,
             run_id=run_id or None,
@@ -103,7 +112,7 @@ def create_server(
         return json.dumps(payload, ensure_ascii=False)
 
     @mcp.tool()
-    def search_memories(
+    async def search_memories(
         query: str,
         user_id: str = "",
         agent_id: str = "",
@@ -117,8 +126,9 @@ def create_server(
         Optionally restrict to categories (comma-separated, e.g. "diet,health").
         """
         category_list = [c.strip() for c in categories.split(",") if c.strip()] or None
-        results = store.search(
-            query,
+        results = await _threaded(
+            store.search,
+            query=query,
             user_id=_uid(user_id),
             agent_id=agent_id or None,
             run_id=run_id or None,
@@ -130,7 +140,7 @@ def create_server(
         )
 
     @mcp.tool()
-    def get_memory_context(
+    async def get_memory_context(
         query: str,
         user_id: str = "",
         token_budget: int = 1200,
@@ -138,39 +148,40 @@ def create_server(
         """Get a ready-to-use context block of the most relevant memories for a
         task, packed to fit the given token budget. Prefer this over
         search_memories when you just want background context injected."""
-        ctx = store.reconstruct_context(
-            query, user_id=_uid(user_id), token_budget=token_budget
+        ctx = await _threaded(
+            store.reconstruct_context,
+            query=query, user_id=_uid(user_id), token_budget=token_budget,
         )
         return ctx.text or "(no relevant memories yet)"
 
     @mcp.tool()
-    def list_memories(user_id: str = "", limit: int = 50) -> str:
+    async def list_memories(user_id: str = "", limit: int = 50) -> str:
         """List the most recently updated memories for a user."""
-        memories = store.get_all(user_id=_uid(user_id), limit=limit)
+        memories = await _threaded(store.get_all, user_id=_uid(user_id), limit=limit)
         return json.dumps([_memory_row(m) for m in memories], ensure_ascii=False)
 
     @mcp.tool()
-    def update_memory(memory_id: str, content: str) -> str:
+    async def update_memory(memory_id: str, content: str) -> str:
         """Rewrite the content of an existing memory (e.g. after the user
         corrects a stored fact)."""
-        memory = store.update(memory_id, content=content)
+        memory = await _threaded(store.update, memory_id=memory_id, content=content)
         if memory is None:
             return json.dumps({"error": f"memory {memory_id} not found"})
         return json.dumps(_memory_row(memory), ensure_ascii=False)
 
     @mcp.tool()
-    def delete_memory(memory_id: str) -> str:
+    async def delete_memory(memory_id: str) -> str:
         """Forget a memory (soft delete: it is invalidated and kept in the
         audit history, not destroyed). Use when the user asks you to forget
         something."""
-        ok = store.delete(memory_id)
+        ok = await _threaded(store.delete, memory_id=memory_id)
         return json.dumps({"deleted": ok, "memory_id": memory_id})
 
     @mcp.tool()
-    def memory_history(memory_id: str) -> str:
+    async def memory_history(memory_id: str) -> str:
         """Show the full audit trail of a memory (ADD/UPDATE/SUPERSEDE/DELETE
         events with old and new content)."""
-        events = store.history(memory_id)
+        events = await _threaded(store.history, memory_id=memory_id)
         return json.dumps(
             [
                 {
@@ -186,9 +197,10 @@ def create_server(
         )
 
     @mcp.tool()
-    def memory_stats() -> str:
+    async def memory_stats() -> str:
         """Show memory store statistics (counts, backend, models in use)."""
-        return json.dumps(store.stats(), ensure_ascii=False, default=str)
+        stats = await _threaded(store.stats)
+        return json.dumps(stats, ensure_ascii=False, default=str)
 
     return mcp
 

{memry-0.2.3 → memry-0.2.4}/src/memry/rest.py

@@ -26,10 +26,12 @@ from __future__ import annotations
 
 import contextlib
 import json
+from functools import partial
 from typing import Any
 from urllib.parse import parse_qs
 
 from starlette.applications import Starlette
+from starlette.concurrency import run_in_threadpool
 from starlette.requests import Request
 from starlette.responses import HTMLResponse, JSONResponse, Response
 from starlette.routing import Mount, Route
@@ -47,6 +49,9 @@ _DASHBOARD = """<!doctype html>
 *{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--text);font-family:ui-sans-serif,system-ui,Segoe UI,sans-serif}
 main{max-width:900px;margin:0 auto;padding:2rem 1rem}
 h1{font-size:1.3rem;margin:.2rem 0 1rem}h1 span{color:var(--accent)}
+h1 .datalinks{float:right;font-size:.75rem;font-weight:400;color:var(--dim)}
+h1 .datalinks a{color:var(--dim);text-decoration:none;border-bottom:1px dotted var(--dim);cursor:help}
+h1 .datalinks a:hover{color:var(--accent);border-bottom-color:var(--accent)}
 .bar{display:flex;gap:.5rem;flex-wrap:wrap;margin-bottom:1rem}
 input,button,textarea{font:inherit;color:inherit;background:var(--panel);border:1px solid var(--line);border-radius:8px;padding:.5rem .7rem}
 input:focus,textarea:focus{outline:2px solid var(--accent);outline-offset:-1px}
@@ -65,7 +70,8 @@ textarea{width:100%;min-height:70px;margin-bottom:.4rem}
 #map{display:block;width:100%}
 .maphint{color:var(--dim);font-size:.75rem;text-align:center;margin:.15rem 0 .35rem}
 </style></head><body><main>
-<h1><span>Mem</span>ry <small style="color:var(--dim);font-weight:400">memory dashboard</small></h1>
+<h1><span>Mem</span>ry <small style="color:var(--dim);font-weight:400">memory dashboard</small>
+<span class="datalinks"><a href="#" onclick="exportMemories();return false" title="Download memories as a .jsonl file: one JSON object per line with content, categories, user_id, type and importance. Same format as the CLI command memry export. Respects the user_id filter box.">export</a> · <a href="#" id="importbtn" onclick="document.getElementById('importfile').click();return false" title="Additive import from a memry export: a .jsonl file (one JSON object per line) or a JSON array. Each row needs a content field; categories, user_id, memory_type and importance are optional. Nothing is deleted or overwritten.">import</a></span></h1>
 <div id="stats">loading…</div>
 <div class="bar">
   <input id="user" placeholder="user_id (all)" style="width:11rem">
@@ -74,8 +80,6 @@ textarea{width:100%;min-height:70px;margin-bottom:.4rem}
   <button onclick="activeCat=null;loadAll()">All</button>
   <button class="toggle" id="addbtn" onclick="togglePanel('add')">+ Add</button>
   <button class="toggle" id="mapbtn" onclick="togglePanel('map')">Map</button>
-  <button onclick="exportMemories()" title="Download memories as JSONL (respects the user_id filter; same format as `memry export`)">Export</button>
-  <button id="importbtn" onclick="document.getElementById('importfile').click()" title="Additive import from a JSON/JSONL export; nothing is deleted">Import</button>
 </div>
 <input type="file" id="importfile" accept=".json,.jsonl,.txt,application/json" hidden onchange="importMemories(this.files[0]);this.value=''">
 <div id="addpanel" hidden>
@@ -105,8 +109,8 @@ async function api(path, opts={}){
   return r.json();
 }
 function esc(s){return (s??'').replace(/[&<>"]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]))}
-// Add form and category map are opt-in panels; the choice sticks per browser.
-const panels={add:localStorage.getItem('memry_show_add')==='1',map:localStorage.getItem('memry_show_map')==='1'};
+// Add form is opt-in, map is opt-out; the choice sticks per browser.
+const panels={add:localStorage.getItem('memry_show_add')==='1',map:localStorage.getItem('memry_show_map')!=='0'};
 function syncPanels(){
   document.getElementById('addpanel').hidden=!panels.add;
   document.getElementById('addbtn').setAttribute('aria-pressed',panels.add);
@@ -337,8 +341,8 @@ async function exportMemories(){
   a.download='memry-export-'+new Date().toISOString().slice(0,10)+'.jsonl';
   a.click(); URL.revokeObjectURL(a.href);
 }
-// Additive: every row becomes a new verbatim memory (same field mapping as
-// `memry import`); nothing is deleted or deduplicated.
+// Additive: every row becomes a new verbatim memory in ONE bulk request
+// (server batches the embedding calls); nothing is deleted or deduplicated.
 async function importMemories(file){
   if(!file)return;
   const text=((await file.text())||'').trim(); if(!text)return;
@@ -347,21 +351,15 @@ async function importMemories(file){
   catch{alert('Not a valid JSON or JSONL export file.');return}
   if(!Array.isArray(rows))rows=[rows];
   const btn=document.getElementById('importbtn');
-  let ok=0,failed=0;
-  for(const r of rows){
-    const content=String(r.content||'').trim();
-    if(!content){failed++;continue}
-    const body={content,infer:false,
-      user_id:r.user_id||uid()||undefined,
-      memory_type:r.memory_type||'semantic',
-      importance:r.importance??0.5,
-      categories:(r.categories&&r.categories.length)?r.categories:undefined};
-    try{await api('/api/v1/memories',{method:'POST',body:JSON.stringify(body)});ok++}
-    catch{failed++}
-    btn.textContent='Import '+(ok+failed)+'/'+rows.length;
-  }
-  btn.textContent='Import';
-  alert('Imported '+ok+' of '+rows.length+(failed?' ('+failed+' failed or empty)':'')+'.');
+  btn.textContent='importing…';
+  try{
+    const res=await api('/api/v1/import',{method:'POST',
+      body:JSON.stringify({memories:rows,user_id:uid()||undefined})});
+    if(res&&res.imported!==undefined)
+      alert('Imported '+res.imported+' of '+rows.length+(res.skipped?' ('+res.skipped+' empty rows skipped)':'')+'.');
+    else alert((res&&res.error)||'Import failed.');
+  }catch{alert('Import failed.')}
+  btn.textContent='import';
   loadAll(); loadStats();
 }
 async function loadStats(){
@@ -463,7 +461,11 @@ def create_app(store: MemoryStore | None = None) -> Starlette:
         # defaults to config.default_user_id instead of storing NULL, which
         # no scoped read (dashboard, clients) would ever find again. Reads
         # keep None = "all users" as the admin view.
-        result = store.add(
+        # Store calls that hit LLM/embedding providers run in the threadpool:
+        # blocking the event loop would stall every other request for the
+        # duration of a provider round-trip.
+        result = await run_in_threadpool(partial(
+            store.add,
             content,
             user_id=_ns(request.state.tenant, body.get("user_id")) or default_user,
             agent_id=body.get("agent_id"),
@@ -473,7 +475,7 @@ def create_app(store: MemoryStore | None = None) -> Starlette:
             memory_type=body.get("memory_type", "semantic"),
             importance=float(body.get("importance", 0.5)),
             categories=body.get("categories"),
-        )
+        ))
         return JSONResponse(result.model_dump(), status_code=201)
 
     async def get_memory(request: Request) -> Response:
@@ -509,12 +511,38 @@ def create_app(store: MemoryStore | None = None) -> Starlette:
         events = store.history(request.path_params["memory_id"])
         return JSONResponse([e.model_dump() for e in events])
 
+    async def import_memories_route(request: Request) -> Response:
+        """Bulk verbatim import: a JSON array of rows, or {memories: [...],
+        user_id?}. One request instead of one POST per memory."""
+        body = await request.json()
+        rows = body if isinstance(body, list) else body.get("memories")
+        if not isinstance(rows, list) or not rows:
+            return JSONResponse(
+                {"error": "provide a JSON array of rows or {\"memories\": [...]}"},
+                status_code=400,
+            )
+        default_uid = None if isinstance(body, list) else body.get("user_id")
+        tenant = request.state.tenant
+        sanitized = [
+            {**row, "user_id": _ns(tenant, row.get("user_id") or default_uid)}
+            for row in rows
+            if isinstance(row, dict)
+        ]
+        result = await run_in_threadpool(partial(
+            store.import_verbatim,
+            sanitized,
+            user_id=_ns(tenant, default_uid) or default_user,
+        ))
+        return JSONResponse(result, status_code=201)
+
     async def distill_memory(request: Request) -> Response:
         _, error = _memory_or_error(request)
         if error:
             return error
         try:
-            result = store.distill(request.path_params["memory_id"])
+            result = await run_in_threadpool(
+                partial(store.distill, request.path_params["memory_id"])
+            )
         except ValueError as exc:
             return JSONResponse({"error": str(exc)}, status_code=400)
         except Exception as exc:  # LLM/provider failure: report, don't 500
@@ -527,7 +555,8 @@ def create_app(store: MemoryStore | None = None) -> Starlette:
 
     async def search(request: Request) -> Response:
         body = await request.json()
-        results = store.search(
+        results = await run_in_threadpool(partial(
+            store.search,
             body.get("query", ""),
             user_id=_ns(request.state.tenant, body.get("user_id")),
             agent_id=body.get("agent_id"),
@@ -535,7 +564,7 @@ def create_app(store: MemoryStore | None = None) -> Starlette:
             limit=int(body.get("limit", 10)),
             include_invalid=bool(body.get("include_invalid", False)),
             categories=_parse_categories(body.get("categories")),
-        )
+        ))
         return JSONResponse(
             [
                 {"memory": r.memory.model_dump(), "score": r.score, "signals": r.signals}
@@ -545,21 +574,25 @@ def create_app(store: MemoryStore | None = None) -> Starlette:
 
     async def context(request: Request) -> Response:
         body = await request.json()
-        ctx = store.reconstruct_context(
+        ctx = await run_in_threadpool(partial(
+            store.reconstruct_context,
             body.get("query", ""),
             user_id=_ns(request.state.tenant, body.get("user_id")),
             agent_id=body.get("agent_id"),
             run_id=body.get("run_id"),
             token_budget=int(body.get("token_budget", 1200)),
-        )
+        ))
         return JSONResponse(ctx.model_dump())
 
     async def stats(request: Request) -> Response:
-        data = store.stats()
+        data = await run_in_threadpool(store.stats)
         if request.state.tenant is not None:
             prefix = f"{request.state.tenant}::"
+            everything = await run_in_threadpool(
+                partial(store.get_all, include_invalid=True, limit=100_000)
+            )
             mine = [
-                m for m in store.get_all(include_invalid=True, limit=100_000)
+                m for m in everything
                 if (m.user_id or "").startswith(prefix)
             ]
             data = {
@@ -623,9 +656,10 @@ def create_app(store: MemoryStore | None = None) -> Starlette:
 
     async def resolve_entities_route(request: Request) -> Response:
         body = await request.json() if await request.body() else {}
-        outcome = store.resolve_entities(
-            user_id=_ns(request.state.tenant, body.get("user_id"))
-        )
+        outcome = await run_in_threadpool(partial(
+            store.resolve_entities,
+            user_id=_ns(request.state.tenant, body.get("user_id")),
+        ))
         return JSONResponse(outcome)
 
     async def guarded_mcp_app(scope, receive, send):
@@ -680,6 +714,7 @@ def create_app(store: MemoryStore | None = None) -> Starlette:
         Route("/api/v1/memories/{memory_id}", guarded(delete_memory), methods=["DELETE"]),
         Route("/api/v1/memories/{memory_id}/history", guarded(memory_history), methods=["GET"]),
         Route("/api/v1/memories/{memory_id}/distill", guarded(distill_memory), methods=["POST"]),
+        Route("/api/v1/import", guarded(import_memories_route), methods=["POST"]),
         Route("/api/v1/search", guarded(search), methods=["POST"]),
         Route("/api/v1/context", guarded(context), methods=["POST"]),
         Route("/api/v1/stats", guarded(stats), methods=["GET"]),

{memry-0.2.3 → memry-0.2.4}/src/memry/store.py

@@ -24,6 +24,7 @@ from .intelligence.entities import resolve_mentions, resolve_open_proposals
 from .intelligence.extraction import extract_facts, verbatim_candidates
 from .intelligence.reconcile import reconcile_candidate
 from .models import (
+    MEMORY_TYPES,
     AddAction,
     AddResult,
     CandidateFact,
@@ -189,6 +190,99 @@ class MemoryStore:
                 )
         return actions
 
+    def import_verbatim(
+        self, rows: list[dict[str, Any]], *, user_id: str | None = None
+    ) -> dict[str, Any]:
+        """Bulk verbatim import (dashboard/CLI import, restoring exports).
+
+        Rows are trusted as already-curated facts: no extraction, no
+        reconciliation, and embeddings are fetched in batched provider calls,
+        so importing N memories costs O(N/batch) HTTP round-trips instead of
+        two or three per row. Each row needs "content"; user_id, categories,
+        memory_type, and importance are optional (a row's own user_id wins
+        over the call-level default)."""
+        default_uid = user_id or self.config.default_user_id
+        prepared: list[dict[str, Any]] = []
+        skipped = 0
+        for row in rows:
+            content = str(row.get("content") or "").strip()
+            if not content:
+                skipped += 1
+                continue
+            categories = row.get("categories") or []
+            if isinstance(categories, str):
+                categories = [c.strip() for c in categories.split(",") if c.strip()]
+            memory_type = row.get("memory_type", "semantic")
+            if memory_type not in MEMORY_TYPES:
+                memory_type = "semantic"
+            try:
+                importance = float(row.get("importance", 0.5))
+            except (TypeError, ValueError):
+                importance = 0.5
+            prepared.append(
+                {
+                    "content": content,
+                    "user_id": str(row.get("user_id") or default_uid),
+                    "agent_id": row.get("agent_id") or None,
+                    "run_id": row.get("run_id") or None,
+                    "categories": [str(c) for c in categories],
+                    "memory_type": memory_type,
+                    "importance": importance,
+                }
+            )
+        if not prepared:
+            return {"imported": 0, "skipped": skipped, "memory_ids": []}
+
+        episodes = [
+            Episode(
+                content=p["content"],
+                user_id=p["user_id"],
+                agent_id=p["agent_id"],
+                run_id=p["run_id"],
+                metadata={"imported": True},
+            )
+            for p in prepared
+        ]
+        self.backend.add_episodes(episodes)
+
+        vectors: list[list[float] | None] = [None] * len(prepared)
+        if self.embedder.dimensions:
+            chunk = 256  # stay well under provider batch limits
+            for start in range(0, len(prepared), chunk):
+                batch = prepared[start : start + chunk]
+                try:
+                    embedded = self.embedder.embed([p["content"] for p in batch])
+                except Exception:
+                    embedded = []  # import anyway; `memry reindex` can backfill
+                for offset, vec in enumerate(embedded):
+                    vectors[start + offset] = vec or None
+
+        memory_ids: list[str] = []
+        for p, episode, vector in zip(prepared, episodes, vectors):
+            memory = Memory(
+                content=p["content"],
+                memory_type=p["memory_type"],
+                user_id=p["user_id"],
+                agent_id=p["agent_id"],
+                run_id=p["run_id"],
+                importance=p["importance"],
+                categories=p["categories"],
+                source_episode_ids=[episode.id],
+            )
+            if vector:
+                memory.embedding_model = self.embedder.model_id
+            stored = self.backend.insert_memory(memory, vector)
+            self.backend.add_event(
+                MemoryEvent(
+                    memory_id=stored.id,
+                    event="ADD",
+                    new_content=stored.content,
+                    reason="imported",
+                )
+            )
+            memory_ids.append(stored.id)
+        return {"imported": len(memory_ids), "skipped": skipped, "memory_ids": memory_ids}
+
     def distill(self, memory_id: str) -> AddResult | None:
         """Run extraction on a memory that was stored verbatim (LLM missing or
         failing at save time) and replace it with the distilled facts.