@melandlabs/memory-store 0.1.0

package/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 Meland Labs
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,377 @@
+# memory-store (workspace)
+
+> **Workspace package.** Internal monorepo build artifact; not published to npm.
+> End users install [`@melandlabs/opencontext`](https://www.npmjs.com/package/@melandlabs/opencontext)
+> (the facade) instead. Monorepo contributors depend on this package via
+> the workspace protocol.
+
+
+OpenContext memory storage + search SDK with optional HTTP and MCP server
+entry points. The package is intentionally decoupled from the opencontext
+web app's database and env layers — every consumer wires up its own
+implementation via `MemoryStoreConfig`.
+
+- **SDK** (`memory-store`) — embed in a Node.js host
+- **HTTP** (`memory-store/http`) — REST daemon
+- **MCP** (`memory-store/mcp`) — stdio tools for Claude Desktop / Cursor
+
+## Install
+
+```bash
+pnpm add @melandlabs/opencontext
+```
+
+## Quick start
+
+```ts
+import { createMemoryStore } from "memory-store";
+
+const store = await createMemoryStore({
+	db: { getDb: () => drizzleDb() },
+	env: { isTauriMode: () => false },
+	unified: {
+		embedQuery: async ({ query }) => myEmbed(query),
+	},
+});
+
+await store.getRawMessageManager();
+const hits = await store.searchUnifiedMemory({ userId, query });
+```
+
+## Entry points
+
+| Import                           | What you get                                    |
+| -------------------------------- | ----------------------------------------------- |
+| `memory-store`      | `createMemoryStore(config)` facade              |
+| `memory-store/http` | `startHttpServer(options)` — Hono app on a port |
+| `memory-store/mcp`  | `startMcpServer()` — stdio MCP server           |
+
+CLI bins ship with the package:
+
+```bash
+opencontext-memory-http --port 7421 --host 127.0.0.1
+opencontext-memory-mcp
+```
+
+## Configuration matrix
+
+| Key                                                   | Required                        | Description                                               |
+| ----------------------------------------------------- | ------------------------------- | --------------------------------------------------------- |
+| `db.getDb()`                                          | yes for persistence             | Drizzle DB handle factory                                 |
+| `db.tables.rawMessages` / `db.tables.memorySummaries` | yes for postgres backend        | Drizzle table references owned by the host                |
+| `env.isTauriMode()`                                   | yes                             | selects sqlite vs postgres backend                        |
+| `env.getTauriDbPath()` / `env.getTauriDataDir()`      | for Tauri                       | where to place the SQLite files                           |
+| `vector.backend`                                      | one of `sqlite-vec` or `chroma` | vector index backend (auto-detected if omitted)           |
+| `vector.sqliteVec.dbPath`                             | when backend = sqlite-vec       | sqlite-vec DB path                                        |
+| `vector.chroma.url`                                   | when backend = chroma           | chroma server URL                                         |
+| `unified.embedQuery`                                  | yes for unified search          | query embedder                                            |
+| `unified.searchKnowledge`                             | optional                        | RAG over uploaded documents                               |
+| `unified.searchInsights`                              | optional                        | semantic search over extracted insights                   |
+| `unified.searchRawMessagesAnn`                        | optional                        | postgres-side ANN over `raw_messages` (database fallback) |
+| `logger`                                              | optional                        | `console`-shaped logger; defaults to `console`            |
+
+If any of `unified.embedQuery`, `unified.searchKnowledge`, `unified.searchInsights`,
+or `unified.searchRawMessagesAnn` are absent, the corresponding source in
+`searchUnifiedMemory` returns empty results with a warning. The SDK still
+works — fine for a read-only memory daemon or a chroma-only deployment.
+
+See `src/config.ts` for the full type surface.
+
+## Recipes
+
+### 1. Postgres backend (server / agent daemon)
+
+```ts
+import { drizzle } from "drizzle-orm/postgres-js";
+import {
+	createMemoryStore,
+	registerPostgresFactory,
+	type PostgresRawMessageManagerLike,
+} from "memory-store";
+import { myPostgresRawMessageManager } from "./postgres-raw-message-store";
+import * as schema from "./schema";
+
+registerPostgresFactory<typeof myPostgresRawMessageManager>(
+	async () =>
+		myPostgresRawMessageManager as unknown as PostgresRawMessageManagerLike,
+);
+
+const db = drizzle(process.env.DATABASE_URL!, { schema });
+
+const store = await createMemoryStore({
+	db: {
+		getDb: () => db,
+		tables: {
+			rawMessages: schema.rawMessages,
+			memorySummaries: schema.memorySummaries,
+		},
+	},
+	env: { isTauriMode: () => false },
+	unified: {
+		embedQuery: async ({ query }) => myEmbedder.embedQuery(query),
+		searchInsights: mySearchInsights,
+		searchKnowledge: mySearchKnowledge,
+		searchRawMessagesAnn: async ({
+			userId,
+			queryEmbedding,
+			limit,
+			threshold,
+			botId,
+		}) => myAnnSearch({ userId, queryEmbedding, limit, threshold, botId }),
+	},
+});
+```
+
+### 2. Tauri / SQLite-vec backend (desktop)
+
+```ts
+const store = await createMemoryStore({
+	env: {
+		isTauriMode: () => true,
+		getTauriDataDir: () => appDataDir(),
+		getTauriDbPath: () => `${appDataDir()}/memory.sqlite`,
+	},
+	vector: {
+		backend: "sqlite-vec",
+		sqliteVec: { dbPath: `${appDataDir()}/vectors.sqlite` },
+	},
+	unified: {
+		embedQuery: async ({ query }) => localOnnxEmbedder.embed(query),
+	},
+});
+```
+
+### 3. Chroma backend (managed vector store)
+
+```ts
+const store = await createMemoryStore({
+	env: { isTauriMode: () => false },
+	vector: {
+		backend: "chroma",
+		chroma: {
+			url: process.env.CHROMA_URL ?? "http://127.0.0.1:8000",
+			rawMessagesCollection: "opencontext_raw_messages",
+			insightsCollection: "opencontext_insights",
+		},
+	},
+	unified: { embedQuery: myEmbedder },
+});
+```
+
+When chroma is reachable and the host's postgres manager exposes
+`searchMessagesSemantically`, chroma wins and the database path becomes
+the fallback — same semantics as the web app.
+
+### 4. Cross-source search wiring
+
+`createUnifiedSearch(deps)` accepts the per-source searchers independently.
+You don't need to wire all of them; the ones you omit just emit a warning:
+
+```ts
+import { createUnifiedSearch } from "memory-store/unified-search";
+
+const search = createUnifiedSearch({
+	embedQuery: async ({ userId, query, authToken }) =>
+		embedder.embed(query, { userId, authToken }),
+
+	searchRawMessagesAnn: async ({
+		userId,
+		queryEmbedding,
+		limit,
+		threshold,
+		botId,
+	}) =>
+		db.rawMessages.searchAnn({
+			userId,
+			embedding: queryEmbedding,
+			limit,
+			threshold,
+			botId,
+		}),
+
+	searchInsights: async ({ userId, query, limit, threshold, botIds }) =>
+		insightIndex.search({ userId, query, limit, threshold, botIds }),
+
+	searchKnowledge: async ({ userId, query, options, authToken }) =>
+		ragIndex.search({ userId, query, ...options, authToken }),
+});
+
+const result = await search.searchUnifiedMemory({
+	userId: "u-1",
+	query: "what changed since yesterday?",
+	sources: ["memory", "insights", "knowledge"],
+	limit: 10,
+	threshold: 0.7,
+	botIds: ["bot-42"],
+});
+
+// result.results: UnifiedMemorySearchResult[]
+// result.warnings: UnifiedMemorySearchWarning[]
+//   e.g. { source: "memory", code: "raw_message_storage_unavailable", ... }
+```
+
+### 5. Postgres manager factory (lazy registration)
+
+If the host application owns the postgres raw-message manager (e.g. an
+existing Drizzle-based repo), register it via the factory pattern. The
+memory-store package will resolve it on first use:
+
+```ts
+import { registerPostgresFactory } from "memory-store/postgres-raw-message-factory";
+import { myPostgresManager } from "./managers/postgres-raw-message";
+
+registerPostgresFactory(async () => myPostgresManager);
+// Later — anywhere in the codebase:
+import { getRawMessageManager } from "memory-store";
+const manager = await getRawMessageManager();
+```
+
+If you don't register a factory, the package falls back to the legacy
+sqlite path (`env.isTauriMode()` must return true). For non-Tauri hosts,
+registering the factory is mandatory.
+
+### 6. HTTP daemon
+
+```ts
+import { startHttpServer } from "memory-store/http";
+
+const { url, port, stop } = await startHttpServer({
+	port: 7421,
+	host: "127.0.0.1",
+	// MemoryStoreConfig passthrough:
+	env: { isTauriMode: () => false },
+	vector: { backend: "chroma", chroma: { url: process.env.CHROMA_URL! } },
+	unified: { embedQuery: myEmbedder },
+});
+
+console.log(`listening at ${url}`);
+// later: await stop();
+```
+
+Or run the CLI:
+
+```bash
+MEMORY_HTTP_HOST=0.0.0.0 MEMORY_HTTP_PORT=7421 opencontext-memory-http
+```
+
+Endpoints:
+
+| Method + path                          | Body                                                                     |
+| -------------------------------------- | ------------------------------------------------------------------------ |
+| `GET  /health`                         | —                                                                        |
+| `POST /v1/search`                      | `{ userId, query, limit?, threshold?, sources?, botIds?, documentIds? }` |
+| `POST /v1/raw-messages`                | `{ userId, messages: RawMessage[] }`                                     |
+| `GET  /v1/raw-messages/:id?userId=...` | —                                                                        |
+
+For container / LAN deployment, put it behind a reverse proxy:
+
+```nginx
+location /memory/ {
+  proxy_pass         http://127.0.0.1:7421/;
+  proxy_set_header   X-Forwarded-User $remote_user;
+  proxy_read_timeout 60s;
+}
+```
+
+### 7. MCP daemon
+
+```bash
+opencontext-memory-mcp
+```
+
+Tools exposed over stdio:
+
+| Tool                     | Required args                                                                        |
+| ------------------------ | ------------------------------------------------------------------------------------ |
+| `memory.health`          | —                                                                                    |
+| `memory.searchUnified`   | `userId`, `query`, optional `limit`, `threshold`, `sources`, `botIds`, `documentIds` |
+| `memory.writeRawMessage` | `userId`, `message: { role, content, platform?, botId?, ... }`                       |
+| `memory.getRawMessage`   | `userId`, `messageId`                                                                |
+
+#### Claude Desktop (`claude_desktop_config.json`)
+
+```json
+{
+	"mcpServers": {
+		"opencontext-memory": {
+			"command": "npx",
+			"args": ["-y", "memory-store", "memory-mcp"],
+			"env": {
+				"DATABASE_URL": "postgres://user:pass@host:5432/opencontext"
+			}
+		}
+	}
+}
+```
+
+For local dev against this monorepo, point at the built CLI directly:
+
+```json
+{
+	"mcpServers": {
+		"opencontext-memory": {
+			"command": "node",
+			"args": [
+				"/path/to/opencontext/packages/memory-store/dist/server/cli-mcp.js"
+			]
+		}
+	}
+}
+```
+
+#### Cursor
+
+Same shape — Cursor reads `mcpServers` from its MCP settings
+(Cursor → Settings → MCP → Add new global MCP server):
+
+```json
+{
+	"mcpServers": {
+		"opencontext-memory": {
+			"command": "opencontext-memory-mcp"
+		}
+	}
+}
+```
+
+After registering, the four `memory.*` tools become available inside the
+editor. Tool calls appear in the chat like any other MCP tool.
+
+## Subpath exports
+
+| Subpath                                                    | Contents                                                                        |
+| ---------------------------------------------------------- | ------------------------------------------------------------------------------- |
+| `memory-store`                                | `createMemoryStore`, top-level types                                            |
+| `memory-store/http`                           | `startHttpServer`, `StartedHttpServer`                                          |
+| `memory-store/mcp`                            | `startMcpServer`                                                                |
+| `memory-store/unified-search`                 | `createUnifiedSearch(deps)` factory + result types                              |
+| `memory-store/raw-message-store`              | `createRawMessageStore`, `getRawMessageManager`, `isRawMessageStorageAvailable` |
+| `memory-store/sqlite-raw-message-store`       | SQLite-vec raw-message manager (Tauri / desktop)                                |
+| `memory-store/postgres-raw-message-factory`   | `registerPostgresFactory`, `resolvePostgresFactory`                             |
+| `memory-store/sqlite-vector-index`            | Direct sqlite-vec insight index helpers                                         |
+| `memory-store/chroma-memory-index`            | Direct chroma upsert / search helpers                                           |
+| `memory-store/memory-graph-write-policy`      | `resolveMemoryGraphWritePolicy`, allowlist gating                               |
+| `memory-store/memory-graph-correction-policy` | `resolveMemoryGraphCorrectionPolicy`                                            |
+
+## Behaviour notes
+
+- An empty / whitespace `query` short-circuits and returns
+  `{ query, sources, results: [], count: 0, warnings: [] }` without
+  touching any backend.
+- If `isRawMessageStorageAvailable()` returns `false`, the memory source
+  emits a `raw_message_storage_unavailable` warning instead of running
+  Chroma / postgres search.
+- When `botIds` is provided, the memory source fans out across each
+  `botId` filter in parallel (`Promise.all(filters.map(...))`) and
+  flattens the results. If `botIds` is empty, a single unfiltered query
+  is sent.
+- `limit` is passed straight through to each underlying backend — no
+  silent inflation. `threshold` is clamped to `[-1, 1]`.
+- Chroma failures fall back to `unified.searchRawMessagesAnn` when both
+  are configured; otherwise the memory source returns empty.
+
+## See also
+
+- [`docs/architecture.md`](../../docs/architecture.md) — the overall data
+  model, lifecycle, and transport surfaces that the memory primitives
+  plug into.

package/dist/config-MlK9f9CM.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Memory store configuration — injected by the host application.
+ *
+ * The memory-store package is intentionally decoupled from the
+ * opencontext web app's database and env layers. Each consumer wires up
+ * its own implementation of these contracts.
+ *
+ * Required for raw-message persistence:
+ *   - `db.getDb()` — returns a Drizzle DB handle
+ *   - `env.isTauriMode()` — for sqlite vs postgres selection
+ *
+ * Required for vector indexing:
+ *   - one of `vector.sqlite-vec.dbPath` or `vector.chroma.url`
+ *
+ * Required for unified semantic search:
+ *   - `unified.embedQuery` — the embedding provider's query embedder
+ *
+ * Optional for cross-source unified search:
+ *   - `unified.searchKnowledge` — RAG over uploaded documents
+ *   - `unified.searchInsights`   — over extracted insights
+ *
+ * If `unified.*` are absent, the SDK still works but the corresponding
+ * sources in `searchUnifiedMemory` will return empty results with a
+ * warning — fine for a standalone memory daemon.
+ */
+
+interface MemoryStoreDb {
+    /** Resolve the active Drizzle DB handle. Must be server-side. */
+    getDb(): unknown;
+    /** Whether the DB has finished initializing (optional, for startup gating). */
+    isDbInitialized?(): boolean;
+    /** Initialize the DB (optional, called by `createMemoryStore` if present). */
+    initDb?(): unknown;
+    /**
+     * Drizzle table references for the postgres backend. Required when
+     * running outside Tauri mode without a registered factory. The host
+     * application owns the actual schema.
+     */
+    tables?: {
+        rawMessages?: unknown;
+        memorySummaries?: unknown;
+    };
+}
+interface MemoryStoreEnv {
+    /** True when running under Tauri (sqlite local). */
+    isTauriMode(): boolean;
+    /** Where to place the SQLite DB file (Tauri mode only). */
+    getTauriDbPath?(): string;
+    /**
+     * Tauri data dir for mkdirSync. Defaults to dirname(getTauriDbPath()).
+     * Provided so callers that use a custom layout don't need to expose
+     * their internal helpers.
+     */
+    getTauriDataDir?(): string;
+}
+type VectorBackend = "sqlite-vec" | "chroma";
+interface MemoryStoreVectorConfig {
+    /** Active backend selector. Defaults to env-based detection. */
+    backend?: VectorBackend;
+    /** SQLite-vec options (used when backend === "sqlite-vec"). */
+    sqliteVec?: {
+        dbPath?: string;
+        insightsCollection?: string;
+    };
+    /** Chroma options (used when backend === "chroma"). */
+    chroma?: {
+        url?: string;
+        rawMessagesCollection?: string;
+        insightsCollection?: string;
+    };
+}
+type EmbedQueryFn = (input: {
+    userId: string;
+    query: string;
+    authToken?: string;
+}) => Promise<number[]>;
+interface UnifiedSearchKnowledgeResult {
+    chunkId: string;
+    documentId: string;
+    documentName: string;
+    content: string;
+    similarity: number;
+    chunkIndex: number;
+}
+interface UnifiedSearchInsightsResult {
+    id: string;
+    content: string;
+    similarity: number;
+    metadata: Record<string, unknown>;
+}
+interface UnifiedSearchDeps {
+    /** Embed a query string using the active user's provider. */
+    embedQuery?: EmbedQueryFn;
+    /**
+     * Postgres-side ANN search over `raw_messages`. Used when chroma is
+     * not enabled but the host has a postgres-backed manager. If both
+     * chroma and this are absent, the memory source will return empty
+     * (with a warning) in standalone mode.
+     */
+    searchRawMessagesAnn?: (input: {
+        userId: string;
+        queryEmbedding: number[];
+        limit: number;
+        threshold: number;
+        botId?: string;
+    }) => Promise<Array<{
+        id: string;
+        content: string;
+        similarity: number;
+        metadata: Record<string, unknown>;
+    }>>;
+    /** RAG over uploaded knowledge documents. Returns a list of chunk hits. */
+    searchKnowledge?: (input: {
+        userId: string;
+        query: string;
+        options: {
+            limit: number;
+            threshold: number;
+            documentIds?: string[];
+        };
+        authToken?: string;
+    }) => Promise<UnifiedSearchKnowledgeResult[]>;
+    /** Semantic search over extracted insights. */
+    searchInsights?: (input: {
+        userId: string;
+        query: string;
+        limit: number;
+        threshold: number;
+        botIds?: string[];
+        includeArchived?: boolean;
+        authToken?: string;
+    }) => Promise<UnifiedSearchInsightsResult[]>;
+}
+interface MemoryStoreConfig {
+    /** Database handle factory. Required for any persistence. */
+    db?: MemoryStoreDb;
+    /** Environment helpers. Defaults to a process.env-only stub if omitted. */
+    env?: MemoryStoreEnv;
+    /** Vector backend config. Defaults to env-based detection. */
+    vector?: MemoryStoreVectorConfig;
+    /** Optional cross-source search providers. */
+    unified?: UnifiedSearchDeps;
+    /** Optional logger. Defaults to console. */
+    logger?: Pick<Console, "log" | "warn" | "error">;
+}
+
+export type { EmbedQueryFn as E, MemoryStoreConfig as M, UnifiedSearchInsightsResult as U, VectorBackend as V, MemoryStoreDb as a, MemoryStoreEnv as b, UnifiedSearchKnowledgeResult as c, UnifiedSearchDeps as d };

package/dist/contracts.d.ts

@@ -0,0 +1,62 @@
+import { MemoryRecord } from '@melandlabs/ai/memory';
+
+/**
+ * Memory-store contracts — types and constants that were originally re-exported
+ * from `@melandlabs/indexeddb` but pulled in browser-only code (IndexedDB
+ * globals) at module evaluation time, breaking the standalone HTTP/MCP
+ * daemons.
+ *
+ * Anything defined here can be safely imported on the server without any
+ * browser globals being resolved. The `@melandlabs/indexeddb` peer dependency
+ * is optional in `@melandlabs/memory-store/package.json`; consumers can
+ * depend on it directly for IndexedDB-backed storage.
+ *
+ * Re-export from this module is stable. New domain types belong in
+ * dedicated files; this module only hosts the boundary contracts.
+ */
+
+/** Prefix used to reserve chat-memory evidence IDs that must not collide. */
+declare const CHAT_MEMORY_EVIDENCE_ID_PREFIX = "opencontext-chat:";
+/** A locally-defined re-export of the raw-message shape used by the SDK.
+ * Kept as a structural type so consumers (SQLite, postgres factories)
+ * can pass either the IndexedDB `RawMessage` or this shape. */
+interface RawMessage {
+    id?: number;
+    messageId: string;
+    platform: string;
+    botId: string;
+    userId: string;
+    channel?: string;
+    person?: string;
+    timestamp: number;
+    content: string;
+    attachments?: Array<{
+        name: string;
+        url: string;
+        contentType?: string;
+        sizeBytes?: number;
+    }>;
+    embedding?: number[];
+    embeddingModel?: string;
+    embeddingContentHash?: string;
+    embeddingDimensions?: number;
+    embeddingUpdatedAt?: number;
+    metadata?: Record<string, any>;
+    createdAt: number;
+    memoryStage?: "short" | "mid" | "long";
+    accessCount?: number;
+    lastAccessAt?: number;
+    importanceScore?: number;
+    archivedAt?: number;
+    isPinned?: boolean;
+    summaryRefId?: string;
+    deprecatedAt?: number;
+    deprecationReason?: string;
+    supersededBySummaryId?: string;
+}
+/** Convert a RawMessage to a MemoryRecord for embedding. Local copy of the
+ * helper that previously lived in `@melandlabs/indexeddb/embedding` and pulled
+ * in browser-only modules. */
+declare function rawMessageToMemoryRecord(message: RawMessage): MemoryRecord;
+
+export { CHAT_MEMORY_EVIDENCE_ID_PREFIX, type RawMessage, rawMessageToMemoryRecord };

package/dist/contracts.js

@@ -0,0 +1,27 @@
+// src/contracts.ts
+var CHAT_MEMORY_EVIDENCE_ID_PREFIX = "opencontext-chat:";
+function normalizeTimestampToMs(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  if (value < 1e11) {
+    return Math.floor(value * 1e3);
+  }
+  return Math.floor(value);
+}
+function rawMessageToMemoryRecord(message) {
+  return {
+    id: message.messageId,
+    userId: message.userId,
+    timestamp: normalizeTimestampToMs(message.timestamp),
+    text: message.archivedAt ? void 0 : message.content,
+    mediaRefs: message.attachments?.map((item) => item.url).filter(Boolean),
+    embedding: message.embedding,
+    embeddingModel: message.embeddingModel,
+    embeddingContentHash: message.embeddingContentHash
+  };
+}
+
+export { CHAT_MEMORY_EVIDENCE_ID_PREFIX, rawMessageToMemoryRecord };
+//# sourceMappingURL=contracts.js.map
+//# sourceMappingURL=contracts.js.map

package/dist/contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contracts.ts"],"names":[],"mappings":";AAkBO,IAAM,8BAAA,GAAiC;AA0C9C,SAAS,uBAAuB,KAAA,EAAmC;AAClE,EAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA,EAAG;AAC5B,IAAA,OAAO,CAAA;AAAA,EACR;AACA,EAAA,IAAK,QAAmB,IAAA,EAAM;AAC7B,IAAA,OAAO,IAAA,CAAK,KAAA,CAAO,KAAA,GAAmB,GAAI,CAAA;AAAA,EAC3C;AACA,EAAA,OAAO,IAAA,CAAK,MAAM,KAAe,CAAA;AAClC;AAKO,SAAS,yBAAyB,OAAA,EAAmC;AAC3E,EAAA,OAAO;AAAA,IACN,IAAI,OAAA,CAAQ,SAAA;AAAA,IACZ,QAAQ,OAAA,CAAQ,MAAA;AAAA,IAChB,SAAA,EAAW,sBAAA,CAAuB,OAAA,CAAQ,SAAS,CAAA;AAAA,IACnD,IAAA,EAAM,OAAA,CAAQ,UAAA,GAAa,MAAA,GAAY,OAAA,CAAQ,OAAA;AAAA,IAC/C,SAAA,EAAW,OAAA,CAAQ,WAAA,EAAa,GAAA,CAAI,CAAC,SAAS,IAAA,CAAK,GAAG,CAAA,CAAE,MAAA,CAAO,OAAO,CAAA;AAAA,IACtE,WAAW,OAAA,CAAQ,SAAA;AAAA,IACnB,gBAAgB,OAAA,CAAQ,cAAA;AAAA,IACxB,sBAAsB,OAAA,CAAQ;AAAA,GAC/B;AACD","file":"contracts.js","sourcesContent":["/**\n * Memory-store contracts — types and constants that were originally re-exported\n * from `@melandlabs/indexeddb` but pulled in browser-only code (IndexedDB\n * globals) at module evaluation time, breaking the standalone HTTP/MCP\n * daemons.\n *\n * Anything defined here can be safely imported on the server without any\n * browser globals being resolved. The `@melandlabs/indexeddb` peer dependency\n * is optional in `@melandlabs/memory-store/package.json`; consumers can\n * depend on it directly for IndexedDB-backed storage.\n *\n * Re-export from this module is stable. New domain types belong in\n * dedicated files; this module only hosts the boundary contracts.\n */\n\nimport type { MemoryRecord } from \"@melandlabs/ai/memory\";\n\n/** Prefix used to reserve chat-memory evidence IDs that must not collide. */\nexport const CHAT_MEMORY_EVIDENCE_ID_PREFIX = \"opencontext-chat:\";\n\n/** A locally-defined re-export of the raw-message shape used by the SDK.\n * Kept as a structural type so consumers (SQLite, postgres factories)\n * can pass either the IndexedDB `RawMessage` or this shape. */\n// biome-ignore lint/suspicious/noExplicitAny: structural mirror of `@melandlabs/indexeddb/storage`'s `RawMessage`.\nexport interface RawMessage {\n\tid?: number;\n\tmessageId: string;\n\tplatform: string;\n\tbotId: string;\n\tuserId: string;\n\tchannel?: string;\n\tperson?: string;\n\ttimestamp: number;\n\tcontent: string;\n\tattachments?: Array<{\n\t\tname: string;\n\t\turl: string;\n\t\tcontentType?: string;\n\t\tsizeBytes?: number;\n\t}>;\n\tembedding?: number[];\n\tembeddingModel?: string;\n\tembeddingContentHash?: string;\n\tembeddingDimensions?: number;\n\tembeddingUpdatedAt?: number;\n\t// biome-ignore lint/suspicious/noExplicitAny: Preserve the public raw metadata contract.\n\tmetadata?: Record<string, any>;\n\tcreatedAt: number;\n\tmemoryStage?: \"short\" | \"mid\" | \"long\";\n\taccessCount?: number;\n\tlastAccessAt?: number;\n\timportanceScore?: number;\n\tarchivedAt?: number;\n\tisPinned?: boolean;\n\tsummaryRefId?: string;\n\tdeprecatedAt?: number;\n\tdeprecationReason?: string;\n\tsupersededBySummaryId?: string;\n}\n\nfunction normalizeTimestampToMs(value: number | undefined): number {\n\tif (!Number.isFinite(value)) {\n\t\treturn 0;\n\t}\n\tif ((value as number) < 1e11) {\n\t\treturn Math.floor((value as number) * 1000);\n\t}\n\treturn Math.floor(value as number);\n}\n\n/** Convert a RawMessage to a MemoryRecord for embedding. Local copy of the\n * helper that previously lived in `@melandlabs/indexeddb/embedding` and pulled\n * in browser-only modules. */\nexport function rawMessageToMemoryRecord(message: RawMessage): MemoryRecord {\n\treturn {\n\t\tid: message.messageId,\n\t\tuserId: message.userId,\n\t\ttimestamp: normalizeTimestampToMs(message.timestamp),\n\t\ttext: message.archivedAt ? undefined : message.content,\n\t\tmediaRefs: message.attachments?.map((item) => item.url).filter(Boolean),\n\t\tembedding: message.embedding,\n\t\tembeddingModel: message.embeddingModel,\n\t\tembeddingContentHash: message.embeddingContentHash,\n\t} as unknown as MemoryRecord;\n}\n"]}

package/dist/http.d.ts

@@ -0,0 +1,38 @@
+import { M as MemoryStoreConfig } from './config-MlK9f9CM.js';
+
+/**
+ * @melandlabs/memory-store/http — HTTP server entry.
+ *
+ * Usage:
+ *   import { startHttpServer } from "@melandlabs/memory-store/http";
+ *   const { url, stop } = await startHttpServer({
+ *     port: 7421,
+ *     db: { getDb: () => drizzleDb() },
+ *     env: { isTauriMode: () => false },
+ *   });
+ *
+ * Endpoints (all POST, JSON in/out):
+ *   GET  /health            → { ok: true }
+ *   POST /v1/search         → UnifiedMemorySearchOutput
+ *   POST /v1/raw-messages   → upsert raw messages (returns count)
+ *   GET  /v1/raw-messages/:id  → single raw message
+ *
+ * The HTTP server speaks only to the raw-message + vector layers; it does
+ * not expose RAG/insights cross-source search (callers wire those up
+ * server-side or use the MCP server with a fully-wired store).
+ */
+
+interface StartHttpServerOptions extends MemoryStoreConfig {
+    /** Port to bind. Defaults to 7421. */
+    port?: number;
+    /** Bind address. Defaults to 127.0.0.1 (loopback only — change to 0.0.0.0 for LAN). */
+    host?: string;
+}
+interface StartedHttpServer {
+    url: string;
+    port: number;
+    stop(): Promise<void>;
+}
+declare function startHttpServer(options?: StartHttpServerOptions): Promise<StartedHttpServer>;
+
+export { MemoryStoreConfig, type StartHttpServerOptions, type StartedHttpServer, startHttpServer };