audrey 0.11.0 → 0.15.0

package/mcp-server/config.js

@@ -1,7 +1,7 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-export const VERSION = '0.11.0';
+export const VERSION = '0.15.0';
 export const SERVER_NAME = 'audrey-memory';
 export const DEFAULT_DATA_DIR = join(homedir(), '.audrey', 'data');
 
@@ -12,18 +12,20 @@ export const DEFAULT_DATA_DIR = join(homedir(), '.audrey', 'data');
  */
 export function resolveEmbeddingProvider(env, explicit) {
   if (explicit && explicit !== 'auto') {
-    const dims = explicit === 'openai' ? 1536 : explicit === 'gemini' ? 768 : 384;
+    const dims = explicit === 'openai' ? 1536 : explicit === 'gemini' ? 3072 : 384;
     const apiKey = explicit === 'gemini'
       ? (env.GOOGLE_API_KEY || env.GEMINI_API_KEY)
       : explicit === 'openai'
         ? env.OPENAI_API_KEY
         : undefined;
-    return { provider: explicit, apiKey, dimensions: dims };
+    const result = { provider: explicit, apiKey, dimensions: dims };
+    if (explicit === 'local') result.device = env.AUDREY_DEVICE || 'gpu';
+    return result;
   }
   if (env.GOOGLE_API_KEY || env.GEMINI_API_KEY) {
-    return { provider: 'gemini', apiKey: env.GOOGLE_API_KEY || env.GEMINI_API_KEY, dimensions: 768 };
+    return { provider: 'gemini', apiKey: env.GOOGLE_API_KEY || env.GEMINI_API_KEY, dimensions: 3072 };
   }
-  return { provider: 'local', dimensions: 384 };
+  return { provider: 'local', dimensions: 384, device: env.AUDREY_DEVICE || 'gpu' };
 }
 
 export function buildAudreyConfig() {

package/mcp-server/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
@@ -63,11 +63,8 @@ function install() {
     process.exit(1);
   }
 
-  if (process.env.OPENAI_API_KEY) {
-    console.log('Detected OPENAI_API_KEY — using OpenAI embeddings (1536d)');
-  } else {
-    console.log('No OPENAI_API_KEY found — using mock embeddings (upgrade anytime by re-running with the key set)');
-  }
+  const embedding = resolveEmbeddingProvider(process.env);
+  console.log(`Embedding: ${embedding.provider} (${embedding.dimensions}d)`);
 
   if (process.env.ANTHROPIC_API_KEY) {
     console.log('Detected ANTHROPIC_API_KEY — enabling LLM-powered consolidation + contradiction detection');
@@ -92,7 +89,7 @@ function install() {
   console.log(`
 Audrey registered as "${SERVER_NAME}" with Claude Code.
 
-9 tools available in every session:
+12 tools available in every session:
   memory_encode        — Store observations, facts, preferences
   memory_recall        — Search memories by semantic similarity
   memory_consolidate   — Extract principles from accumulated episodes
@@ -102,6 +99,9 @@ Audrey registered as "${SERVER_NAME}" with Claude Code.
   memory_import        — Import a snapshot into a fresh database
   memory_forget        — Forget a specific memory by ID or query
   memory_decay         — Apply forgetting curves, transition low-confidence to dormant
+  memory_status        — Check brain health (episode/vec sync, dimensions)
+  memory_reflect       — Form lasting memories from a conversation
+  memory_greeting      — Wake up as yourself: load identity, context, mood
 
 Data stored in: ${DEFAULT_DATA_DIR}
 Verify: claude mcp list
@@ -196,11 +196,12 @@ async function main() {
         arousal: z.number().min(0).max(1).optional().describe('Emotional arousal: 0 (calm) to 1 (highly activated)'),
         label: z.string().optional().describe('Human-readable emotion label (e.g., "curiosity", "frustration", "relief")'),
       }).optional().describe('Emotional affect — how this memory feels'),
-      private: z.boolean().optional().describe('If true, memory is only visible to the AI � excluded from public recall results'),
+      private: z.boolean().optional().describe('If true, memory is only visible to the AI — excluded from public recall results'),
+      auto_supersede: z.boolean().optional().describe('If true, automatically supersede the most similar existing memory if similarity > 0.95'),
     },
-    async ({ content, source, tags, salience, private: isPrivate, context, affect }) => {
+    async ({ content, source, tags, salience, private: isPrivate, context, affect, auto_supersede }) => {
       try {
-        const id = await audrey.encode({ content, source, tags, salience, private: isPrivate, context, affect });
+        const id = await audrey.encode({ content, source, tags, salience, private: isPrivate, context, affect, autoSupersede: auto_supersede });
         return toolResult({ id, content, source, private: isPrivate ?? false });
       } catch (err) {
         return toolError(err);
@@ -377,6 +378,73 @@ async function main() {
     },
   );
 
+  server.tool(
+    'memory_status',
+    {},
+    async () => {
+      try {
+        const status = audrey.memoryStatus();
+        return toolResult(status);
+      } catch (err) {
+        return toolError(err);
+      }
+    },
+  );
+
+  server.tool(
+    'memory_reflect',
+    {
+      turns: z.array(z.object({
+        role: z.string().describe('Message role: user or assistant'),
+        content: z.string().describe('Message content'),
+      })).describe('Conversation turns to reflect on. Call at end of meaningful conversations to form lasting memories.'),
+    },
+    async ({ turns }) => {
+      try {
+        const result = await audrey.reflect(turns);
+        return toolResult(result);
+      } catch (err) {
+        return toolError(err);
+      }
+    },
+  );
+
+  server.tool(
+    'memory_dream',
+    {
+      min_cluster_size: z.number().optional().describe('Minimum episodes per cluster for consolidation'),
+      similarity_threshold: z.number().optional().describe('Similarity threshold for clustering'),
+      dormant_threshold: z.number().min(0).max(1).optional().describe('Confidence below which memories go dormant'),
+    },
+    async ({ min_cluster_size, similarity_threshold, dormant_threshold }) => {
+      try {
+        const result = await audrey.dream({
+          minClusterSize: min_cluster_size,
+          similarityThreshold: similarity_threshold,
+          dormantThreshold: dormant_threshold,
+        });
+        return toolResult(result);
+      } catch (err) {
+        return toolError(err);
+      }
+    },
+  );
+
+  server.tool(
+    'memory_greeting',
+    {
+      context: z.string().optional().describe('Optional hint about this session (e.g. "working on authentication feature"). If provided, also returns semantically relevant memories.'),
+    },
+    async ({ context }) => {
+      try {
+        const briefing = await audrey.greeting({ context });
+        return toolResult(briefing);
+      } catch (err) {
+        return toolError(err);
+      }
+    },
+  );
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error('[audrey-mcp] connected via stdio');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "audrey",
-  "version": "0.11.0",
+  "version": "0.15.0",
   "description": "Biological memory architecture for AI agents — encode, consolidate, and recall memories with confidence decay, contradiction detection, and causal graphs",
   "type": "module",
   "main": "src/index.js",
@@ -65,6 +65,7 @@
   "dependencies": {
     "@huggingface/transformers": "^3.8.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "audrey": "^0.11.0",
     "better-sqlite3": "^12.6.2",
     "sqlite-vec": "^0.1.7-alpha.2",
     "ulid": "^3.0.2",

package/src/audrey.js

@@ -193,7 +193,10 @@ export class Audrey extends EventEmitter {
    */
   async encode(params) {
     await this._ensureMigrated();
-    const encodeParams = { ...params, arousalWeight: this.affectConfig.arousalWeight };
+    const encodeParams = {
+      ...params,
+      arousalWeight: this.affectConfig.arousalWeight,
+    };
     const id = await encodeEpisode(this.db, this.embeddingProvider, encodeParams);
     this.emit('encode', { id, ...params });
     if (this.interferenceConfig.enabled) {
@@ -424,6 +427,168 @@ export class Audrey extends EventEmitter {
     return introspectFn(this.db);
   }
 
+  memoryStatus() {
+    const episodes = this.db.prepare('SELECT COUNT(*) as c FROM episodes').get().c;
+    const semantics = this.db.prepare('SELECT COUNT(*) as c FROM semantics').get().c;
+    const procedures = this.db.prepare('SELECT COUNT(*) as c FROM procedures').get().c;
+
+    let vecEpisodes = 0, vecSemantics = 0, vecProcedures = 0;
+    try {
+      vecEpisodes = this.db.prepare('SELECT COUNT(*) as c FROM vec_episodes').get().c;
+      vecSemantics = this.db.prepare('SELECT COUNT(*) as c FROM vec_semantics').get().c;
+      vecProcedures = this.db.prepare('SELECT COUNT(*) as c FROM vec_procedures').get().c;
+    } catch {
+      // vec tables may not exist if no dimensions configured
+    }
+
+    const dimsRow = this.db.prepare("SELECT value FROM audrey_config WHERE key = 'dimensions'").get();
+    const dimensions = dimsRow ? parseInt(dimsRow.value, 10) : null;
+    const versionRow = this.db.prepare("SELECT value FROM audrey_config WHERE key = 'schema_version'").get();
+    const schemaVersion = versionRow ? parseInt(versionRow.value, 10) : 0;
+
+    const device = this.embeddingProvider._actualDevice
+      ?? this.embeddingProvider.device
+      ?? null;
+
+    const healthy = episodes === vecEpisodes
+      && semantics === vecSemantics
+      && procedures === vecProcedures;
+
+    return {
+      episodes,
+      vec_episodes: vecEpisodes,
+      semantics,
+      vec_semantics: vecSemantics,
+      procedures,
+      vec_procedures: vecProcedures,
+      dimensions,
+      schema_version: schemaVersion,
+      device,
+      healthy,
+    };
+  }
+
+  async greeting({ context, recentLimit = 10, principleLimit = 5, identityLimit = 5 } = {}) {
+    const recent = this.db.prepare(
+      'SELECT id, content, source, tags, salience, created_at FROM episodes WHERE "private" = 0 ORDER BY created_at DESC LIMIT ?'
+    ).all(recentLimit);
+
+    const principles = this.db.prepare(
+      'SELECT id, content, salience, created_at FROM semantics WHERE state = ? ORDER BY salience DESC LIMIT ?'
+    ).all('active', principleLimit);
+
+    const identity = this.db.prepare(
+      'SELECT id, content, tags, salience, created_at FROM episodes WHERE "private" = 1 ORDER BY created_at DESC LIMIT ?'
+    ).all(identityLimit);
+
+    const unresolved = this.db.prepare(
+      "SELECT id, content, tags, salience, created_at FROM episodes WHERE tags LIKE '%unresolved%' AND salience > 0.3 ORDER BY created_at DESC LIMIT 10"
+    ).all();
+
+    const rawAffectRows = this.db.prepare(
+      "SELECT affect FROM episodes WHERE affect IS NOT NULL AND affect != '{}' ORDER BY created_at DESC LIMIT 20"
+    ).all();
+
+    const affectParsed = rawAffectRows
+      .map(r => { try { return JSON.parse(r.affect); } catch { return null; } })
+      .filter(a => a && a.valence !== undefined);
+
+    let mood;
+    if (affectParsed.length === 0) {
+      mood = { valence: 0, arousal: 0, samples: 0 };
+    } else {
+      const sumV = affectParsed.reduce((s, a) => s + a.valence, 0);
+      const sumA = affectParsed.reduce((s, a) => s + (a.arousal ?? 0), 0);
+      mood = {
+        valence: sumV / affectParsed.length,
+        arousal: sumA / affectParsed.length,
+        samples: affectParsed.length,
+      };
+    }
+
+    // Health & staleness
+    const stats = this.introspect();
+    const status = this.memoryStatus();
+
+    const lastConsolidation = stats.lastConsolidation;
+    const daysSinceConsolidation = lastConsolidation
+      ? (Date.now() - new Date(lastConsolidation).getTime()) / (1000 * 60 * 60 * 24)
+      : null;
+
+    const lastEpisode = this.db.prepare(
+      'SELECT created_at FROM episodes ORDER BY created_at DESC LIMIT 1'
+    ).get();
+    const daysSinceLastMemory = lastEpisode
+      ? (Date.now() - new Date(lastEpisode.created_at).getTime()) / (1000 * 60 * 60 * 24)
+      : null;
+
+    const suggestions = [];
+    if (stats.episodic > 50 && stats.totalConsolidationRuns === 0) {
+      suggestions.push('run consolidation — enough episodes have accumulated');
+    }
+    if (daysSinceConsolidation !== null && daysSinceConsolidation > 7) {
+      suggestions.push('consolidation overdue — consider running dream()');
+    }
+    if (!status.healthy) {
+      suggestions.push('vector tables out of sync — run reembed');
+    }
+
+    const health = {
+      totalEpisodes: stats.episodic,
+      totalSemantics: stats.semantic,
+      totalProcedural: stats.procedural,
+      dormant: stats.dormant,
+      contradictions: stats.contradictions.open,
+      consolidationRuns: stats.totalConsolidationRuns,
+      lastConsolidation,
+      healthy: status.healthy,
+      stale: daysSinceLastMemory !== null && daysSinceLastMemory > 7,
+      suggestion: suggestions.length > 0 ? suggestions.join('; ') : null,
+    };
+
+    const result = { recent, principles, mood, unresolved, identity, health };
+
+    if (context) {
+      result.contextual = await this.recall(context, { limit: 5, includePrivate: true });
+    }
+
+    return result;
+  }
+
+  /**
+   * Run a full "dreaming" cycle: consolidation + decay + interference cleanup.
+   * Inspired by CMA paper's REM-like replay. Designed to be called by hooks or on a schedule.
+   * @param {{ minClusterSize?: number, similarityThreshold?: number, dormantThreshold?: number }} [options]
+   * @returns {Promise<{ consolidated: ConsolidationResult, decayed: { totalEvaluated: number, transitionedToDormant: number }, summary: string }>}
+   */
+  async dream(options = {}) {
+    await this._ensureMigrated();
+
+    const consolidated = await this.consolidate({
+      minClusterSize: options.minClusterSize,
+      similarityThreshold: options.similarityThreshold,
+    });
+
+    const decayed = this.decay({
+      dormantThreshold: options.dormantThreshold,
+    });
+
+    const parts = [];
+    if (consolidated.principlesExtracted > 0) {
+      parts.push(`extracted ${consolidated.principlesExtracted} principles from ${consolidated.clustersFound} clusters`);
+    }
+    if (decayed.transitionedToDormant > 0) {
+      parts.push(`${decayed.transitionedToDormant} memories went dormant`);
+    }
+    if (parts.length === 0) {
+      parts.push('nothing changed — memories are well-maintained');
+    }
+
+    const result = { consolidated, decayed, summary: parts.join('; ') };
+    this.emit('dream', result);
+    return result;
+  }
+
   export() {
     return exportMemories(this.db);
   }