mnemekit 0.1.0__tar.gz

mnemekit-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: mnemekit
+Version: 0.1.0
+Summary: A zero-LLM, zero-embedding, cue-indexed tag memory for conversational agents.
+Author: Yam
+License: MIT
+Project-URL: Homepage, https://github.com/FTP2026/Mneme
+Keywords: memory,llm,agent,conversational,retrieval,spreading-activation
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: spacy>=3.7
+Provides-Extra: zh
+Requires-Dist: jieba; extra == "zh"
+Provides-Extra: eval
+Requires-Dist: mem0ai; extra == "eval"
+Requires-Dist: sentence-transformers; extra == "eval"
+Requires-Dist: matplotlib; extra == "eval"
+
+# Mneme
+
+A local, cue-indexed **tag memory** for conversational agents — **no embeddings, no LLM** in the memory path.
+
+Human recall is cue-driven: a partial cue brings back a cluster of related memories that the mind wires into a momentary web and then lets dissolve. Mneme models this. Each turn is tagged deterministically; tags form an inverted index (the cue index); a query reinstates directly-cued turns lexically and then builds an **ephemeral association graph** over them—spreading activation to related turns—which is discarded once the query is answered. No vector DB, no graph DB, no language model.
+
+## Install
+
+```bash
+pip install mnemekit                       # English (default)
+python -m spacy download en_core_web_sm    # required language model
+
+pip install "mnemekit[zh]"                 # + Chinese (adds jieba)
+pip install "mnemekit[eval]"               # + benchmark/baseline deps
+```
+
+`import mneme` regardless of the distribution name.
+
+## Usage
+
+```python
+from mneme import Memory
+
+m = Memory(root="~/.mneme")
+m.remember("My dog Lucky is a golden retriever", "Cute! How old is Lucky?",
+           session_id="chat-42", round_id=1)
+m.recall("what breed is my dog")           # -> [Turn, ...]
+```
+
+- **Structured ids & storage.** `session_id` (default `"default-session"`) + `round_id` form each turn's id; turns are stored one file per round under `{root}/{session_id}/{YYYY-MM-DD}/{round_id}.json`, so a session is easy to inspect, export, or delete.
+- **Chinese.** With `[zh]` installed, Chinese is segmented by `jieba`; pass a custom dictionary for vertical domains: `Memory(userdict="terms.txt")`.
+- **Optional LLM enrichment.** An `enrich(text, source, tags) -> tags` callback can add semantic tags; off by default (the memory path stays LLM-free).
+
+## Design
+
+```
+schema.py  — Tag / Turn / Event records
+extract.py — TagExtractor: spaCy NER+lemmas (en) / jieba.posseg (zh, +userdict)
+thread.py  — Threader: event segmentation + tag inheritance for keyword-free follow-ups
+store.py   — Store: per-session/day turn files + inverted.json + events.json
+recall.py  — Recaller: lexical IDF reinstatement + ephemeral association graph
+memory.py  — Memory: remember() / recall()
+```
+
+Two-stage recall: (1) lexical, IDF-weighted lookup over the inverted index; (2) a per-query association graph seeded by the lexical hits that spreads activation through shared entities and is then discarded. Because information without distinctive cues is never surfaced, forgetting is implicit and cue-dependent.
+
+## Evaluation & paper
+
+See `paper/` for the write-up and `eval/` for the LoCoMo / LongMemEval harness and the controlled mem0 comparison. The frozen reproduction version is on the `paper-repro` branch.

mnemekit-0.1.0/README.md

@@ -0,0 +1,49 @@
+# Mneme
+
+A local, cue-indexed **tag memory** for conversational agents — **no embeddings, no LLM** in the memory path.
+
+Human recall is cue-driven: a partial cue brings back a cluster of related memories that the mind wires into a momentary web and then lets dissolve. Mneme models this. Each turn is tagged deterministically; tags form an inverted index (the cue index); a query reinstates directly-cued turns lexically and then builds an **ephemeral association graph** over them—spreading activation to related turns—which is discarded once the query is answered. No vector DB, no graph DB, no language model.
+
+## Install
+
+```bash
+pip install mnemekit                       # English (default)
+python -m spacy download en_core_web_sm    # required language model
+
+pip install "mnemekit[zh]"                 # + Chinese (adds jieba)
+pip install "mnemekit[eval]"               # + benchmark/baseline deps
+```
+
+`import mneme` regardless of the distribution name.
+
+## Usage
+
+```python
+from mneme import Memory
+
+m = Memory(root="~/.mneme")
+m.remember("My dog Lucky is a golden retriever", "Cute! How old is Lucky?",
+           session_id="chat-42", round_id=1)
+m.recall("what breed is my dog")           # -> [Turn, ...]
+```
+
+- **Structured ids & storage.** `session_id` (default `"default-session"`) + `round_id` form each turn's id; turns are stored one file per round under `{root}/{session_id}/{YYYY-MM-DD}/{round_id}.json`, so a session is easy to inspect, export, or delete.
+- **Chinese.** With `[zh]` installed, Chinese is segmented by `jieba`; pass a custom dictionary for vertical domains: `Memory(userdict="terms.txt")`.
+- **Optional LLM enrichment.** An `enrich(text, source, tags) -> tags` callback can add semantic tags; off by default (the memory path stays LLM-free).
+
+## Design
+
+```
+schema.py  — Tag / Turn / Event records
+extract.py — TagExtractor: spaCy NER+lemmas (en) / jieba.posseg (zh, +userdict)
+thread.py  — Threader: event segmentation + tag inheritance for keyword-free follow-ups
+store.py   — Store: per-session/day turn files + inverted.json + events.json
+recall.py  — Recaller: lexical IDF reinstatement + ephemeral association graph
+memory.py  — Memory: remember() / recall()
+```
+
+Two-stage recall: (1) lexical, IDF-weighted lookup over the inverted index; (2) a per-query association graph seeded by the lexical hits that spreads activation through shared entities and is then discarded. Because information without distinctive cues is never surfaced, forgetting is implicit and cue-dependent.
+
+## Evaluation & paper
+
+See `paper/` for the write-up and `eval/` for the LoCoMo / LongMemEval harness and the controlled mem0 comparison. The frozen reproduction version is on the `paper-repro` branch.

mnemekit-0.1.0/mneme/__init__.py

@@ -0,0 +1,4 @@
+from mneme.schema import Tag, Turn, Event
+from mneme.memory import Memory
+
+__all__ = ["Memory", "Tag", "Turn", "Event"]

mnemekit-0.1.0/mneme/extract.py

@@ -0,0 +1,92 @@
+from functools import lru_cache
+from typing import Callable, Optional
+
+import spacy
+
+from mneme.schema import Tag, TagSource
+
+Enricher = Callable[[str, TagSource, list[Tag]], list[Tag]]
+
+EN_MODEL = "en_core_web_sm"
+CONTENT_POS = {"NOUN", "PROPN", "VERB", "ADJ"}
+SKIP_LABELS = {"DATE", "TIME", "CARDINAL", "ORDINAL", "QUANTITY", "PERCENT"}
+ZH_ENT_FLAGS = {"nr", "ns", "nt", "nz", "eng"}
+ZH_CONTENT_HEADS = ("n", "v", "a")
+ENTITY_WEIGHT = 2.0
+TERM_WEIGHT = 1.0
+CONT_MAX_LEN = 6
+CONT_MARKERS = ("接着", "然后", "继续", "还有", "对了", "顺便", "另外", "所以呢", "后来")
+
+
+@lru_cache(maxsize=2)
+def _en():
+    return spacy.load(EN_MODEL, disable=["parser"]) if spacy.util.is_package(EN_MODEL) else None
+
+
+class TagExtractor:
+
+    def __init__(self, enrich: Optional[Enricher] = None, userdict: Optional[str] = None):
+        self._enrich = enrich
+        self._userdict = userdict
+        self._pseg = None
+
+    def __call__(self, text: str, source: TagSource) -> list[Tag]:
+        if not text.strip():
+            return []
+        tags = self._zh_tags(text, source) if self._has_cjk(text) else self._en_tags(text, source)
+        if self._enrich:
+            tags = self._enrich(text, source, tags)
+        return tags
+
+    def is_continuation(self, text: str) -> bool:
+        t = text.strip()
+        return t.startswith(CONT_MARKERS) or len(t) <= CONT_MAX_LEN
+
+    def _en_tags(self, text: str, source: TagSource) -> list[Tag]:
+        nlp = _en()
+        if nlp is None:
+            return []
+        best: dict[str, Tag] = {}
+        doc = nlp(text)
+        for ent in doc.ents:
+            if ent.label_ not in SKIP_LABELS:
+                self._put(best, ent.text, source, "entity", ENTITY_WEIGHT)
+        for tok in doc:
+            if tok.pos_ in CONTENT_POS and not tok.is_stop and not tok.like_num:
+                self._put(best, tok.lemma_ or tok.text, source, "term", TERM_WEIGHT)
+        return list(best.values())
+
+    def _zh_tags(self, text: str, source: TagSource) -> list[Tag]:
+        pseg = self._zh_seg()
+        if pseg is None:
+            return self._en_tags(text, source)
+        best: dict[str, Tag] = {}
+        for w in pseg.cut(text):
+            if w.flag in ZH_ENT_FLAGS:
+                self._put(best, w.word, source, "entity", ENTITY_WEIGHT)
+            elif w.flag and w.flag[0] in ZH_CONTENT_HEADS:
+                self._put(best, w.word, source, "term", TERM_WEIGHT)
+        return list(best.values())
+
+    def _zh_seg(self):
+        if self._pseg is None:
+            try:
+                import jieba
+                import jieba.posseg as pseg
+            except ImportError:
+                return None
+            if self._userdict:
+                jieba.load_userdict(self._userdict)
+            self._pseg = pseg
+        return self._pseg
+
+    def _put(self, best: dict, raw: str, source: TagSource, kind: str, weight: float) -> None:
+        text = raw.lower().strip()
+        if len(text) < 2:
+            return
+        cur = best.get(text)
+        if cur is None or weight > cur.weight:
+            best[text] = Tag(text, source, kind, weight)
+
+    def _has_cjk(self, text: str) -> bool:
+        return any("一" <= c <= "鿿" for c in text)

mnemekit-0.1.0/mneme/memory.py

@@ -0,0 +1,61 @@
+import os
+import time
+from typing import Optional
+
+from mneme.schema import Turn, Event
+from mneme.extract import TagExtractor, Enricher
+from mneme.thread import Threader
+from mneme.store import Store
+from mneme.recall import Recaller
+
+
+class Memory:
+
+    def __init__(self, root: str = "~/.mneme", enrich: Optional[Enricher] = None, associate: bool = True, userdict: Optional[str] = None):
+        self.store = Store(os.path.expanduser(root))
+        self.extract = TagExtractor(enrich=enrich, userdict=userdict)
+        self.thread = Threader(self.store.last_event())
+        self._recaller = Recaller(self.store, self.extract, associate=associate)
+
+    def remember(
+        self,
+        query: str,
+        response: str,
+        *,
+        session_id: str = "default-session",
+        round_id: Optional[int] = None,
+        ts: Optional[float] = None,
+        event_id: Optional[str] = None,
+    ) -> Turn:
+        ts = ts if ts is not None else time.time()
+        tags = self.extract(query, "user") + self.extract(response, "assistant")
+        if event_id is not None:
+            event, carried = self._fixed_event(event_id, tags, ts)
+        else:
+            event, carried = self.thread.assign(tags, self.extract.is_continuation(query), ts)
+        rid = round_id if round_id is not None else int(time.time() * 1e6)
+        turn = Turn(
+            id=f"{session_id}:{rid}",
+            ts=ts,
+            query=query,
+            response=response,
+            event_id=event.id,
+            tags=carried,
+        )
+        event.turn_ids.append(turn.id)
+        self.store.add_turn(turn)
+        self.store.put_event(event)
+        return turn
+
+    def _fixed_event(self, event_id: str, tags: list, ts: float) -> tuple:
+        texts = {t.text for t in tags}
+        if event := self.store.events.get(event_id):
+            event.tags = sorted(set(event.tags) | texts)
+            return event, tags
+        return Event(id=event_id, ts=ts, tier="STM", tags=sorted(texts), turn_ids=[]), tags
+
+    def recall(self, query: str, topn: int = 5, assoc_n: int = 0) -> list[Turn]:
+        return self._recaller(query, topn, assoc_n)
+
+    def confidence(self, query: str) -> float:
+        return self._recaller.confidence(query)

mnemekit-0.1.0/mneme/recall.py

@@ -0,0 +1,62 @@
+import math
+from collections import defaultdict
+
+from mneme.schema import Tag, Turn
+from mneme.extract import TagExtractor
+from mneme.store import Store
+
+SEED_K = 15
+EXPAND_DF_MAX = 20
+
+
+class Recaller:
+
+    def __init__(self, store: Store, extractor: TagExtractor, associate: bool = True):
+        self.store = store
+        self.extract = extractor
+        self.associate = associate
+
+    def __call__(self, query: str, topn: int = 5, assoc_n: int = 0) -> list[Turn]:
+        seeds = self.extract(query, "user")
+        if not seeds:
+            return []
+        score = self._lexical(seeds)
+        lex = sorted(score, key=score.get, reverse=True)[:topn]
+        if not self.associate or assoc_n <= 0:
+            return [self.store.turns[tid] for tid in lex]
+        extra = self._associate(score, lex, set(lex), assoc_n)
+        return [self.store.turns[tid] for tid in lex + extra]
+
+    def confidence(self, query: str) -> float:
+        seeds = self.extract(query, "user")
+        if not seeds:
+            return 0.0
+        score = self._lexical(seeds)
+        return max(score.values()) if score else 0.0
+
+    def _lexical(self, seeds: list[Tag]) -> dict[str, float]:
+        score: dict[str, float] = defaultdict(float)
+        for t in seeds:
+            idf = self._idf(t.text)
+            for tid in self.store.turns_for(t.text):
+                score[tid] += t.weight * idf
+        return score
+
+    def _associate(self, score: dict[str, float], lex: list[str], seen: set[str], need: int) -> list[str]:
+        strength: dict[str, float] = defaultdict(float)
+        for tid in lex[:SEED_K]:
+            base = score[tid]
+            for tag in self.store.turns[tid].tags:
+                sibs = self.store.turns_for(tag.text)
+                if len(sibs) <= 1 or len(sibs) > EXPAND_DF_MAX:
+                    continue
+                bridge = base * self._idf(tag.text)
+                for nb in sibs:
+                    if nb not in seen:
+                        strength[nb] += bridge
+        return sorted(strength, key=strength.get, reverse=True)[:need]
+
+    def _idf(self, tag: str) -> float:
+        n = len(self.store.turns)
+        df = len(self.store.turns_for(tag))
+        return math.log(1 + n / df) if df else 0.0

mnemekit-0.1.0/mneme/schema.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass, asdict
+from typing import Literal
+
+TagKind = Literal["entity", "term", "time", "emotion"]
+TagSource = Literal["user", "assistant", "event"]
+Tier = Literal["STM", "MTM", "LTM"]
+
+
+@dataclass
+class Tag:
+    text: str
+    source: TagSource
+    kind: TagKind
+    weight: float
+
+
+@dataclass
+class Turn:
+    id: str
+    ts: float
+    query: str
+    response: str
+    event_id: str
+    tags: list[Tag]
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Turn":
+        d = dict(d)
+        d["tags"] = [Tag(**t) for t in d["tags"]]
+        return cls(**d)
+
+
+@dataclass
+class Event:
+    id: str
+    ts: float
+    tier: Tier
+    tags: list[str]
+    turn_ids: list[str]

mnemekit-0.1.0/mneme/store.py

@@ -0,0 +1,63 @@
+import os
+import json
+from glob import glob
+from datetime import datetime
+from dataclasses import asdict
+from typing import Optional
+
+from mneme.schema import Turn, Event
+
+
+class Store:
+
+    def __init__(self, root: str):
+        self.root = root
+        self._events_path = os.path.join(root, "events.json")
+        self._index_path = os.path.join(root, "inverted.json")
+        self.turns: dict[str, Turn] = {}
+        self.events: dict[str, Event] = {}
+        self.index: dict[str, list[str]] = {}
+        self._load()
+
+    def add_turn(self, turn: Turn) -> None:
+        self.turns[turn.id] = turn
+        for t in turn.tags:
+            ids = self.index.setdefault(t.text, [])
+            if turn.id not in ids:
+                ids.append(turn.id)
+        session, _, rnd = turn.id.partition(":")
+        day = datetime.fromtimestamp(turn.ts).strftime("%Y-%m-%d")
+        d = os.path.join(self.root, session, day)
+        os.makedirs(d, exist_ok=True)
+        with open(os.path.join(d, f"{rnd}.json"), "w") as f:
+            json.dump(turn.as_dict(), f, ensure_ascii=False)
+        self._dump(self._index_path, self.index)
+
+    def put_event(self, event: Event) -> None:
+        self.events[event.id] = event
+        self._dump(self._events_path, {k: asdict(v) for k, v in self.events.items()})
+
+    def turns_for(self, tag: str) -> list[str]:
+        return self.index.get(tag, [])
+
+    def last_event(self) -> Optional[Event]:
+        if not self.events:
+            return None
+        return max(self.events.values(), key=lambda e: e.ts)
+
+    def _load(self) -> None:
+        os.makedirs(self.root, exist_ok=True)
+        for path in sorted(glob(os.path.join(self.root, "*", "*", "*.json"))):
+            with open(path) as f:
+                turn = Turn.from_dict(json.load(f))
+                self.turns[turn.id] = turn
+        if os.path.exists(self._events_path):
+            with open(self._events_path) as f:
+                self.events = {k: Event(**v) for k, v in json.load(f).items()}
+        if os.path.exists(self._index_path):
+            with open(self._index_path) as f:
+                self.index = json.load(f)
+
+    def _dump(self, path: str, obj) -> None:
+        with open(path, "w") as f:
+            json.dump(obj, f, ensure_ascii=False)

mnemekit-0.1.0/mneme/thread.py

@@ -0,0 +1,44 @@
+from typing import Optional
+
+from mneme.schema import Tag, Event
+
+JACCARD_TH = 0.15
+GAP_SEC = 30 * 60
+INHERIT_WEIGHT = 0.5
+
+
+class Threader:
+
+    def __init__(self, active: Optional[Event] = None):
+        self._event = active
+
+    def assign(self, tags: list[Tag], is_cont: bool, ts: float) -> tuple[Event, list[Tag]]:
+        texts = {t.text for t in tags}
+        if self._same_event(texts, is_cont, ts):
+            carried = self._inherit(tags)
+            self._event.tags = sorted(set(self._event.tags) | texts)
+            self._event.ts = ts
+            return self._event, carried
+        ev = Event(id=f"e{int(ts * 1e6)}", ts=ts, tier="STM", tags=sorted(texts), turn_ids=[])
+        self._event = ev
+        return ev, tags
+
+    def _same_event(self, texts: set[str], is_cont: bool, ts: float) -> bool:
+        if self._event is None or ts - self._event.ts > GAP_SEC:
+            return False
+        if is_cont:
+            return True
+        return self._jaccard(texts, set(self._event.tags)) >= JACCARD_TH
+
+    def _inherit(self, tags: list[Tag]) -> list[Tag]:
+        have = {t.text for t in tags}
+        carried = list(tags)
+        for txt in self._event.tags:
+            if txt not in have:
+                carried.append(Tag(txt, "event", "term", INHERIT_WEIGHT))
+        return carried
+
+    def _jaccard(self, a: set[str], b: set[str]) -> float:
+        if not a or not b:
+            return 0.0
+        return len(a & b) / len(a | b)

mnemekit-0.1.0/mnemekit.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: mnemekit
+Version: 0.1.0
+Summary: A zero-LLM, zero-embedding, cue-indexed tag memory for conversational agents.
+Author: Yam
+License: MIT
+Project-URL: Homepage, https://github.com/FTP2026/Mneme
+Keywords: memory,llm,agent,conversational,retrieval,spreading-activation
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: spacy>=3.7
+Provides-Extra: zh
+Requires-Dist: jieba; extra == "zh"
+Provides-Extra: eval
+Requires-Dist: mem0ai; extra == "eval"
+Requires-Dist: sentence-transformers; extra == "eval"
+Requires-Dist: matplotlib; extra == "eval"
+
+# Mneme
+
+A local, cue-indexed **tag memory** for conversational agents — **no embeddings, no LLM** in the memory path.
+
+Human recall is cue-driven: a partial cue brings back a cluster of related memories that the mind wires into a momentary web and then lets dissolve. Mneme models this. Each turn is tagged deterministically; tags form an inverted index (the cue index); a query reinstates directly-cued turns lexically and then builds an **ephemeral association graph** over them—spreading activation to related turns—which is discarded once the query is answered. No vector DB, no graph DB, no language model.
+
+## Install
+
+```bash
+pip install mnemekit                       # English (default)
+python -m spacy download en_core_web_sm    # required language model
+
+pip install "mnemekit[zh]"                 # + Chinese (adds jieba)
+pip install "mnemekit[eval]"               # + benchmark/baseline deps
+```
+
+`import mneme` regardless of the distribution name.
+
+## Usage
+
+```python
+from mneme import Memory
+
+m = Memory(root="~/.mneme")
+m.remember("My dog Lucky is a golden retriever", "Cute! How old is Lucky?",
+           session_id="chat-42", round_id=1)
+m.recall("what breed is my dog")           # -> [Turn, ...]
+```
+
+- **Structured ids & storage.** `session_id` (default `"default-session"`) + `round_id` form each turn's id; turns are stored one file per round under `{root}/{session_id}/{YYYY-MM-DD}/{round_id}.json`, so a session is easy to inspect, export, or delete.
+- **Chinese.** With `[zh]` installed, Chinese is segmented by `jieba`; pass a custom dictionary for vertical domains: `Memory(userdict="terms.txt")`.
+- **Optional LLM enrichment.** An `enrich(text, source, tags) -> tags` callback can add semantic tags; off by default (the memory path stays LLM-free).
+
+## Design
+
+```
+schema.py  — Tag / Turn / Event records
+extract.py — TagExtractor: spaCy NER+lemmas (en) / jieba.posseg (zh, +userdict)
+thread.py  — Threader: event segmentation + tag inheritance for keyword-free follow-ups
+store.py   — Store: per-session/day turn files + inverted.json + events.json
+recall.py  — Recaller: lexical IDF reinstatement + ephemeral association graph
+memory.py  — Memory: remember() / recall()
+```
+
+Two-stage recall: (1) lexical, IDF-weighted lookup over the inverted index; (2) a per-query association graph seeded by the lexical hits that spreads activation through shared entities and is then discarded. Because information without distinctive cues is never surfaced, forgetting is implicit and cue-dependent.
+
+## Evaluation & paper
+
+See `paper/` for the write-up and `eval/` for the LoCoMo / LongMemEval harness and the controlled mem0 comparison. The frozen reproduction version is on the `paper-repro` branch.

mnemekit-0.1.0/mnemekit.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+mneme/__init__.py
+mneme/extract.py
+mneme/memory.py
+mneme/recall.py
+mneme/schema.py
+mneme/store.py
+mneme/thread.py
+mnemekit.egg-info/PKG-INFO
+mnemekit.egg-info/SOURCES.txt
+mnemekit.egg-info/dependency_links.txt
+mnemekit.egg-info/requires.txt
+mnemekit.egg-info/top_level.txt

mnemekit-0.1.0/mnemekit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mnemekit-0.1.0/mnemekit.egg-info/requires.txt

@@ -0,0 +1,9 @@
+spacy>=3.7
+
+[eval]
+mem0ai
+sentence-transformers
+matplotlib
+
+[zh]
+jieba

mnemekit-0.1.0/mnemekit.egg-info/top_level.txt

@@ -0,0 +1 @@
+mneme

mnemekit-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mnemekit"
+version = "0.1.0"
+description = "A zero-LLM, zero-embedding, cue-indexed tag memory for conversational agents."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Yam" }]
+keywords = ["memory", "llm", "agent", "conversational", "retrieval", "spreading-activation"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = ["spacy>=3.7"]
+
+[project.optional-dependencies]
+zh = ["jieba"]
+eval = ["mem0ai", "sentence-transformers", "matplotlib"]
+
+[project.urls]
+Homepage = "https://github.com/FTP2026/Mneme"
+
+[tool.setuptools]
+packages = ["mneme"]

mnemekit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+