memstrand 0.1.0__py3-none-any.whl

memstrand/__init__.py

@@ -0,0 +1,7 @@
+"""memstrand: local-first typed memory for AI agents."""
+
+from .api import Memory
+from .schema import Category, MemoryAtom, MemoryEdge, Provenance, RelationType
+
+__version__ = "0.1.0"
+__all__ = ["Category", "Memory", "MemoryAtom", "MemoryEdge", "Provenance", "RelationType"]

memstrand/api.py

@@ -0,0 +1,182 @@
+"""memstrand public API: remember / recall / improve / forget."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from datetime import UTC
+
+import httpx
+
+from .schema import Category, MemoryAtom, Provenance, RelationType, ScopedQuery
+from .stores.base import GraphStore, SessionStore, VectorStore
+from .stores.graph_kuzu import KuzuGraphStore
+from .stores.sqlite import SqliteSessionStore
+from .stores.vector_qdrant import QdrantVectorStore
+
+
+class Memory:
+    """Local-first typed memory. All LLM calls go to a local endpoint."""
+
+    def __init__(
+        self,
+        qdrant_url: str = "http://localhost:6333",
+        kuzu_path: str = "./kuzu_data",
+        sqlite_path: str = "./memstrand.db",
+        llm_base_url: str | None = None,
+        llm_model: str | None = None,
+        # dependency injection: real backends by default, swappable in tests
+        embedder=None,
+        vector_store: VectorStore | None = None,
+        graph_store: GraphStore | None = None,
+        session_store: SessionStore | None = None,
+    ):
+        if embedder is None:
+            from fastembed import TextEmbedding
+
+            embedder = TextEmbedding()  # local ONNX, no API key
+        self.embedder = embedder
+        self.vectors = vector_store or QdrantVectorStore(url=qdrant_url)
+        self.graph = graph_store or KuzuGraphStore(path=kuzu_path)
+        self.sessions = session_store or SqliteSessionStore(path=sqlite_path)
+        self.llm_base_url = (
+            llm_base_url or os.environ.get("MEMSTRAND_LLM_BASE_URL", "http://localhost:8081/v1")
+        )
+        self.llm_model = llm_model or os.environ.get("MEMSTRAND_LLM_MODEL", "local")
+
+    def _embed(self, text: str) -> list[float]:
+        return next(iter(self.embedder.embed([text])))
+
+    @staticmethod
+    def _atom_id(content: str) -> str:
+        """Content-hash id: identical re-adds are no-ops by construction."""
+        return f"mem:{hashlib.sha256(content.encode()).hexdigest()[:12]}"
+
+    # -- fast write path (L0/L3): no extraction, ~ms -------------------------
+    def remember(
+        self,
+        content: str,
+        category: Category = Category.fact,
+        provenance: Provenance = Provenance.explicit_statement,
+        confidence: float = 0.8,
+        session_id: str | None = None,
+        task_id: str | None = None,
+        host: str | None = None,
+        ttl_days: float | None = None,
+    ) -> MemoryAtom:
+        from datetime import datetime, timedelta
+
+        atom = MemoryAtom(
+            id=self._atom_id(content),
+            category=category,
+            content=content,
+            provenance=provenance,
+            confidence=confidence,
+            session_id=session_id,
+            task_id=task_id,
+            host=host,
+            expires_at=(
+                datetime.now(UTC) + timedelta(days=ttl_days)
+                if ttl_days
+                else None
+            ),
+        )
+        self.vectors.upsert(atom, self._embed(content))
+        self.graph.add_atom(atom)
+        self.sessions.log_provenance(atom.id, "remember", provenance.value)
+        return atom
+
+    # -- scoped read path ----------------------------------------------------
+    def recall(
+        self,
+        query: str,
+        session_id: str | None = None,
+        task_id: str | None = None,
+        host: str | None = None,
+        categories: list[Category] | None = None,
+        limit: int = 10,
+    ) -> list[dict]:
+        """Scope filter is a hard filter. Unscoped queries never see
+        task-scoped atoms — the Playwright-bug fix. Results are hydrated:
+        content, type, provenance, and graph neighbors ride along, and
+        contradictions are surfaced, never hidden."""
+        q = ScopedQuery(
+            text=query, session_id=session_id, task_id=task_id,
+            host=host, categories=categories, limit=limit,
+        )
+        hits = self.vectors.search(self._embed(query), q)
+        results = []
+        for atom_id, score in hits:
+            atom = self.graph.get_atom(atom_id)
+            neighbor_rows = []
+            for n_atom, edge in self.graph.neighbors(atom_id, depth=1):
+                neighbor_rows.append(
+                    {
+                        "id": n_atom.id,
+                        "relation": edge.relation.value,
+                        "content": n_atom.content,
+                        "weight": edge.weight,
+                    }
+                )
+                self.graph.strengthen_edge(atom_id, n_atom.id)  # Hebbian
+            results.append(
+                {
+                    "id": atom_id,
+                    "score": score,
+                    "content": atom.content if atom else None,
+                    "category": atom.category.value if atom else None,
+                    "provenance": atom.provenance.value if atom else None,
+                    "confidence": atom.confidence if atom else None,
+                    "task_id": atom.task_id if atom else None,
+                    "neighbors": neighbor_rows,
+                    "contradictions": [
+                        n for n in neighbor_rows if n["relation"] == RelationType.contradicts.value
+                    ],
+                }
+            )
+        return results
+
+    # -- session lifecycle ---------------------------------------------------
+    def improve(self, session_ids: list[str]) -> dict:
+        """Distill raw sessions into typed permanent memory."""
+        from .pipeline import distill
+
+        return distill.distill_sessions(self, session_ids)
+
+    def forget(self, atom_id: str) -> None:
+        """Delete with provenance-chain cleanup. Never silent."""
+        self.vectors.delete(atom_id)
+        self.graph.delete_atom(atom_id)
+        self.sessions.log_provenance(atom_id, "forget", "explicit user delete")
+        # TODO: propagate to session turns that cited this atom
+
+    # -- grounded answering ---------------------------------------------------
+    def grounded_answer(self, question: str, **recall_kwargs) -> str:
+        """Answer ONLY from stored memories. No retrieval = 'I don't know'."""
+        hits = self.recall(question, **recall_kwargs)
+        if not hits:
+            return "I don't know — nothing in memory covers this."
+        context = "\n".join(
+            f"- [{h['category']}] {h['content']} (score {h['score']:.2f})"
+            for h in hits
+            if h["content"]
+        )
+        if not context:
+            return "I don't know — nothing in memory covers this."
+        resp = httpx.post(
+            f"{self.llm_base_url}/chat/completions",
+            headers={"Authorization": "Bearer <redacted>"},
+            json={
+                "model": self.llm_model,
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": "Answer ONLY from the memories below. "
+                        "If they don't cover the question, say so.",
+                    },
+                    {"role": "user", "content": f"Memories:\n{context}\n\nQ: {question}"},
+                ],
+            },
+            timeout=120,
+        )
+        return resp.json()["choices"][0]["message"]["content"]

memstrand/cli.py

@@ -0,0 +1,38 @@
+"""memstrand CLI."""
+
+from __future__ import annotations
+
+import argparse
+
+from .api import Memory
+from .schema import Category, Provenance
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(prog="memstrand", description="local-first agent memory")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    r = sub.add_parser("remember", help="store one memory")
+    r.add_argument("content")
+    r.add_argument("--category", default="fact", choices=[c.value for c in Category])
+    r.add_argument("--task", default=None)
+
+    q = sub.add_parser("recall", help="scoped recall")
+    q.add_argument("query")
+    q.add_argument("--task", default=None)
+    q.add_argument("--limit", type=int, default=10)
+
+    args = p.parse_args()
+    mem = Memory()
+
+    if args.cmd == "remember":
+        atom = mem.remember(
+            args.content,
+            category=Category(args.category),
+            provenance=Provenance.explicit_statement,
+            task_id=args.task,
+        )
+        print(atom.id)
+    elif args.cmd == "recall":
+        for hit in mem.recall(args.query, task_id=args.task, limit=args.limit):
+            print(f"{hit['score']:.3f}  {hit['id']}")

memstrand/mcp_server.py

@@ -0,0 +1,70 @@
+"""MCP server: memstrand tools for any MCP-compatible agent.
+
+    python -m memstrand.mcp_server
+"""
+
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+from .api import Memory
+from .schema import Category, Provenance
+
+mcp = FastMCP("memstrand")
+_mem: Memory | None = None
+
+
+def _memory() -> Memory:
+    global _mem
+    if _mem is None:
+        _mem = Memory()
+    return _mem
+
+
+@mcp.tool()
+def remember(
+    content: str,
+    category: str = "fact",
+    provenance: str = "explicit_statement",
+    confidence: float = 0.8,
+    session_id: str | None = None,
+    task_id: str | None = None,
+) -> str:
+    """Store one atomic memory."""
+    atom = _memory().remember(
+        content,
+        category=Category(category),
+        provenance=Provenance(provenance),
+        confidence=confidence,
+        session_id=session_id,
+        task_id=task_id,
+    )
+    return atom.id
+
+
+@mcp.tool()
+def recall(
+    query: str,
+    session_id: str | None = None,
+    task_id: str | None = None,
+    limit: int = 10,
+) -> list[dict]:
+    """Scoped semantic recall."""
+    return _memory().recall(
+        query, session_id=session_id, task_id=task_id, limit=limit
+    )
+
+
+@mcp.tool()
+def forget(atom_id: str) -> str:
+    """Delete a memory with provenance logging."""
+    _memory().forget(atom_id)
+    return f"forgot {atom_id}"
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

memstrand/pipeline/__init__.py

@@ -0,0 +1,3 @@
+from . import consolidate, distill, extract
+
+__all__ = ["consolidate", "distill", "extract"]

memstrand/pipeline/consolidate.py

@@ -0,0 +1,47 @@
+"""Sleep consolidation: FSRS + replay + Hebbian decay.
+
+ZenBrain's stealable mechanics, adapted:
+  - per-fact FSRS state {difficulty, stability_days, next_review};
+    retrieval success counts as a review (stability grows)
+  - replay: nightly, pick top-k by
+      0.3*access_freq + 0.3*emotion + 0.2*recency + 0.2*instability,
+    restabilize (stability x1.5, cap 365d)
+  - Hebbian edge decay on a schedule; prune weak EDGES, never facts
+
+Runs as a cron job, not in the request path.
+"""
+
+from __future__ import annotations
+
+import math
+from datetime import UTC, datetime, timedelta
+
+
+def fsrs_recall_probability(stability_days: float, days_since_review: float) -> float:
+    """R = e^(-t/S): probability the fact is still retrievable."""
+    if stability_days <= 0:
+        return 0.0
+    return math.exp(-days_since_review / stability_days)
+
+
+def record_review(atom, success: bool) -> None:
+    """A successful recall strengthens; a miss weakens. Desirable difficulty."""
+    if success:
+        atom.fsrs_stability_days = min(atom.fsrs_stability_days * 1.5, 365.0)
+        atom.fsrs_difficulty = max(atom.fsrs_difficulty - 0.05, 0.1)
+    else:
+        atom.fsrs_stability_days = max(atom.fsrs_stability_days * 0.7, 1.0)
+        atom.fsrs_difficulty = min(atom.fsrs_difficulty + 0.05, 0.9)
+    atom.fsrs_next_review = datetime.now(UTC) + timedelta(
+        days=atom.fsrs_stability_days
+    )
+
+
+def replay_priority(atom) -> float:
+    """Which memories get replayed tonight."""
+    return (
+        0.3 * min(atom.access_count / 10.0, 1.0)
+        + 0.3 * atom.confidence
+        + 0.2 * 1.0  # recency term: compute from updated_at in real impl
+        + 0.2 * atom.fsrs_difficulty
+    )

memstrand/pipeline/distill.py

@@ -0,0 +1,164 @@
+"""Session-end distillation (the 'improve' step).
+
+Cognee's improve() pattern, local-first:
+  1. extract candidate atoms from raw session turns
+  2. dedup by content hash (identical re-add = no-op)
+  3. conflict check: genuinely contradictory atoms become
+     `contradicts` EDGES — additive, both sides stay readable
+  4. promote survivors into L2 (episodic, task-scoped) and
+     L3/L5 (semantic + graph)
+
+Runs async at session end / pre-compact hook. Never blocks the chat loop.
+Idempotent: content-hash ids make a crashed run safe to re-run.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from ..schema import MemoryEdge, Provenance, RelationType
+from .extract import LLMUnavailable, _extract_json_array, chat_completion, extract_atoms
+
+if TYPE_CHECKING:
+    from ..api import Memory
+
+JUDGE_SYSTEM_PROMPT = """\
+You resolve one candidate memory against existing memories.
+Return a single JSON object, nothing else:
+{"action": "add" | "update" | "delete" | "none",
+ "target_id": "<id of the existing memory, or null>",
+ "relation": "supports" | "extends" | "contradicts" | "supersedes" | "related_to",
+ "reason": "<one line>"}
+Rules:
+- "none": the candidate is already covered by an existing memory, or is noise.
+- "update": the candidate replaces or refines the target. The old memory
+  stays queryable, linked by a supersedes edge. Nothing is deleted.
+- "delete": the candidate shows the target memory is WRONG. Store the
+  correction as a new memory linked by a supersedes edge. Nothing is deleted.
+- "contradicts" relation: genuinely contradictory memories both stay
+  readable, joined by a contradicts edge.
+- Default "add" for new information; link it "related_to" the most similar
+  existing memory.\
+"""
+
+
+def _judge(mem: Memory, candidate: dict, existing: list[dict]) -> dict:
+    """ADD/UPDATE/DELETE/NONE resolution (Mem0's pattern)."""
+    if not existing:
+        return {"action": "add", "target_id": None, "relation": "related_to", "reason": "no similar memories"}
+    lines = "\n".join(
+        f"- [{h['id']}] ({h['category']}) {h['content']}" for h in existing if h["content"]
+    )
+    raw = chat_completion(
+        mem.llm_base_url,
+        mem.llm_model,
+        [
+            {"role": "system", "content": JUDGE_SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": (
+                    f"Candidate ({candidate['category'].value}): {candidate['content']}\n"
+                    f"Existing memories:\n{lines}"
+                ),
+            },
+        ],
+        timeout=120.0,
+    )
+    try:
+        verdict = _extract_json_array(f"[{raw}]")[0]
+    except (ValueError, json.JSONDecodeError, IndexError, TypeError, AttributeError):
+        return {"action": "add", "target_id": None, "relation": "related_to", "reason": "judge unparseable; defaulting to add"}
+    action = verdict.get("action", "add")
+    if action not in ("add", "update", "delete", "none"):
+        action = "add"
+    return {
+        "action": action,
+        "target_id": verdict.get("target_id"),
+        "relation": verdict.get("relation", "related_to"),
+        "reason": str(verdict.get("reason", ""))[:200],
+    }
+
+
+def distill_sessions(mem: Memory, session_ids: list[str]) -> dict:
+    """Full implementation. Returns a per-stage report."""
+    report: dict = {
+        "sessions": session_ids,
+        "atoms": 0,
+        "edges": 0,
+        "contradictions": 0,
+        "skipped_dedup": 0,
+        "skipped_none": 0,
+        "errors": [],
+    }
+    for sid in session_ids:
+        turns = mem.sessions.get_session(sid)
+        if not turns:
+            continue
+        task_id = turns[0].get("task_id") or None
+        try:
+            candidates = extract_atoms(turns, mem.llm_base_url, mem.llm_model)
+        except LLMUnavailable as e:
+            report["errors"].append({"session": sid, "error": str(e)})
+            continue  # content-hash ids make a later re-run safe
+        for cand in candidates:
+            atom_id = mem._atom_id(cand["content"])
+            if mem.vectors.exists(atom_id):
+                report["skipped_dedup"] += 1
+                continue
+            similar = [
+                h
+                for h in mem.recall(cand["content"], task_id=task_id, limit=5)
+                if h["score"] is not None and h["score"] >= 0.6 and h["id"] != atom_id
+            ]
+            verdict = _judge(mem, cand, similar)
+            if verdict["action"] == "none":
+                report["skipped_none"] += 1
+                continue
+            provenance = cand["provenance"]
+            if verdict["action"] == "delete":
+                # A retraction is a first-class memory, not a deletion.
+                provenance = Provenance.corrected
+            atom = mem.remember(
+                cand["content"],
+                category=cand["category"],
+                provenance=provenance,
+                confidence=cand["confidence"],
+                session_id=sid,
+                task_id=task_id,
+            )
+            report["atoms"] += 1
+            target = verdict["target_id"]
+            if verdict["action"] in ("update", "delete") and target:
+                mem.graph.add_edge(
+                    MemoryEdge(
+                        source_id=atom.id,
+                        target_id=target,
+                        relation=RelationType.supersedes,
+                        reason=verdict["reason"] or "session distillation",
+                    )
+                )
+                report["edges"] += 1
+            elif verdict["relation"] == "contradicts" and target:
+                mem.graph.add_edge(
+                    MemoryEdge(
+                        source_id=atom.id,
+                        target_id=target,
+                        relation=RelationType.contradicts,
+                        reason=verdict["reason"] or "session distillation",
+                    )
+                )
+                report["edges"] += 1
+                report["contradictions"] += 1
+            elif target and similar:
+                # new information, linked to its neighborhood
+                mem.graph.add_edge(
+                    MemoryEdge(
+                        source_id=atom.id,
+                        target_id=target,
+                        relation=RelationType.related_to,
+                        reason=verdict["reason"] or "same topic",
+                    )
+                )
+                report["edges"] += 1
+    return report

memstrand/pipeline/extract.py

@@ -0,0 +1,124 @@
+"""ECL-lite EXTRACT: session turns -> typed MemoryAtoms.
+
+The 13-category schema IS the extraction contract: the local LLM is
+instructed to emit only valid Category/Provenance values, with a
+confidence per atom. Resolution follows Mem0's pattern:
+ADD / UPDATE / DELETE / NONE per candidate atom (resolved in distill.py).
+
+Every LLM call goes to a local OpenAI-compatible endpoint. Zero keys.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+import httpx
+
+from ..schema import Category, Provenance
+
+EXTRACTION_SYSTEM_PROMPT = """\
+You extract durable memories from a conversation session.
+Emit a JSON list. Each item: {"category": <one of the 13 categories>,
+"content": "<atomic fact>", "provenance": "<how learned>",
+"confidence": <0.0-1.0>}.
+Valid categories: instruction, fact, decision, goal, commitment,
+preference, relationship, context, event, learning, observation,
+artifact, error.
+Valid provenance: explicit_statement, inferred, corrected, validated,
+observed, imported.
+One atomic fact per item. Skip chit-chat and throwaway context.
+Prefer high-signal items. Prefer explicit_statement when the user said
+it directly, observed when it came from tool output, inferred otherwise.
+Keep confidence honest: 0.9+ only for directly stated facts.\
+"""
+
+
+class LLMUnavailable(Exception):
+    """The local LLM endpoint didn't answer. Nothing was written."""
+
+
+def chat_completion(
+    base_url: str, model: str, messages: list[dict], timeout: float = 120.0
+) -> str:
+    """One blocking chat call against a local OpenAI-compatible endpoint."""
+    try:
+        resp = httpx.post(
+            f"{base_url.rstrip('/')}/chat/completions",
+            headers={"Authorization": "Bearer <redacted>"},
+            json={"model": model, "messages": messages, "temperature": 0.1},
+            timeout=timeout,
+        )
+        resp.raise_for_status()
+    except (httpx.ConnectError, httpx.TimeoutException) as e:
+        raise LLMUnavailable(f"local LLM at {base_url} unreachable: {e}") from e
+    try:
+        return resp.json()["choices"][0]["message"]["content"]
+    except (KeyError, IndexError, ValueError) as e:
+        raise LLMUnavailable(f"malformed LLM response from {base_url}: {e}") from e
+
+
+def _extract_json_array(text: str) -> list:
+    """Pull the first JSON array out of free-form model output."""
+    cleaned = text.strip()
+    cleaned = re.sub(r"^```(?:json)?\s*", "", cleaned)
+    cleaned = re.sub(r"\s*```$", "", cleaned)
+    start = cleaned.find("[")
+    end = cleaned.rfind("]")
+    if start == -1 or end == -1 or end <= start:
+        raise ValueError(f"no JSON array in model output: {text[:200]!r}")
+    return json.loads(cleaned[start : end + 1])
+
+
+def _valid_atom(item: dict) -> dict | None:
+    """Schema-contract check. Drops (never invents) malformed candidates."""
+    try:
+        category = Category(item["category"])
+        provenance = Provenance(item.get("provenance", "inferred"))
+        content = str(item["content"]).strip()
+        if not content:
+            return None
+        confidence = float(item.get("confidence", 0.7))
+        confidence = max(0.0, min(1.0, confidence))
+    except (KeyError, ValueError, TypeError):
+        return None
+    return {
+        "category": category,
+        "content": content,
+        "provenance": provenance,
+        "confidence": confidence,
+    }
+
+
+def extract_atoms(
+    session_turns: list[dict],
+    llm_base_url: str,
+    llm_model: str,
+    timeout: float = 180.0,
+) -> list[dict]:
+    """Turns -> validated candidate atom dicts. LLM call goes here."""
+    transcript = "\n".join(
+        f"{t.get('role', 'user').upper()}: {t.get('content', '')}" for t in session_turns
+    )
+    if not transcript.strip():
+        return []
+    raw = chat_completion(
+        llm_base_url,
+        llm_model,
+        [
+            {"role": "system", "content": EXTRACTION_SYSTEM_PROMPT},
+            {"role": "user", "content": f"Session transcript:\n{transcript}"},
+        ],
+        timeout=timeout,
+    )
+    try:
+        items = _extract_json_array(raw)
+    except (ValueError, json.JSONDecodeError):
+        return []  # unparseable extraction = no atoms, not a crash
+    atoms = []
+    for item in items:
+        if isinstance(item, dict):
+            valid = _valid_atom(item)
+            if valid:
+                atoms.append(valid)
+    return atoms

memstrand/schema.py

@@ -0,0 +1,107 @@
+"""memstrand schema: the typed memory contract.
+
+Adapted from Memanto's 13-category typed schema (moorcheh-ai/memanto),
+reimplemented local-first. Every memory atom carries its type, its
+provenance, and its confidence — the three things flat vector memory
+throws away.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from enum import Enum
+from uuid import uuid4
+
+from pydantic import BaseModel, Field
+
+
+class Category(str, Enum):
+    """The 13 typed memory categories."""
+
+    instruction = "instruction"      # durable directives ("always do X")
+    fact = "fact"                    # stable world knowledge
+    decision = "decision"            # a choice that was made + rationale
+    goal = "goal"                    # an outcome being worked toward
+    commitment = "commitment"        # a promise (often with a deadline)
+    preference = "preference"        # likes, dislikes, defaults
+    relationship = "relationship"    # people, roles, how they connect
+    context = "context"              # situational background
+    event = "event"                  # something that happened (timestamped)
+    learning = "learning"            # distilled lesson from experience
+    observation = "observation"      # noticed, not yet verified
+    artifact = "artifact"            # a produced thing (file, doc, link)
+    error = "error"                  # a mistake + what it taught
+
+
+class Provenance(str, Enum):
+    """How this memory was learned. Never trust a memory without one."""
+
+    explicit_statement = "explicit_statement"  # the user said it directly
+    inferred = "inferred"                      # derived by the agent
+    corrected = "corrected"                    # supersedes an earlier atom
+    validated = "validated"                    # confirmed against a source
+    observed = "observed"                      # seen in tool output / behavior
+    imported = "imported"                      # bulk-loaded from elsewhere
+
+
+class RelationType(str, Enum):
+    """Typed edges between memories. Contradictions are edges, never deletes."""
+
+    informs = "informs"
+    supports = "supports"
+    contradicts = "contradicts"      # additive only; both sides stay readable
+    extends = "extends"
+    supersedes = "supersedes"        # new atom replaces old; old stays queryable
+    related_to = "related_to"
+    precedes = "precedes"            # temporal ordering
+    caused_by = "caused_by"
+
+
+class MemoryAtom(BaseModel):
+    """One typed unit of memory. The fundamental unit of the system."""
+
+    id: str = Field(default_factory=lambda: f"mem:{uuid4().hex[:12]}")
+    category: Category
+    content: str
+    provenance: Provenance = Provenance.inferred
+    confidence: float = Field(default=0.7, ge=0.0, le=1.0)
+
+    # scope: the Playwright-bug fix. Retrieval filters on these FIRST.
+    session_id: str | None = None
+    task_id: str | None = None
+    host: str | None = None
+    agent: str | None = None
+
+    # lifecycle
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    expires_at: datetime | None = None   # None = permanent
+    access_count: int = 0
+
+    # FSRS memory-strength state (per-fact forgetting curve)
+    fsrs_difficulty: float = 0.5
+    fsrs_stability_days: float = 30.0
+    fsrs_next_review: datetime | None = None
+
+
+class MemoryEdge(BaseModel):
+    """One typed relationship between two atoms."""
+
+    source_id: str
+    target_id: str
+    relation: RelationType
+    confidence: float = Field(default=0.7, ge=0.0, le=1.0)
+    reason: str = ""                 # why this edge exists (esp. contradicts)
+    weight: float = Field(default=1.0, ge=0.0)  # Hebbian: use strengthens
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class ScopedQuery(BaseModel):
+    """A recall query. Scope is a hard filter, not a ranking signal."""
+
+    text: str
+    session_id: str | None = None
+    task_id: str | None = None
+    host: str | None = None
+    categories: list[Category] | None = None
+    limit: int = 10

memstrand/stores/__init__.py

@@ -0,0 +1,3 @@
+from .base import GraphStore, SessionStore, VectorStore
+
+__all__ = ["GraphStore", "SessionStore", "VectorStore"]

memstrand/stores/base.py

@@ -0,0 +1,48 @@
+"""Store interfaces. All backends are swappable.
+
+The GraphStore protocol exists because Kuzu upstream was archived after
+the Oct 2025 acquisition: pin kuzu==0.11.3 today, swap tomorrow without
+touching anything above this interface.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from ..schema import MemoryAtom, MemoryEdge, ScopedQuery
+
+
+class GraphStore(Protocol):
+    """Typed relationship graph. Kuzu today, something else tomorrow."""
+
+    def add_atom(self, atom: MemoryAtom) -> None: ...
+    def add_edge(self, edge: MemoryEdge) -> None: ...
+    def get_atom(self, atom_id: str) -> MemoryAtom | None: ...
+    def neighbors(
+        self, atom_id: str, relation: str | None = None, depth: int = 1
+    ) -> list[tuple[MemoryAtom, MemoryEdge]]: ...
+    def contradicting(self, atom_id: str) -> list[tuple[MemoryAtom, MemoryEdge]]: ...
+    def strengthen_edge(self, source_id: str, target_id: str, amount: float = 0.1) -> None: ...
+    def decay_edges(self, factor: float = 0.98, prune_below: float = 0.1) -> int: ...
+    def delete_atom(self, atom_id: str) -> None: ...
+
+
+class VectorStore(Protocol):
+    """Semantic similarity over atoms. Qdrant today."""
+
+    def upsert(self, atom: MemoryAtom, embedding: list[float]) -> None: ...
+    def search(
+        self, embedding: list[float], query: ScopedQuery
+    ) -> list[tuple[str, float]]: ...
+    def exists(self, atom_id: str) -> bool: ...
+    def delete(self, atom_id: str) -> None: ...
+
+
+class SessionStore(Protocol):
+    """Fast raw session cache (L1). SQLite today."""
+
+    def append_turn(self, session_id: str, role: str, content: str) -> None: ...
+    def get_session(self, session_id: str) -> list[dict]: ...
+    def list_sessions(self, task_id: str | None = None) -> list[str]: ...
+    def clear_session(self, session_id: str) -> None: ...
+    def log_provenance(self, atom_id: str, action: str, detail: str = "") -> None: ...

memstrand/stores/graph_kuzu.py

@@ -0,0 +1,175 @@
+"""Kuzu-backed GraphStore. Embedded, zero infrastructure.
+
+Pinned to kuzu==0.11.3 (upstream archived Oct 2025). All access goes
+through the GraphStore protocol so a future fork can be swapped in.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+import kuzu
+
+from ..schema import Category, MemoryAtom, MemoryEdge, Provenance, RelationType
+
+
+def _row_to_atom(row: tuple) -> MemoryAtom:
+    (aid, cat, content, prov, conf, sess, task, host, created, expires) = row
+    return MemoryAtom(
+        id=aid,
+        category=Category(cat),
+        content=content,
+        provenance=Provenance(prov),
+        confidence=conf,
+        session_id=sess or None,
+        task_id=task or None,
+        host=host or None,
+        created_at=datetime.fromisoformat(created) if created else datetime.now(UTC),
+        expires_at=datetime.fromisoformat(expires) if expires else None,
+    )
+
+
+def _row_to_edge(row: tuple) -> MemoryEdge:
+    (src, dst, rel, conf, reason, weight) = row
+    return MemoryEdge(
+        source_id=src,
+        target_id=dst,
+        relation=RelationType(rel),
+        confidence=conf,
+        reason=reason or "",
+        weight=weight,
+    )
+
+
+class KuzuGraphStore:
+    def __init__(self, path: str = "./kuzu_data"):
+        self.db = kuzu.Database(path)
+        self.conn = kuzu.Connection(self.db)
+        self._init_schema()
+
+    def _init_schema(self) -> None:
+        self.conn.execute(
+            """CREATE NODE TABLE IF NOT EXISTS Atom(
+                id STRING, category STRING, content STRING,
+                provenance STRING, confidence DOUBLE,
+                session_id STRING, task_id STRING, host STRING,
+                created_at STRING, expires_at STRING,
+                PRIMARY KEY (id))"""
+        )
+        self.conn.execute(
+            """CREATE REL TABLE IF NOT EXISTS LINK(
+                FROM Atom TO Atom,
+                relation STRING, confidence DOUBLE,
+                reason STRING, weight DOUBLE)"""
+        )
+
+    def add_atom(self, atom: MemoryAtom) -> None:
+        self.conn.execute(
+            """MERGE (a:Atom {id: $id})
+               SET a.category=$cat, a.content=$content,
+                   a.provenance=$prov, a.confidence=$conf,
+                   a.session_id=$sess, a.task_id=$task, a.host=$host,
+                   a.created_at=$created,
+                   a.expires_at=$expires""",
+            {
+                "id": atom.id, "cat": atom.category.value,
+                "content": atom.content, "prov": atom.provenance.value,
+                "conf": atom.confidence,
+                "sess": atom.session_id or "", "task": atom.task_id or "",
+                "host": atom.host or "",
+                "created": atom.created_at.isoformat(),
+                "expires": atom.expires_at.isoformat() if atom.expires_at else "",
+            },
+        )
+
+    def add_edge(self, edge: MemoryEdge) -> None:
+        self.conn.execute(
+            """MATCH (a:Atom {id: $src}), (b:Atom {id: $dst})
+               CREATE (a)-[l:LINK {relation: $rel, confidence: $conf,
+                   reason: $reason, weight: $w}]->(b)""",
+            {
+                "src": edge.source_id, "dst": edge.target_id,
+                "rel": edge.relation.value, "conf": edge.confidence,
+                "reason": edge.reason, "w": edge.weight,
+            },
+        )
+
+    def get_atom(self, atom_id: str) -> MemoryAtom | None:
+        """Row -> MemoryAtom hydration. Vector store is still the
+        primary read path; this is the fallback for graph-only reads."""
+        rows = self.conn.execute(
+            """MATCH (a:Atom {id: $id})
+               RETURN a.id, a.category, a.content, a.provenance,
+                      a.confidence, a.session_id, a.task_id, a.host,
+                      a.created_at, a.expires_at""",
+            {"id": atom_id},
+        ).get_all()
+        return _row_to_atom(rows[0]) if rows else None
+
+    def neighbors(
+        self, atom_id: str, relation: str | None = None, depth: int = 1
+    ) -> list[tuple[MemoryAtom, MemoryEdge]]:
+        """Depth-1 neighbor hydration, both directions. relation filters
+        to one edge type (e.g. 'contradicts'). Deeper traversal is a BFS
+        over this primitive — depth>1 expands one hop at a time."""
+        rel_filter = "AND l.relation = $rel" if relation else ""
+        params: dict = {"id": atom_id}
+        if relation:
+            params["rel"] = relation
+        rows = self.conn.execute(
+            f"""MATCH (a:Atom {{id: $id}})-[l:LINK]-(b:Atom)
+                WHERE b.id <> $id {rel_filter}
+                RETURN b.id AS bid, b.category, b.content, b.provenance,
+                       b.confidence, b.session_id, b.task_id, b.host,
+                       b.created_at, b.expires_at,
+                       a.id AS src, b.id AS dst, l.relation, l.confidence, l.reason, l.weight""",
+            params,
+        ).get_all()
+        out = []
+        for r in rows:
+            out.append((_row_to_atom(r[:10]), _row_to_edge(r[10:])))
+        if depth > 1:
+            seen = {atom_id} | {a.id for a, _ in out}
+            frontier = [a.id for a, _ in out]
+            for _ in range(depth - 1):
+                nxt = []
+                for fid in frontier:
+                    for na, ne in self.neighbors(fid, relation=relation, depth=1):
+                        if na.id not in seen:
+                            seen.add(na.id)
+                            out.append((na, ne))
+                            nxt.append(na.id)
+                frontier = nxt
+        return out
+
+    def delete_atom(self, atom_id: str) -> None:
+        """DETACH DELETE: removes the node and all its edges. Facts are
+        never pruned by consolidation, but an explicit forget() removes."""
+        self.conn.execute(
+            "MATCH (a:Atom {id: $id}) DETACH DELETE a", {"id": atom_id}
+        )
+
+    def contradicting(self, atom_id: str) -> list[tuple[MemoryAtom, MemoryEdge]]:
+        return self.neighbors(atom_id, relation="contradicts")
+
+    def strengthen_edge(self, source_id: str, target_id: str, amount: float = 0.1) -> None:
+        """Hebbian: use strengthens the edge, capped."""
+        self.conn.execute(
+            """MATCH (a:Atom {id: $src})-[l:LINK]->(b:Atom {id: $dst})
+               SET l.weight = l.weight + $amt * (1 - l.weight / 10)""",
+            {"src": source_id, "dst": target_id, "amt": amount},
+        )
+
+    def decay_edges(self, factor: float = 0.98, prune_below: float = 0.1) -> int:
+        """Hebbian decay. Prunes weak EDGES — never facts."""
+        self.conn.execute(
+            "MATCH ()-[l:LINK]->() SET l.weight = l.weight * $f",
+            {"f": factor},
+        )
+        result = self.conn.execute(
+            "MATCH ()-[l:LINK]->() WHERE l.weight < $floor "
+            "DELETE l RETURN count(*)",
+            {"floor": prune_below},
+        )
+        row = result.get_next()
+        return int(row[0]) if row else 0

memstrand/stores/sqlite.py

@@ -0,0 +1,58 @@
+"""SQLite: session cache (L1) + provenance ledger. Embedded, zero setup."""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+
+
+class SqliteSessionStore:
+    def __init__(self, path: str = "./memstrand.db"):
+        self.conn = sqlite3.connect(path, check_same_thread=False)
+        self.conn.execute(
+            """CREATE TABLE IF NOT EXISTS turns(
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id TEXT, task_id TEXT, role TEXT,
+                content TEXT, ts REAL)"""
+        )
+        self.conn.execute(
+            """CREATE TABLE IF NOT EXISTS provenance(
+                atom_id TEXT PRIMARY KEY, action TEXT,
+                detail TEXT, ts REAL)"""
+        )
+        self.conn.commit()
+
+    def append_turn(
+        self, session_id: str, role: str, content: str, task_id: str | None = None
+    ) -> None:
+        self.conn.execute(
+            "INSERT INTO turns(session_id, task_id, role, content, ts) VALUES (?,?,?,?,?)",
+            (session_id, task_id or "", role, content, time.time()),
+        )
+        self.conn.commit()
+
+    def get_session(self, session_id: str) -> list[dict]:
+        rows = self.conn.execute(
+            "SELECT role, content, ts, task_id FROM turns WHERE session_id=? ORDER BY ts",
+            (session_id,),
+        ).fetchall()
+        return [{"role": r, "content": c, "ts": t, "task_id": tid} for r, c, t, tid in rows]
+
+    def list_sessions(self, task_id: str | None = None) -> list[str]:
+        q = "SELECT DISTINCT session_id FROM turns"
+        args: tuple = ()
+        if task_id:
+            q += " WHERE task_id=?"
+            args = (task_id,)
+        return [r[0] for r in self.conn.execute(q, args).fetchall()]
+
+    def clear_session(self, session_id: str) -> None:
+        self.conn.execute("DELETE FROM turns WHERE session_id=?", (session_id,))
+        self.conn.commit()
+
+    def log_provenance(self, atom_id: str, action: str, detail: str = "") -> None:
+        self.conn.execute(
+            "INSERT OR REPLACE INTO provenance(atom_id, action, detail, ts) VALUES (?,?,?,?)",
+            (atom_id, action, detail, time.time()),
+        )
+        self.conn.commit()

memstrand/stores/vector_qdrant.py

@@ -0,0 +1,123 @@
+"""Qdrant-backed VectorStore. Scope lives in the payload filter.
+
+Scoping rule (the Playwright-bug fix, enforced here):
+  - task_id / host are HARD filters. When the query carries them, only
+    atoms with the exact same value match. When the query does NOT carry
+    them, only GLOBAL atoms (stored with no task/host) match — an
+    unscoped query can never see task-scoped memories.
+  - session_id is provenance, not a recall filter. Sessions scope the L1
+    fast cache and the distillation provenance; semantic recall is
+    deliberately cross-session within a task (that's rubric test 2).
+"""
+
+from __future__ import annotations
+
+import uuid
+
+from qdrant_client import QdrantClient
+from qdrant_client.models import (
+    Distance,
+    FieldCondition,
+    Filter,
+    MatchValue,
+    PointStruct,
+    VectorParams,
+)
+
+from ..schema import MemoryAtom, ScopedQuery
+
+COLLECTION = "memstrand"
+
+
+def _point_id(atom_id: str) -> str:
+    """Deterministic UUID for a human-readable atom id (mem:abc123...).
+
+    Qdrant's embedded/local mode only accepts UUID or integer point ids,
+    while the server accepts arbitrary strings. UUIDv5 keeps one code
+    path that works on both — the real atom id rides in the payload.
+    """
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, f"memstrand:{atom_id}"))
+
+
+class QdrantVectorStore:
+    def __init__(
+        self,
+        url: str = "http://localhost:6333",
+        dim: int = 384,
+        client: QdrantClient | None = None,
+    ):
+        self.client = client or QdrantClient(url=url)
+        if not self.client.collection_exists(COLLECTION):
+            self.client.create_collection(
+                COLLECTION,
+                vectors_config=VectorParams(size=dim, distance=Distance.COSINE),
+            )
+
+    def _scope_filter(self, query: ScopedQuery) -> Filter | None:
+        must = []
+        # task_id: exact match, or global-only when the query is unscoped.
+        # This is the hard filter that stops cross-task leaks.
+        must.append(
+            FieldCondition(
+                key="task_id",
+                match=MatchValue(value=query.task_id if query.task_id else ""),
+            )
+        )
+        # host: same rule.
+        must.append(
+            FieldCondition(
+                key="host",
+                match=MatchValue(value=query.host if query.host else ""),
+            )
+        )
+        # session_id: deliberately NOT a filter (see module docstring).
+        if query.categories:
+            must.append(
+                FieldCondition(
+                    key="category",
+                    match=MatchValue(value=[c.value for c in query.categories]),
+                )
+            )
+        return Filter(must=must) if must else None
+
+    def upsert(self, atom: MemoryAtom, embedding: list[float]) -> None:
+        self.client.upsert(
+            collection_name=COLLECTION,
+            points=[
+                PointStruct(
+                    id=_point_id(atom.id),
+                    vector=embedding,
+                    payload={
+                        "atom_id": atom.id,
+                        "category": atom.category.value,
+                        "content": atom.content,
+                        "session_id": atom.session_id or "",
+                        "task_id": atom.task_id or "",
+                        "host": atom.host or "",
+                        "confidence": atom.confidence,
+                        "provenance": atom.provenance.value,
+                    },
+                )
+            ],
+        )
+
+    def exists(self, atom_id: str) -> bool:
+        """Content-hash dedup check: is this atom already stored?"""
+        records = self.client.retrieve(
+            collection_name=COLLECTION, ids=[_point_id(atom_id)], with_vectors=False
+        )
+        return len(records) > 0
+
+    def search(self, embedding: list[float], query: ScopedQuery) -> list[tuple[str, float]]:
+        hits = self.client.query_points(
+            collection_name=COLLECTION,
+            query=embedding,
+            query_filter=self._scope_filter(query),
+            limit=query.limit,
+        ).points
+        return [(h.payload["atom_id"], h.score) for h in hits]
+
+    def delete(self, atom_id: str) -> None:
+        self.client.delete(
+            collection_name=COLLECTION, points_selector=[_point_id(atom_id)]
+        )

memstrand-0.1.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.5
+Name: memstrand
+Version: 0.1.0
+Summary: Local-first typed memory for AI agents. Zero API keys.
+Author: Chiran
+License: MIT
+License-File: LICENSE
+Keywords: agents,ai,knowledge-graph,local-first,memory,rag
+Requires-Python: >=3.11
+Requires-Dist: fastembed>=0.3
+Requires-Dist: httpx>=0.27
+Requires-Dist: kuzu==0.11.3
+Requires-Dist: mcp>=1.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: qdrant-client>=1.10
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# memstrand
+
+**Local-first typed memory for AI agents. Zero API keys.**
+
+Two strands, like DNA: one strand holds **facts** (vectors), the other holds **relationships** (graph). Every write joins them base-pair by base-pair — a memory is never stored without its connections, and never retrieved without its scope.
+
+`pip install memstrand` → `remember()` → `recall()` → done. Everything runs on your machine: no cloud, no keys, no telemetry.
+
+## Why
+
+Flat vector memory has three failure modes, and every agent hits all three:
+
+1. **No types** — a preference, a decision, and a guess all look the same to cosine similarity.
+2. **No scope** — a fact learned while testing Playwright leaks into an unrelated Mac disk-cleanup session. (This actually happened. It's why this exists.)
+3. **No provenance** — nobody knows whether a memory was *said*, *inferred*, or *corrected*, or how confident the agent was.
+
+memstrand fixes all three: every memory is **typed** (13 categories), **scoped** (session/task/host), and **carries provenance** (how it was learned, confidence, expiry).
+
+## Quickstart
+
+```bash
+docker compose up -d          # Qdrant (vectors); Kuzu + SQLite are embedded, zero setup
+pip install memstrand
+
+export MEMSTRAND_LLM_BASE_URL=http://localhost:8081/v1   # any OpenAI-compatible local endpoint
+```
+
+```python
+from memstrand import Memory, Category
+
+mem = Memory()
+
+mem.remember(
+    "Chiran prefers a natural, unstylized look in AI portraits",
+    category=Category.preference,
+    provenance="explicit_statement",
+    confidence=0.95,
+)
+
+for hit in mem.recall("what do I know about portrait preferences?"):
+    print(hit.content, hit.score)
+```
+
+## Architecture
+
+Seven layers, deterministic write routing, scoped retrieval:
+
+| Layer | What lives there | Scope |
+|---|---|---|
+| L0 working | live transcript + task/host scope; outranks everything | task |
+| L1 session cache | fast raw Q&A, no extraction, TTL'd | session |
+| L2 episodic | distilled session learnings | task + host |
+| L3 semantic | typed facts, vector-embedded | global |
+| L4 consolidated | curated cross-session synthesis | global |
+| L5 graph | typed edges over everything above | global |
+| L6 procedural | action sequences, workflow patterns, lessons | global |
+
+**Write path** (the session-commit loop): during a session, writes land in L1 with zero extraction cost. At session end (or pre-compact hook), an async distillation pass extracts Memanto-typed atoms via your local LLM, dedups by content hash, checks for conflicts — contradictions become `contradicts` **edges**, never deletions — and promotes into L2/L3/L5.
+
+**Read path:** scope filter *first* (session/task/host is a hard filter, not a ranking signal), then tiered abstracts before full content, graph traversal for multi-hop, and a `grounded_answer()` primitive that answers only from stored memory.
+
+**Memory dynamics** (stolen fair and square, see below): per-fact FSRS strength with a review queue, Hebbian edge weights (use strengthens, disuse decays), and replay consolidation that prunes weak *edges* but never *facts*.
+
+## API
+
+```python
+mem.remember(content, category=..., provenance=..., confidence=..., ttl_days=...)
+mem.recall(query, session_id=..., task_id=..., limit=...)   # scope-aware
+mem.improve(session_ids=[...])    # distill sessions → permanent memory
+mem.forget(memory_id)             # provenance-chain cleanup, never silent
+mem.grounded_answer(question)     # answer ONLY from stored memories
+```
+
+MCP server included: `python -m memstrand.mcp_server` exposes the same surface to Claude Code, Cursor, and friends over stdio.
+
+## Acceptance test
+
+Any memory system should pass these three before you trust it (rubric adapted from a Cognee ad, because it was right):
+
+1. **Remember me in a brand-new chat** without re-pasting anything.
+2. **Search by meaning**, not keywords.
+3. **Connect facts across sessions** — and *don't* leak facts across unrelated tasks (the Playwright test).
+
+## Acknowledgments
+
+Standing on shoulders, with credit:
+
+- **Memanto** (moorcheh-ai/memanto) — the 13-category typed schema, provenance, and confidence model. Their product is cloud-only; this is the schema reimplemented local-first.
+- **Cognee** (topoteretes/cognee) — the pipeline patterns: fast session cache → distillation, joint graph+vector writes, contradictions as additive edges.
+- **ZenBrain** (zensation-ai/zenbrain) — per-fact FSRS, deterministic write routing, replay consolidation, Hebbian edges.
+- **Mem0** — the ADD/UPDATE/DELETE/NONE extraction resolution pattern.
+
+## Roadmap
+
+- [x] Schema + store interfaces + scaffold
+- [x] Session-commit distillation loop (extract → dedup → judge → promote)
+- [x] Scoped retrieval (task/host hard filters; unscoped queries see globals only)
+- [x] Graph neighbor hydration + Hebbian strengthen/decay
+- [ ] FSRS + replay consolidation pass (math is in `pipeline/consolidate.py`, not yet scheduled)
+- [x] MCP server tools (remember/recall/forget)
+- [ ] `memstrand import` — adopt an existing Markdown memory file
+- [x] Benchmarks: the 3-test rubric, automated (`tests/test_memory_flow.py`)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

memstrand-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+memstrand/__init__.py,sha256=J-cleaWApe0UvFDd-Tlce1AmM54YtCgoW_Zh_IdKrys,275
+memstrand/api.py,sha256=ZjIHBXaNqBgFo5P-9td051FOH0beG1iBTlMaohb331A,7173
+memstrand/cli.py,sha256=1uXzsewUPLExWXXIcV8UIGQijyX4dwqCf1nDodGqSNE,1167
+memstrand/mcp_server.py,sha256=8fQXKGenIegybnwTQ0Bl2Fs3hAJZSrR2fLN8BGdLUlU,1419
+memstrand/schema.py,sha256=XO-W_SBfNu5hq3cMCpuVQJJ4e1J-SEv13VULrc4z0tY,4096
+memstrand/pipeline/__init__.py,sha256=fljVr-aZV76vdtkF0RiPCjrzTJWlAKHsOz4c_YF4_BY,93
+memstrand/pipeline/consolidate.py,sha256=O3o-S-wiEBxdar7ZnCaI99N5zIjTQMeYeRXLCGWjpwM,1691
+memstrand/pipeline/distill.py,sha256=Dv07RcwPA9UudZ5yZR-pTPUy97WfC-WU_7rixyzl47M,6483
+memstrand/pipeline/extract.py,sha256=apjtB-VTUbVgvb-gQwS7KG7Q6F9sfEwW89DNHCnIAio,4345
+memstrand/stores/__init__.py,sha256=0RX3YN1vHOyKdmt78-m7qoPtltWjGCK8Ev93y4z4XTQ,113
+memstrand/stores/base.py,sha256=WPZIBmLoROb6xouDUHDfSIBk4KcxzJuXBhaVbJY1uPY,1917
+memstrand/stores/graph_kuzu.py,sha256=ERXm_OZyC3uN61df6xiHI7e-y2Tl_Riz0nypMMuG7Pw,6928
+memstrand/stores/sqlite.py,sha256=eJHGFu1SX8kls-uoM8X6C-W5XVMxdsUipuYRbk3V96Y,2174
+memstrand/stores/vector_qdrant.py,sha256=xnyvyyr3Sno19_iHtxOL2wmYnzFvGXUQUyt3DK_2kZM,4329
+memstrand-0.1.0.dist-info/METADATA,sha256=_GEtFnUPnkqPq5Wk04nYlMyCW7OBh1AEtiJ4fKSC6BE,5783
+memstrand-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+memstrand-0.1.0.dist-info/entry_points.txt,sha256=gc-yoOyQXucR10c1iWk2diHkZNY-oAJMeaurXJE5Apw,49
+memstrand-0.1.0.dist-info/licenses/LICENSE,sha256=Z_DX2HrQCIFVJQN05yay85ejmKlQ4Y8gXpzE2rdc5Os,1063
+memstrand-0.1.0.dist-info/RECORD,,

memstrand-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

memstrand-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+memstrand = memstrand.cli:main

memstrand-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chiran
+
+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.