audrey 0.9.0 → 0.14.0

package/mcp-server/config.js

@@ -1,26 +1,42 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-export const VERSION = '0.9.0';
+export const VERSION = '0.14.0';
 export const SERVER_NAME = 'audrey-memory';
 export const DEFAULT_DATA_DIR = join(homedir(), '.audrey', 'data');
 
+/**
+ * Resolves which embedding provider to use.
+ * Priority: explicit config -> gemini (if GOOGLE_API_KEY exists) -> local
+ * OpenAI is NEVER auto-selected -- must be set explicitly via AUDREY_EMBEDDING_PROVIDER=openai.
+ */
+export function resolveEmbeddingProvider(env, explicit) {
+  if (explicit && explicit !== 'auto') {
+    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;
+    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: 3072 };
+  }
+  return { provider: 'local', dimensions: 384, device: env.AUDREY_DEVICE || 'gpu' };
+}
+
 export function buildAudreyConfig() {
   const dataDir = process.env.AUDREY_DATA_DIR || DEFAULT_DATA_DIR;
   const agent = process.env.AUDREY_AGENT || 'claude-code';
-  const embProvider = process.env.AUDREY_EMBEDDING_PROVIDER || 'mock';
-  const embDimensions = parseInt(process.env.AUDREY_EMBEDDING_DIMENSIONS || '8', 10);
+  const explicitProvider = process.env.AUDREY_EMBEDDING_PROVIDER;
   const llmProvider = process.env.AUDREY_LLM_PROVIDER;
 
-  const config = {
-    dataDir,
-    agent,
-    embedding: { provider: embProvider, dimensions: embDimensions },
-  };
+  const embedding = resolveEmbeddingProvider(process.env, explicitProvider);
 
-  if (embProvider === 'openai') {
-    config.embedding.apiKey = process.env.OPENAI_API_KEY;
-  }
+  const config = { dataDir, agent, embedding };
 
   if (llmProvider === 'anthropic') {
     config.llm = { provider: 'anthropic', apiKey: process.env.ANTHROPIC_API_KEY };
@@ -36,13 +52,13 @@ export function buildAudreyConfig() {
 export function buildInstallArgs(env = process.env) {
   const envPairs = [`AUDREY_DATA_DIR=${DEFAULT_DATA_DIR}`];
 
-  if (env.OPENAI_API_KEY) {
+  const embedding = resolveEmbeddingProvider(env);
+  if (embedding.provider === 'gemini') {
+    envPairs.push('AUDREY_EMBEDDING_PROVIDER=gemini');
+    envPairs.push(`GOOGLE_API_KEY=${embedding.apiKey}`);
+  } else if (embedding.provider === 'openai') {
     envPairs.push('AUDREY_EMBEDDING_PROVIDER=openai');
-    envPairs.push('AUDREY_EMBEDDING_DIMENSIONS=1536');
     envPairs.push(`OPENAI_API_KEY=${env.OPENAI_API_KEY}`);
-  } else {
-    envPairs.push('AUDREY_EMBEDDING_PROVIDER=mock');
-    envPairs.push('AUDREY_EMBEDDING_DIMENSIONS=8');
   }
 
   if (env.ANTHROPIC_API_KEY) {

package/mcp-server/index.js

@@ -8,7 +8,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { Audrey } from '../src/index.js';
 import { readStoredDimensions } from '../src/db.js';
-import { VERSION, SERVER_NAME, DEFAULT_DATA_DIR, buildAudreyConfig, buildInstallArgs } from './config.js';
+import { VERSION, SERVER_NAME, DEFAULT_DATA_DIR, buildAudreyConfig, buildInstallArgs, resolveEmbeddingProvider } from './config.js';
 
 const VALID_SOURCES = ['direct-observation', 'told-by-user', 'tool-result', 'inference', 'model-generated'];
 const VALID_TYPES = ['episodic', 'semantic', 'procedural'];
@@ -19,6 +19,11 @@ if (subcommand === 'install') {
   install();
 } else if (subcommand === 'uninstall') {
   uninstall();
+} else if (subcommand === 'reembed') {
+  reembed().catch(err => {
+    console.error('[audrey] reembed failed:', err);
+    process.exit(1);
+  });
 } else if (subcommand === 'status') {
   status();
 } else {
@@ -28,6 +33,28 @@ if (subcommand === 'install') {
   });
 }
 
+
+async function reembed() {
+  const dataDir = process.env.AUDREY_DATA_DIR || DEFAULT_DATA_DIR;
+  const explicit = process.env.AUDREY_EMBEDDING_PROVIDER;
+  const embedding = resolveEmbeddingProvider(process.env, explicit);
+
+  const storedDims = readStoredDimensions(dataDir);
+  const dimensionsChanged = storedDims !== null && storedDims !== embedding.dimensions;
+
+  console.log(`Re-embedding with ${embedding.provider} (${embedding.dimensions}d)...`);
+  if (dimensionsChanged) {
+    console.log(`Dimension change: ${storedDims}d -> ${embedding.dimensions}d (will drop and recreate vec tables)`);
+  }
+
+  const audrey = new Audrey({ dataDir, agent: 'reembed', embedding });
+  const { reembedAll } = await import('../src/migrate.js');
+  const counts = await reembedAll(audrey.db, audrey.embeddingProvider, { dropAndRecreate: dimensionsChanged });
+  audrey.close();
+
+  console.log(`Done. Re-embedded: ${counts.episodes} episodes, ${counts.semantics} semantics, ${counts.procedures} procedures`);
+}
+
 function install() {
   try {
     execFileSync('claude', ['--version'], { stdio: 'ignore' });
@@ -65,7 +92,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
@@ -75,6 +102,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
@@ -169,11 +199,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'),
     },
-    async ({ content, source, tags, salience, context, affect }) => {
+    async ({ content, source, tags, salience, private: isPrivate, context, affect }) => {
       try {
-        const id = await audrey.encode({ content, source, tags, salience, context, affect });
-        return toolResult({ id, content, source });
+        const id = await audrey.encode({ content, source, tags, salience, private: isPrivate, context, affect });
+        return toolResult({ id, content, source, private: isPrivate ?? false });
       } catch (err) {
         return toolError(err);
       }
@@ -349,6 +380,52 @@ 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_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.9.0",
+  "version": "0.14.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",
@@ -63,7 +63,9 @@
   },
   "license": "MIT",
   "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/affect.js

@@ -55,7 +55,7 @@ export async function detectResonance(db, embeddingProvider, episodeId, { conten
       priorAffect,
       semanticSimilarity: match.similarity,
       emotionalSimilarity,
-      timeDelta: Date.now() - new Date(match.created_at).getTime(),
+      timeDeltaDays: Math.floor((Date.now() - new Date(match.created_at).getTime()) / 86400000),
       priorCreatedAt: match.created_at,
     });
   }

package/src/audrey.js

@@ -10,7 +10,7 @@ import { applyDecay } from './decay.js';
 import { rollbackConsolidation, getConsolidationHistory } from './rollback.js';
 import { forgetMemory, forgetByQuery as forgetByQueryFn, purgeMemories } from './forget.js';
 import { introspect as introspectFn } from './introspect.js';
-import { buildContextResolutionPrompt } from './prompts.js';
+import { buildContextResolutionPrompt, buildReflectionPrompt } from './prompts.js';
 import { exportMemories } from './export.js';
 import { importMemories } from './import.js';
 import { suggestConsolidationParams as suggestParamsFn } from './adaptive.js';
@@ -29,6 +29,8 @@ import { detectResonance } from './affect.js';
  * @property {{ trigger?: string, consequence?: string }} [causal]
  * @property {string[]} [tags]
  * @property {string} [supersedes]
+ * @property {Record<string, string>} [context]
+ * @property {{ valence?: number, arousal?: number, label?: string }} [affect]
  *
  * @typedef {Object} RecallOptions
  * @property {number} [minConfidence]
@@ -40,6 +42,8 @@ import { detectResonance } from './affect.js';
  * @property {string[]} [sources]
  * @property {string} [after]
  * @property {string} [before]
+ * @property {Record<string, string>} [context]
+ * @property {{ valence?: number, arousal?: number }} [mood]
  *
  * @typedef {Object} RecallResult
  * @property {string} id
@@ -94,6 +98,7 @@ export class Audrey extends EventEmitter {
     interference = {},
     context = {},
     affect = {},
+    autoReflect = false,
   } = {}) {
     super();
 
@@ -148,6 +153,7 @@ export class Audrey extends EventEmitter {
         affectThreshold: affect.resonance?.affectThreshold ?? 0.6,
       },
     };
+    this.autoReflect = autoReflect;
   }
 
   async _ensureMigrated() {
@@ -212,6 +218,48 @@ export class Audrey extends EventEmitter {
     return id;
   }
 
+
+  async reflect(turns) {
+    if (!this.llmProvider) return { encoded: 0, memories: [], skipped: 'no llm provider' };
+
+    const prompt = buildReflectionPrompt(turns);
+    let raw;
+    try {
+      raw = await this.llmProvider.chat(prompt);
+    } catch (err) {
+      this.emit('error', err);
+      return { encoded: 0, memories: [], skipped: 'llm error' };
+    }
+
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return { encoded: 0, memories: [], skipped: 'invalid llm response' };
+    }
+
+    const memories = parsed.memories ?? [];
+    let encoded = 0;
+    for (const mem of memories) {
+      if (!mem.content || !mem.source) continue;
+      try {
+        await this.encode({
+          content: mem.content,
+          source: mem.source,
+          salience: mem.salience,
+          tags: mem.tags,
+          private: mem.private ?? false,
+          affect: mem.affect ?? undefined,
+        });
+        encoded++;
+      } catch (err) {
+        this.emit('error', err);
+      }
+    }
+
+    return { encoded, memories };
+  }
+
   /**
    * @param {EncodeParams[]} paramsList
    * @returns {Promise<string[]>}
@@ -376,6 +424,94 @@ 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,
+      };
+    }
+
+    const result = { recent, principles, mood, unresolved, identity };
+
+    if (context) {
+      result.contextual = await this.recall(context, { limit: 5, includePrivate: true });
+    }
+
+    return result;
+  }
+
   export() {
     return exportMemories(this.db);
   }