mnemocyte 0.1.0 → 0.1.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +125 -142
- package/dist/index.d.mts.map +1 -1
- package/dist/index.mjs +181 -44
- package/dist/index.mjs.map +1 -1
- package/package.json +5 -5
package/README.md
CHANGED
|
@@ -1,19 +1,25 @@
|
|
|
1
1
|
# Mnemocyte
|
|
2
2
|
|
|
3
|
-
Persistent memory for TypeScript AI
|
|
3
|
+
Persistent memory for TypeScript AI applications.
|
|
4
4
|
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
5
|
+
Mnemocyte stores small, durable memories for users, agents, sessions, or
|
|
6
|
+
other entities. It provides hybrid retrieval, context formatting, lifecycle
|
|
7
|
+
operations, audit logging, and duplicate-consolidation tools without requiring
|
|
8
|
+
a separate vector database.
|
|
8
9
|
|
|
9
|
-
|
|
10
|
+
> Mnemocyte is early software. APIs may change before v1.0.
|
|
10
11
|
|
|
11
|
-
|
|
12
|
+
## Features
|
|
12
13
|
|
|
13
|
-
-
|
|
14
|
-
-
|
|
14
|
+
- In-memory backend for tests, demos, and short-lived processes.
|
|
15
|
+
- Postgres + pgvector backend for persistent storage.
|
|
16
|
+
- Hybrid recall using vector similarity, lexical matching, recency,
|
|
17
|
+
confidence, access count, and importance.
|
|
18
|
+
- Prompt-ready context output in Markdown, plain text, or XML.
|
|
19
|
+
- Provider timeouts, retries, and `AbortSignal` cancellation.
|
|
20
|
+
- Pruning, duplicate detection, audit logs, and experimental consolidation.
|
|
15
21
|
|
|
16
|
-
|
|
22
|
+
Mnemocyte is ESM-only. Use `import`, not CommonJS `require`.
|
|
17
23
|
|
|
18
24
|
## Install
|
|
19
25
|
|
|
@@ -21,242 +27,218 @@ The package is ESM-only. Use `import` rather than CommonJS `require`.
|
|
|
21
27
|
pnpm add mnemocyte
|
|
22
28
|
```
|
|
23
29
|
|
|
24
|
-
##
|
|
30
|
+
## Quick Start
|
|
25
31
|
|
|
26
32
|
```ts
|
|
27
33
|
import { createMnemocyte } from "mnemocyte";
|
|
28
34
|
|
|
29
35
|
const client = createMnemocyte({
|
|
30
|
-
embedder: {
|
|
31
|
-
model: "demo",
|
|
32
|
-
dimensions: 3,
|
|
33
|
-
async embed(texts) {
|
|
34
|
-
return texts.map((text) => [text.length, 1, 0]);
|
|
35
|
-
},
|
|
36
|
-
},
|
|
36
|
+
embedder: {
|
|
37
|
+
model: "demo",
|
|
38
|
+
dimensions: 3,
|
|
39
|
+
async embed(texts) {
|
|
40
|
+
return texts.map((text) => [text.length, 1, 0]);
|
|
41
|
+
},
|
|
42
|
+
},
|
|
37
43
|
});
|
|
38
44
|
|
|
39
45
|
await client.remember({
|
|
40
|
-
entityId: "user_123",
|
|
41
|
-
content: "Prefers short, direct answers.",
|
|
42
|
-
type: "preference",
|
|
46
|
+
entityId: "user_123",
|
|
47
|
+
content: "Prefers short, direct answers.",
|
|
48
|
+
type: "preference",
|
|
43
49
|
});
|
|
44
50
|
|
|
45
51
|
const memories = await client.recall({
|
|
46
|
-
entityId: "user_123",
|
|
47
|
-
query: "How should I respond?",
|
|
48
|
-
limit: 5,
|
|
49
|
-
explain: true,
|
|
52
|
+
entityId: "user_123",
|
|
53
|
+
query: "How should I respond?",
|
|
54
|
+
limit: 5,
|
|
55
|
+
explain: true,
|
|
50
56
|
});
|
|
51
57
|
|
|
52
58
|
await client.close();
|
|
53
59
|
```
|
|
54
60
|
|
|
55
|
-
|
|
56
|
-
[Pruning memories](#pruning-memories),
|
|
57
|
-
[Finding duplicates](#finding-duplicates-experimental),
|
|
58
|
-
[Audit log](#audit-log-experimental), and
|
|
59
|
-
[Consolidating duplicates](#consolidating-duplicates-experimental).
|
|
61
|
+
When `databaseUrl` is omitted, Mnemocyte uses the in-memory backend.
|
|
60
62
|
|
|
61
|
-
## Postgres
|
|
63
|
+
## Postgres
|
|
62
64
|
|
|
63
|
-
|
|
65
|
+
Apply the bundled migration to a Postgres database with pgvector enabled, then
|
|
66
|
+
pass `databaseUrl`:
|
|
64
67
|
|
|
65
68
|
```ts
|
|
66
69
|
const client = createMnemocyte({
|
|
67
|
-
databaseUrl: process.env.DATABASE_URL,
|
|
68
|
-
embedder, // embedder.dimensions
|
|
70
|
+
databaseUrl: process.env.DATABASE_URL,
|
|
71
|
+
embedder, // embedder.dimensions must be 1536 for the Postgres backend.
|
|
69
72
|
});
|
|
70
73
|
```
|
|
71
74
|
|
|
72
75
|
The published package includes `migrations/0000_initial.sql`.
|
|
73
76
|
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
> pool. The in-memory backend has no such constraint.
|
|
77
|
+
The current Postgres schema uses `embedding vector(1536)`. If
|
|
78
|
+
`embedder.dimensions` is anything else, `createMnemocyte` throws a
|
|
79
|
+
`MnemocyteError` with code `"CONFIG"` before opening the connection pool. The
|
|
80
|
+
in-memory backend does not enforce this constraint.
|
|
79
81
|
|
|
80
|
-
## Provider
|
|
82
|
+
## Provider Resilience
|
|
81
83
|
|
|
82
|
-
Mnemocyte
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
are unaffected.
|
|
84
|
+
Mnemocyte can apply timeouts and retries to embedder calls, and forwards
|
|
85
|
+
`AbortSignal` cancellation to in-flight attempts. Retries and timeouts are
|
|
86
|
+
disabled by default.
|
|
86
87
|
|
|
87
88
|
```ts
|
|
88
89
|
const client = createMnemocyte({
|
|
89
|
-
embedder,
|
|
90
|
-
provider: {
|
|
91
|
-
timeoutMs: 5_000,
|
|
92
|
-
retries: 2,
|
|
93
|
-
baseDelayMs: 200,
|
|
94
|
-
maxDelayMs: 2_000,
|
|
95
|
-
},
|
|
90
|
+
embedder,
|
|
91
|
+
provider: {
|
|
92
|
+
timeoutMs: 5_000,
|
|
93
|
+
retries: 2,
|
|
94
|
+
baseDelayMs: 200,
|
|
95
|
+
maxDelayMs: 2_000,
|
|
96
|
+
},
|
|
96
97
|
});
|
|
97
98
|
|
|
98
99
|
const controller = new AbortController();
|
|
99
100
|
setTimeout(() => controller.abort(), 1_000);
|
|
100
101
|
|
|
101
102
|
await client.remember({
|
|
102
|
-
entityId: "user_123",
|
|
103
|
-
content: "Prefers short answers.",
|
|
104
|
-
signal: controller.signal,
|
|
103
|
+
entityId: "user_123",
|
|
104
|
+
content: "Prefers short answers.",
|
|
105
|
+
signal: controller.signal,
|
|
105
106
|
});
|
|
106
107
|
```
|
|
107
108
|
|
|
108
|
-
|
|
109
|
+
Provider failures surface as `MnemocyteError` values with stable `code`s:
|
|
109
110
|
|
|
110
|
-
- `"TIMEOUT"
|
|
111
|
-
- `"ABORTED"
|
|
112
|
-
- `"EMBEDDING"
|
|
111
|
+
- `"TIMEOUT"`: a provider attempt exceeded `timeoutMs`.
|
|
112
|
+
- `"ABORTED"`: the operation was cancelled via `signal` and is not retried.
|
|
113
|
+
- `"EMBEDDING"`: the embedder failed after retries were exhausted.
|
|
113
114
|
|
|
114
|
-
## Pruning
|
|
115
|
+
## Pruning
|
|
115
116
|
|
|
116
|
-
`prune`
|
|
117
|
-
|
|
117
|
+
`prune` deletes memories matching a filter. At least one selector is required;
|
|
118
|
+
`prune({})` is rejected to avoid accidental full deletion.
|
|
118
119
|
|
|
119
120
|
```ts
|
|
120
|
-
// Drop expired memories for one entity.
|
|
121
121
|
await client.prune({ entityId: "user_123", expired: true });
|
|
122
122
|
|
|
123
|
-
// Evict memories not accessed in the last 30 days, but never drop
|
|
124
|
-
// "high" or "critical" memories.
|
|
125
123
|
await client.prune({
|
|
126
|
-
notAccessedSince: new Date(Date.now() - 30 * 24 * 3600 * 1000),
|
|
127
|
-
maxImportance: "normal",
|
|
124
|
+
notAccessedSince: new Date(Date.now() - 30 * 24 * 3600 * 1000),
|
|
125
|
+
maxImportance: "normal",
|
|
128
126
|
});
|
|
129
127
|
|
|
130
|
-
// Count what would be deleted without touching the store.
|
|
131
128
|
const preview = await client.prune({
|
|
132
|
-
entityId: "user_123",
|
|
133
|
-
superseded: true,
|
|
134
|
-
dryRun: true,
|
|
129
|
+
entityId: "user_123",
|
|
130
|
+
superseded: true,
|
|
131
|
+
dryRun: true,
|
|
135
132
|
});
|
|
136
133
|
console.log(preview.matchedCount);
|
|
137
134
|
```
|
|
138
135
|
|
|
139
136
|
Available selectors: `entityId`, `expired`, `superseded`, `createdBefore`,
|
|
140
|
-
`notAccessedSince`, `types`, `tags`, `maxImportance`.
|
|
137
|
+
`notAccessedSince`, `types`, `tags`, `maxImportance`. Selectors are combined
|
|
138
|
+
with AND semantics.
|
|
141
139
|
|
|
142
|
-
##
|
|
140
|
+
## Duplicate Detection
|
|
143
141
|
|
|
144
|
-
`findDuplicates` is
|
|
145
|
-
memories for one entity using pairwise cosine similarity.
|
|
146
|
-
intentionally passive — nothing is deleted or modified — so callers can
|
|
147
|
-
decide their own consolidation policy.
|
|
142
|
+
`findDuplicates` is an experimental, read-only scan that surfaces
|
|
143
|
+
near-identical memories for one entity using pairwise cosine similarity.
|
|
148
144
|
|
|
149
145
|
```ts
|
|
150
146
|
const pairs = await client.findDuplicates({
|
|
151
|
-
entityId: "user_123",
|
|
152
|
-
threshold: 0.95,
|
|
153
|
-
limit: 50,
|
|
147
|
+
entityId: "user_123",
|
|
148
|
+
threshold: 0.95,
|
|
149
|
+
limit: 50,
|
|
154
150
|
});
|
|
155
151
|
|
|
156
152
|
for (const { a, b, similarity } of pairs) {
|
|
157
|
-
console.log(similarity.toFixed(3), a.content, "<>", b.content);
|
|
153
|
+
console.log(similarity.toFixed(3), a.content, "<>", b.content);
|
|
158
154
|
}
|
|
159
155
|
```
|
|
160
156
|
|
|
161
|
-
Optional selectors: `types`, `tags`
|
|
162
|
-
`
|
|
163
|
-
are excluded by default.
|
|
157
|
+
Optional selectors: `types`, `tags`, `includeSuperseded`, `includeExpired`.
|
|
158
|
+
`types` and `tags` must match on both memories in each pair. Superseded and
|
|
159
|
+
expired memories are excluded by default.
|
|
164
160
|
|
|
165
|
-
|
|
166
|
-
> follow-up releases as conflict detection and active dedup land.
|
|
161
|
+
## Audit Log
|
|
167
162
|
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
When `audit.enabled` is `true`, Mnemocyte records an entry on every
|
|
171
|
-
state-changing operation (`remember`, `forget`, `forgetAll`, `prune`).
|
|
172
|
-
Read with `client.listAuditLog()`.
|
|
163
|
+
When `audit.enabled` is `true`, Mnemocyte records an entry for state-changing
|
|
164
|
+
operations. Read entries with `client.listAuditLog()`.
|
|
173
165
|
|
|
174
166
|
```ts
|
|
175
167
|
const client = createMnemocyte({
|
|
176
|
-
embedder,
|
|
177
|
-
audit: { enabled: true },
|
|
168
|
+
embedder,
|
|
169
|
+
audit: { enabled: true },
|
|
178
170
|
});
|
|
179
171
|
|
|
180
172
|
await client.remember({ entityId: "user_123", content: "Likes tea." });
|
|
181
173
|
await client.prune({ entityId: "user_123", expired: true });
|
|
182
174
|
|
|
183
175
|
const log = await client.listAuditLog({
|
|
184
|
-
entityId: "user_123",
|
|
185
|
-
limit: 100,
|
|
176
|
+
entityId: "user_123",
|
|
177
|
+
limit: 100,
|
|
186
178
|
});
|
|
179
|
+
|
|
187
180
|
for (const event of log) {
|
|
188
|
-
console.log(event.timestamp, event.description, event.metadata);
|
|
181
|
+
console.log(event.timestamp, event.description, event.metadata);
|
|
189
182
|
}
|
|
190
183
|
```
|
|
191
184
|
|
|
192
185
|
Recorded `description` slugs:
|
|
193
186
|
|
|
194
|
-
- `"memory.created"
|
|
195
|
-
- `"memory.deleted"
|
|
196
|
-
- `"entity.cleared"
|
|
197
|
-
- `"memory.pruned"
|
|
198
|
-
|
|
199
|
-
Audit entries are **sticky**: `forgetAll` no longer erases prior log
|
|
200
|
-
entries — wiping an entity is itself a recorded `"entity.cleared"`
|
|
201
|
-
event. Disable audit by leaving `audit.enabled` unset (the default);
|
|
202
|
-
historical entries remain readable.
|
|
187
|
+
- `"memory.created"`: single insert.
|
|
188
|
+
- `"memory.deleted"`: single `forget`.
|
|
189
|
+
- `"entity.cleared"`: `forgetAll`.
|
|
190
|
+
- `"memory.pruned"`: non-dry-run `prune` with an `entityId` selector.
|
|
191
|
+
- `"memory.superseded"`: experimental consolidation.
|
|
203
192
|
|
|
204
|
-
|
|
205
|
-
|
|
193
|
+
Audit entries are sticky: `forgetAll` does not erase prior log entries. Disable
|
|
194
|
+
audit by leaving `audit.enabled` unset.
|
|
206
195
|
|
|
207
|
-
##
|
|
196
|
+
## Consolidation
|
|
208
197
|
|
|
209
|
-
`client.experimental.consolidate()`
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
survivor unless `mergeTags: false`. Idempotent — already-superseded
|
|
213
|
-
memories are skipped.
|
|
214
|
-
|
|
215
|
-
Pair it with `findDuplicates` to build a complete dedup pipeline:
|
|
198
|
+
`client.experimental.consolidate()` marks likely-duplicate memories as
|
|
199
|
+
superseded by a survivor. Superseded memories are excluded from `recall` by
|
|
200
|
+
default. Tags are unioned onto the survivor unless `mergeTags: false`.
|
|
216
201
|
|
|
217
202
|
```ts
|
|
218
203
|
const pairs = await client.findDuplicates({
|
|
219
|
-
entityId: "user_123",
|
|
220
|
-
threshold: 0.97,
|
|
204
|
+
entityId: "user_123",
|
|
205
|
+
threshold: 0.97,
|
|
221
206
|
});
|
|
222
207
|
|
|
223
208
|
for (const { a, b } of pairs) {
|
|
224
|
-
await client.experimental.consolidate({
|
|
225
|
-
entityId: "user_123",
|
|
226
|
-
survivorId: a.id,
|
|
227
|
-
supersededIds: [b.id],
|
|
228
|
-
});
|
|
209
|
+
await client.experimental.consolidate({
|
|
210
|
+
entityId: "user_123",
|
|
211
|
+
survivorId: a.id,
|
|
212
|
+
supersededIds: [b.id],
|
|
213
|
+
});
|
|
229
214
|
}
|
|
230
215
|
```
|
|
231
216
|
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
> The `experimental` namespace is intentionally unstable. Members may
|
|
236
|
-
> change or move to the main client surface in future releases.
|
|
217
|
+
The `experimental` namespace is intentionally unstable. Members may change or
|
|
218
|
+
move before v1.0.
|
|
237
219
|
|
|
238
|
-
## Retrieval
|
|
220
|
+
## Retrieval Tuning
|
|
239
221
|
|
|
240
222
|
```ts
|
|
241
223
|
const client = createMnemocyte({
|
|
242
|
-
embedder,
|
|
243
|
-
retrieval: {
|
|
244
|
-
weights: {
|
|
245
|
-
vector: 0.55,
|
|
246
|
-
lexical: 0.2,
|
|
247
|
-
recency: 0.1,
|
|
248
|
-
confidence: 0.05,
|
|
249
|
-
access: 0.05,
|
|
250
|
-
importance: 0.05,
|
|
251
|
-
},
|
|
252
|
-
recencyHalfLifeDays: 90,
|
|
253
|
-
accessSaturation: 10,
|
|
254
|
-
candidateMultiplier: 3,
|
|
255
|
-
},
|
|
224
|
+
embedder,
|
|
225
|
+
retrieval: {
|
|
226
|
+
weights: {
|
|
227
|
+
vector: 0.55,
|
|
228
|
+
lexical: 0.2,
|
|
229
|
+
recency: 0.1,
|
|
230
|
+
confidence: 0.05,
|
|
231
|
+
access: 0.05,
|
|
232
|
+
importance: 0.05,
|
|
233
|
+
},
|
|
234
|
+
recencyHalfLifeDays: 90,
|
|
235
|
+
accessSaturation: 10,
|
|
236
|
+
candidateMultiplier: 3,
|
|
237
|
+
},
|
|
256
238
|
});
|
|
257
239
|
```
|
|
258
240
|
|
|
259
|
-
## Development
|
|
241
|
+
## Development
|
|
260
242
|
|
|
261
243
|
```bash
|
|
262
244
|
pnpm checktypes
|
|
@@ -270,4 +252,5 @@ pnpm run pack:check
|
|
|
270
252
|
|
|
271
253
|
## Architecture
|
|
272
254
|
|
|
273
|
-
See
|
|
255
|
+
See [ARCHITECTURE.md](./ARCHITECTURE.md) for implementation details and
|
|
256
|
+
[ROADMAP.md](./ROADMAP.md) for planned work.
|
package/dist/index.d.mts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/client.ts","../src/errors.ts"],"mappings":";;AAYA
|
|
1
|
+
{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/client.ts","../src/errors.ts"],"mappings":"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"}
|