vektor-slipstream 1.4.4 → 2.0.0

package/export-import.js

@@ -1,221 +0,0 @@
-/**
- * VEKTOR memory.export() / memory.import() — v1.3.7
- * Full graph serialisation — backup, migration, agent sharing.
- *
- * Gemini review fixes applied (round 2):
- *   Fix 1 — SQL subqueries replace IN (...memIds) — no more 32,766 param limit crash
- *   Fix 2 — O(N) loop in replace mode → bulk subquery deletes
- *   Fix 3 — Checksum hashes full memories payload, not just IDs
- *   Fix 4 — Dangling edge guard — edges only inserted if both endpoints exist
- */
-
-import { createHash } from 'crypto';
-import { VektorError, ERR } from './errors.js';
-
-const EXPORT_VERSION = '1.3.7';
-
-function resolveSinceTs(since) {
-  if (!since) return null;
-  if (typeof since === 'number') {
-    return since > 9_999_999_999 ? Math.floor(since / 1000) : since;
-  }
-  const rel = String(since).match(/^(\d+)(d|h|m)$/);
-  if (rel) {
-    const n = parseInt(rel[1]);
-    const mult = rel[2] === 'd' ? 86400 : rel[2] === 'h' ? 3600 : 60;
-    return Math.floor(Date.now() / 1000) - n * mult;
-  }
-  const ts = Date.parse(since);
-  if (!isNaN(ts)) return Math.floor(ts / 1000);
-  throw new VektorError(ERR.EXPORT_FAILED, `Invalid since value: "${since}"`);
-}
-
-export function exportMemory(db, agentId, namespace, opts = {}) {
-  const { includeEmbeddings = false, since = null } = opts;
-  const sinceTs  = resolveSinceTs(since);
-  const sinceSQL = sinceTs ? `AND created_at >= ${sinceTs}` : '';
-  const embedCol = includeEmbeddings ? ', embedding' : '';
-
-  const memories = db.prepare(`
-    SELECT id, content, summary, importance, pinned,
-           namespace, created_at, updated_at${embedCol}
-    FROM memories
-    WHERE agent_id = ? AND namespace = ? ${sinceSQL}
-    ORDER BY created_at ASC
-  `).all(agentId, namespace);
-
-  if (memories.length === 0) {
-    throw new VektorError(ERR.EXPORT_FAILED,
-      `No memories found for agent "${agentId}" in namespace "${namespace}"`);
-  }
-
-  // Fix 1 — subquery replaces IN (...memIds) placeholders
-  // SQLite hard limit is 32,766 bound params — a 16,500 memory export would crash the old code
-  const edges = db.prepare(`
-    SELECT id, source_id, target_id, edge_type, weight, created_at
-    FROM graph_edges
-    WHERE source_id IN (SELECT id FROM memories WHERE agent_id = ? AND namespace = ? ${sinceSQL})
-       OR target_id IN (SELECT id FROM memories WHERE agent_id = ? AND namespace = ? ${sinceSQL})
-  `).all(agentId, namespace, agentId, namespace);
-
-  let entityMentions = [], entities = [];
-  try {
-    entityMentions = db.prepare(`
-      SELECT memory_id, entity_id FROM entity_mentions
-      WHERE memory_id IN (SELECT id FROM memories WHERE agent_id = ? AND namespace = ? ${sinceSQL})
-    `).all(agentId, namespace);
-    entities = db.prepare(`SELECT * FROM entities`).all();
-  } catch { /* entity tables may not exist */ }
-
-  let audnLog = [];
-  try {
-    audnLog = db.prepare(`
-      SELECT action, memory_id, content, reason, similarity, ran_at
-      FROM audn_log WHERE agent_id = ? AND namespace = ?
-      ORDER BY ran_at DESC LIMIT 1000
-    `).all(agentId, namespace);
-  } catch { /* audn_log may not exist */ }
-
-  // Fix 3 — hash full memories payload, not just IDs
-  // Previously content tampering went undetected — only IDs were hashed
-  const checksum = createHash('sha256')
-    .update(JSON.stringify(memories))
-    .digest('hex')
-    .slice(0, 16);
-
-  return {
-    _vektor: { version: EXPORT_VERSION, exported_at: new Date().toISOString(),
-               agent_id: agentId, namespace, checksum,
-               counts: { memories: memories.length, edges: edges.length, entities: entities.length } },
-    memories, edges, entities, entityMentions, audnLog
-  };
-}
-
-export function importMemory(db, agentId, bundle, opts = {}) {
-  const { namespace = null, mode = 'merge', dryRun = false } = opts;
-
-  if (!bundle?._vektor?.version) {
-    throw new VektorError(ERR.IMPORT_SCHEMA_MISMATCH, 'Invalid export bundle — missing _vektor header');
-  }
-
-  const targetNamespace = namespace || bundle._vektor.namespace;
-  if (!targetNamespace) throw new VektorError(ERR.IMPORT_FAILED, 'No target namespace specified');
-  if (!Array.isArray(bundle.memories) || bundle.memories.length === 0) {
-    throw new VektorError(ERR.IMPORT_FAILED, 'Bundle contains no memories');
-  }
-
-  // Fix 3 — verify full-payload checksum (same serialisation as export)
-  const checksum = createHash('sha256')
-    .update(JSON.stringify(bundle.memories))
-    .digest('hex')
-    .slice(0, 16);
-
-  if (checksum !== bundle._vektor.checksum) {
-    throw new VektorError(ERR.IMPORT_SCHEMA_MISMATCH,
-      `Checksum mismatch — bundle may be corrupted or tampered.\n` +
-      `Expected: ${bundle._vektor.checksum}  Got: ${checksum}`);
-  }
-
-  if (dryRun) {
-    return { dryRun: true, would_import: bundle.memories.length,
-             would_add_edges: bundle.edges?.length ?? 0,
-             target_namespace: targetNamespace,
-             source_version: bundle._vektor.version, checksum_valid: true };
-  }
-
-  const doImport = db.transaction(() => {
-    let imported = 0, skipped = 0, edgesAdded = 0, edgesSkipped = 0;
-
-    // Fix 2 — replace mode: bulk subquery deletes, not O(N) JS loop
-    if (mode === 'replace') {
-      db.prepare(`
-        DELETE FROM graph_edges
-        WHERE source_id IN (SELECT id FROM memories WHERE agent_id = ? AND namespace = ?)
-           OR target_id IN (SELECT id FROM memories WHERE agent_id = ? AND namespace = ?)
-      `).run(agentId, targetNamespace, agentId, targetNamespace);
-
-      db.prepare(`
-        DELETE FROM entity_mentions
-        WHERE memory_id IN (SELECT id FROM memories WHERE agent_id = ? AND namespace = ?)
-      `).run(agentId, targetNamespace);
-
-      db.prepare(`DELETE FROM memories WHERE agent_id = ? AND namespace = ?`)
-        .run(agentId, targetNamespace);
-    }
-
-    const insertMem = db.prepare(`
-      INSERT INTO memories
-        (id, agent_id, namespace, content, summary, importance, pinned, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO NOTHING
-    `);
-
-    for (const m of bundle.memories) {
-      const r = insertMem.run(
-        m.id, agentId, targetNamespace,
-        m.content, m.summary ?? null, m.importance ?? 0.5, m.pinned ?? 0,
-        m.created_at, m.updated_at ?? null
-      );
-      if (r.changes > 0) imported++; else skipped++;
-    }
-
-    // Fix 4 — dangling edge guard
-    // Partial exports (since: '7d') may reference memories older than the export window.
-    // INSERT ... SELECT ... WHERE EXISTS ensures we never write an edge pointing to a ghost node.
-    const insertEdge = db.prepare(`
-      INSERT INTO graph_edges (id, source_id, target_id, edge_type, weight, created_at)
-      SELECT ?, ?, ?, ?, ?, ?
-      WHERE EXISTS (SELECT 1 FROM memories WHERE id = ?)
-        AND EXISTS (SELECT 1 FROM memories WHERE id = ?)
-      ON CONFLICT(id) DO NOTHING
-    `);
-
-    for (const e of bundle.edges ?? []) {
-      const r = insertEdge.run(
-        e.id, e.source_id, e.target_id, e.edge_type, e.weight, e.created_at,
-        e.source_id, e.target_id
-      );
-      if (r.changes > 0) edgesAdded++; else edgesSkipped++;
-    }
-
-    if (bundle.entities?.length) {
-      const insertEntity = db.prepare(`
-        INSERT INTO entities (id, canonical, type, confidence, created_at)
-        VALUES (?, ?, ?, ?, ?)
-        ON CONFLICT(id) DO NOTHING
-      `);
-      for (const e of bundle.entities) {
-        try { insertEntity.run(e.id, e.canonical, e.type ?? 'unknown', e.confidence ?? 1.0, e.created_at); }
-        catch { /* entity table may not exist */ }
-      }
-    }
-
-    return { imported, skipped, edgesAdded, edgesSkipped };
-  });
-
-  const result = doImport();
-
-  if (result.edgesSkipped > 0) {
-    console.warn(
-      `[VEKTOR] import: ${result.edgesSkipped} edges skipped — ` +
-      `endpoints missing in destination (expected for partial exports).`
-    );
-  }
-
-  return result;
-}
-
-/**
- * Usage:
- *   const bundle = memory.export();
- *   fs.writeFileSync('backup.vektor.json', JSON.stringify(bundle, null, 2));
- *
- *   memory.import(bundle);
- *   // → { imported: 244, skipped: 3, edgesAdded: 7100, edgesSkipped: 0 }
- *
- *   memory.import(bundle, { dryRun: true });
- *   // → { dryRun: true, checksum_valid: true, ... }
- *
- *   memory.import(bundle, { mode: 'replace' });
- *   memory.import(bundle, { namespace: 'restored-2026-01' });
- */

package/forget.js

@@ -1,148 +0,0 @@
-/**
- * VEKTOR memory.forget() — v1.3.7
- * Deletes a memory node and cascades to all graph edges.
- * Add this method to your core Memory class.
- *
- * Schema assumptions (existing vektor tables):
- *   memories(id, content, summary, importance, embedding, namespace, pinned, agent_id, created_at)
- *   graph_edges(id, source_id, target_id, edge_type, weight)
- *   entity_mentions(memory_id, entity_id)   -- if entity resolver is active
- */
-
-import { VektorError, ERR } from './errors.js';
-
-/**
- * forget(id)
- * Hard-deletes a single memory and all associated graph edges.
- *
- * @param {object} db        - better-sqlite3 db instance
- * @param {string} agentId   - current agent scope
- * @param {string} namespace - current namespace scope
- * @param {string} id        - memory id to delete
- * @returns {{ deleted: boolean, edgesRemoved: number }}
- */
-export function forget(db, agentId, namespace, id) {
-  const memory = db
-    .prepare(`SELECT id, pinned FROM memories WHERE id = ? AND agent_id = ? AND namespace = ?`)
-    .get(id, agentId, namespace);
-
-  if (!memory) {
-    throw new VektorError(
-      ERR.MEMORY_NOT_FOUND,
-      `Memory ${id} not found for agent ${agentId} in namespace ${namespace}`
-    );
-  }
-
-  if (memory.pinned) {
-    throw new VektorError(
-      ERR.MEMORY_DELETE_FAILED,
-      `Memory ${id} is pinned — unpin it first with memory.unpin(id)`
-    );
-  }
-
-  // Count edges before delete for return value
-  const edgeCount = db
-    .prepare(`SELECT COUNT(*) as n FROM graph_edges WHERE source_id = ? OR target_id = ?`)
-    .get(id, id).n;
-
-  // Fix 3 (Gemini round 3) — pinned edge orphan guard
-  // If this memory shares an edge with a pinned memory, deleting it would
-  // leave a dangling edge in the MAGMA graph pointing to a ghost node,
-  // silently corrupting traversal. Block the delete and surface the conflict.
-  const linkedPinned = db.prepare(`
-    SELECT m.id, m.content FROM graph_edges ge
-    JOIN memories m ON (ge.source_id = m.id OR ge.target_id = m.id)
-    WHERE (ge.source_id = ? OR ge.target_id = ?)
-      AND m.id != ?
-      AND m.pinned = 1
-    LIMIT 1
-  `).get(id, id, id);
-
-  if (linkedPinned) {
-    throw new VektorError(
-      ERR.MEMORY_DELETE_FAILED,
-      `Cannot delete memory ${id} — it is linked to pinned memory "${linkedPinned.id}". ` +
-      `Unpin that memory first, or use forgetWhere() to review the connection.`
-    );
-  }
-
-  // Run as transaction — all or nothing
-  const deleteAll = db.transaction(() => {
-    db.prepare(`DELETE FROM graph_edges WHERE source_id = ? OR target_id = ?`).run(id, id);
-    db.prepare(`DELETE FROM entity_mentions WHERE memory_id = ?`).run(id);
-    db.prepare(`DELETE FROM memories WHERE id = ? AND agent_id = ? AND namespace = ?`)
-      .run(id, agentId, namespace);
-  });
-
-  deleteAll();
-
-  return { deleted: true, edgesRemoved: edgeCount };
-}
-
-/**
- * forgetWhere(query)
- * Bulk-delete memories matching a semantic query above a threshold.
- * Useful for: "forget everything about Project X"
- *
- * @param {object} db
- * @param {string} agentId
- * @param {string} namespace
- * @param {Function} recallFn   - memory.recall() reference
- * @param {string} query        - natural language query
- * @param {object} opts
- * @param {number} opts.limit   - max memories to delete (default 10, safety cap)
- * @param {number} opts.minScore - min similarity score (default 0.85)
- * @param {boolean} opts.dryRun - if true, returns candidates without deleting
- * @returns {{ deleted: number, candidates: object[] }}
- */
-export async function forgetWhere(db, agentId, namespace, recallFn, query, opts = {}) {
-  const { limit = 10, minScore = 0.85, dryRun = false } = opts;
-
-  const candidates = await recallFn(query, limit);
-  const toDelete = candidates.filter(c => c.score >= minScore && !c.pinned);
-
-  if (dryRun) {
-    return { deleted: 0, candidates: toDelete };
-  }
-
-  let deleted = 0;
-  for (const mem of toDelete) {
-    try {
-      forget(db, agentId, namespace, mem.id);
-      deleted++;
-    } catch (e) {
-      // Only swallow expected skips — pinned memories or already-deleted IDs
-      // Re-throw anything infrastructure-level (SQLITE_BUSY, disk full, etc.)
-      if (e instanceof VektorError &&
-         (e.code === ERR.MEMORY_DELETE_FAILED || e.code === ERR.MEMORY_NOT_FOUND)) {
-        // expected skip — continue loop
-      } else {
-        throw e;
-      }
-    }
-  }
-
-  return { deleted, candidates: toDelete };
-}
-
-/**
- * Integration into Memory class:
- *
- * async forget(id) {
- *   return forget(this.db, this.agentId, this.namespace, id);
- * }
- *
- * async forgetWhere(query, opts = {}) {
- *   return forgetWhere(this.db, this.agentId, this.namespace, this.recall.bind(this), query, opts);
- * }
- *
- * Usage:
- *   await memory.forget('mem_abc123');
- *   // → { deleted: true, edgesRemoved: 4 }
- *
- *   await memory.forgetWhere('Project Atlas decisions', { dryRun: true });
- *   // → { deleted: 0, candidates: [...] }  -- preview first
- *
- *   await memory.forgetWhere('Project Atlas decisions', { minScore: 0.9, limit: 5 });
- *   // → { deleted: 3, candidates: [...] }
- */

package/inspect.js

@@ -1,199 +0,0 @@
-/**
- * VEKTOR memory.inspect() — v1.3.7
- * Returns a full diagnostic snapshot of the memory graph.
- * No more raw SQLite queries to debug state.
- */
-
-/**
- * inspect()
- * @param {object} db
- * @param {string} agentId
- * @param {string} namespace
- * @returns {object} full diagnostic snapshot
- */
-export function inspect(db, agentId, namespace) {
-  const scope = { agent_id: agentId, namespace };
-
-  // Core counts
-  const memoryCount = db.prepare(
-    `SELECT COUNT(*) as n FROM memories WHERE agent_id = ? AND namespace = ?`
-  ).get(agentId, namespace).n;
-
-  const pinnedCount = db.prepare(
-    `SELECT COUNT(*) as n FROM memories WHERE agent_id = ? AND namespace = ? AND pinned = 1`
-  ).get(agentId, namespace).n;
-
-  const edgeCount = db.prepare(
-    `SELECT COUNT(*) as n FROM graph_edges ge
-     JOIN memories m ON ge.source_id = m.id
-     WHERE m.agent_id = ? AND m.namespace = ?`
-  ).get(agentId, namespace).n;
-
-  // Edge type breakdown
-  const edgeTypes = db.prepare(
-    `SELECT ge.edge_type, COUNT(*) as n FROM graph_edges ge
-     JOIN memories m ON ge.source_id = m.id
-     WHERE m.agent_id = ? AND m.namespace = ?
-     GROUP BY ge.edge_type ORDER BY n DESC`
-  ).all(agentId, namespace);
-
-  // Top nodes by edge count (most connected memories)
-  const topNodes = db.prepare(
-    `SELECT m.id, m.content, m.summary, m.importance, m.pinned,
-            COUNT(ge.id) as connections
-     FROM memories m
-     LEFT JOIN graph_edges ge ON ge.source_id = m.id OR ge.target_id = m.id
-     WHERE m.agent_id = ? AND m.namespace = ?
-     GROUP BY m.id
-     ORDER BY connections DESC, m.importance DESC
-     LIMIT 5`
-  ).all(agentId, namespace);
-
-  // Recent memories
-  const recentMemories = db.prepare(
-    `SELECT id, content, summary, importance, pinned, created_at
-     FROM memories
-     WHERE agent_id = ? AND namespace = ?
-     ORDER BY created_at DESC LIMIT 5`
-  ).all(agentId, namespace);
-
-  // Importance distribution
-  const importanceBuckets = db.prepare(
-    `SELECT
-       ROUND(importance, 1) as bucket,
-       COUNT(*) as n
-     FROM memories
-     WHERE agent_id = ? AND namespace = ?
-     GROUP BY bucket ORDER BY bucket DESC`
-  ).all(agentId, namespace);
-
-  // REM stats
-  const remStats = (() => {
-    try {
-      return db.prepare(
-        `SELECT COUNT(*) as dreams,
-                MAX(ran_at) as last_run,
-                SUM(fragments_in) as total_fragments_in,
-                SUM(fragments_out) as total_fragments_out
-         FROM rem_log WHERE agent_id = ? AND namespace = ?`
-      ).get(agentId, namespace);
-    } catch {
-      return { dreams: 0, last_run: null, total_fragments_in: 0, total_fragments_out: 0 };
-    }
-  })();
-
-  // AUDN stats
-  const audnStats = (() => {
-    try {
-      return db.prepare(
-        `SELECT
-           IFNULL(SUM(CASE WHEN action='ADD'    THEN 1 ELSE 0 END), 0) as added,
-           IFNULL(SUM(CASE WHEN action='UPDATE' THEN 1 ELSE 0 END), 0) as updated,
-           IFNULL(SUM(CASE WHEN action='DELETE' THEN 1 ELSE 0 END), 0) as deleted,
-           IFNULL(SUM(CASE WHEN action='NO_OP'  THEN 1 ELSE 0 END), 0) as skipped
-         FROM audn_log WHERE agent_id = ? AND namespace = ?`
-      ).get(agentId, namespace);
-    } catch {
-      return null;
-    }
-  })();
-
-  // Namespace list (across all agents — useful for multi-namespace setups)
-  const namespaces = db.prepare(
-    `SELECT namespace, COUNT(*) as memories
-     FROM memories WHERE agent_id = ?
-     GROUP BY namespace ORDER BY memories DESC`
-  ).all(agentId);
-
-  // Oldest and newest memory
-  const oldest = db.prepare(
-    `SELECT id, content, created_at FROM memories
-     WHERE agent_id = ? AND namespace = ? ORDER BY created_at ASC LIMIT 1`
-  ).get(agentId, namespace);
-
-  const newest = db.prepare(
-    `SELECT id, content, created_at FROM memories
-     WHERE agent_id = ? AND namespace = ? ORDER BY created_at DESC LIMIT 1`
-  ).get(agentId, namespace);
-
-  // Health score — simple heuristic
-  const compressionRatio = remStats?.total_fragments_in > 0
-    ? (remStats.total_fragments_out / remStats.total_fragments_in).toFixed(2)
-    : null;
-
-  const avgImportance = db.prepare(
-    `SELECT AVG(importance) as avg FROM memories WHERE agent_id = ? AND namespace = ?`
-  ).get(agentId, namespace).avg;
-
-  return {
-    agent_id: agentId,
-    namespace,
-    snapshot_at: new Date().toISOString(),
-
-    counts: {
-      memories: memoryCount,
-      pinned: pinnedCount,
-      edges: edgeCount,
-      namespaces: namespaces.length
-    },
-
-    graph: {
-      edgeTypes,
-      topNodes: topNodes.map(n => ({
-        id: n.id,
-        preview: (n.summary || n.content || '').slice(0, 80),
-        importance: n.importance,
-        connections: n.connections,
-        pinned: !!n.pinned
-      }))
-    },
-
-    timeline: {
-      oldest: oldest ? { id: oldest.id, preview: oldest.content?.slice(0, 60), at: oldest.created_at } : null,
-      newest: newest ? { id: newest.id, preview: newest.content?.slice(0, 60), at: newest.created_at } : null
-    },
-
-    recent: recentMemories.map(m => ({
-      id: m.id,
-      preview: (m.summary || m.content || '').slice(0, 80),
-      importance: m.importance,
-      pinned: !!m.pinned,
-      at: m.created_at
-    })),
-
-    importance: {
-      avg: avgImportance ? parseFloat(avgImportance.toFixed(3)) : null,
-      distribution: importanceBuckets
-    },
-
-    rem: {
-      totalDreams: remStats?.dreams || 0,
-      lastRun: remStats?.last_run || null,
-      compressionRatio,
-      fragmentsProcessed: remStats?.total_fragments_in || 0
-    },
-
-    audn: audnStats,
-
-    namespaces
-  };
-}
-
-/**
- * Integration into Memory class:
- *
- * inspect() {
- *   return inspect(this.db, this.agentId, this.namespace);
- * }
- *
- * Usage:
- *   const state = memory.inspect();
- *   console.log(state.counts);
- *   // → { memories: 247, pinned: 3, edges: 7180, namespaces: 2 }
- *
- *   console.log(state.rem.compressionRatio);
- *   // → "0.06"  (50:1 means ~0.02, 10:1 means 0.1)
- *
- *   console.log(state.graph.topNodes[0]);
- *   // → { id, preview, importance, connections: 42, pinned: false }
- */

package/mistral/README-mistral.md

@@ -1,123 +0,0 @@
-# VEKTOR Slipstream — Mistral Integration
-
-Connect Mistral agents (Le Chat, Mistral API, La Plateforme) to persistent
-local memory. Your memory graph runs on your machine — nothing leaves it.
-
----
-
-## How it works
-
-```
-Mistral agent
-    ↓  tool call
-mistral-bridge.js  (http://localhost:3847)
-    ↓  memory ops
-your-agent.db  (local SQLite — your machine only)
-```
-
-The bridge is a lightweight HTTP server that runs locally. Mistral calls
-`localhost:3847` — your memory never touches any external server.
-
----
-
-## Setup (60 seconds)
-
-```bash
-# From your project root (after npm install vektor-slipstream):
-node node_modules/vektor-slipstream/mistral/mistral-setup.js
-```
-
-The setup script will:
-1. Ask for your Vektor licence key
-2. Validate it against Polar
-3. Save config to `~/.vektor/mistral.config.json`
-4. Start the bridge on port 3847
-
----
-
-## Add to your Mistral agent
-
-After setup, add the tool manifest to your Mistral agent or La Plateforme project.
-The manifest is at:
-
-```
-node_modules/vektor-slipstream/mistral/vektor-tool-manifest.json
-```
-
-The bridge endpoint is:
-```
-http://localhost:3847/api/v1/mistral/vektor_memoire
-```
-
----
-
-## Tool usage
-
-**Recall memories:**
-```json
-{
-  "action": "recall",
-  "query":  "user coding preferences",
-  "key":    "YOUR_LICENCE_KEY",
-  "limit":  5
-}
-```
-
-**Store a memory:**
-```json
-{
-  "action":  "remember",
-  "content": "User prefers TypeScript over JavaScript",
-  "key":     "YOUR_LICENCE_KEY"
-}
-```
-
-**Response (recall):**
-```json
-{
-  "action": "recall",
-  "query": "coding preferences",
-  "memory_fragments": [
-    { "content": "User prefers TypeScript over JavaScript", "relevance": 0.97, "importance": 2, "id": 1 }
-  ],
-  "count": 1,
-  "metadata": { "engine": "VEKTOR_MAGMA_v1.0.5", "auth": "VERIFIED", "local": true }
-}
-```
-
----
-
-## Start/stop the bridge
-
-```bash
-# Start (foreground — logs visible):
-node node_modules/vektor-slipstream/mistral/mistral-setup.js --start
-
-# Start (background):
-# Run setup and choose 'Y' when asked about background mode
-
-# Health check:
-curl http://localhost:3847/health
-```
-
----
-
-## Environment variables
-
-| Variable | Default | Description |
-|---|---|---|
-| `VEKTOR_LICENCE_KEY` | — | Your licence key (alternative to setup prompt) |
-| `VEKTOR_MISTRAL_PORT` | 3847 | Port for the bridge server |
-
----
-
-## Separate from other agents
-
-Each agent gets its own memory database. The Mistral bridge uses whichever
-`dbPath` you set during setup — completely separate from any LangChain or
-OpenAI agent databases.
-
-```js
-// Other agents are unaffected:
-const memory = await createMemory({ agentId: 'my-other-agent', dbPath: './other.db' });
-```