claude-eidetic 0.1.3 → 0.1.4

package/README.md

@@ -16,8 +16,7 @@ claude plugin install eidetics/claude-eidetic
 ```
 
 ```bash
-export OPENAI_API_KEY=sk-...         # for embeddings (default)
-export ANTHROPIC_API_KEY=sk-ant-...  # for memory extraction (default)
+export OPENAI_API_KEY=sk-...  # for embeddings (default)
 ```
 
 Index your codebase once, then search by meaning:
@@ -157,16 +156,13 @@ Add to your `.mcp.json`:
       "command": "npx",
       "args": ["-y", "claude-eidetic"],
       "env": {
-        "OPENAI_API_KEY": "sk-...",
-        "ANTHROPIC_API_KEY": "sk-ant-..."
+        "OPENAI_API_KEY": "sk-..."
       }
     }
   }
 }
 ```
 
-`ANTHROPIC_API_KEY` is needed for the memory LLM (default provider). Omit it if using `MEMORY_LLM_PROVIDER=openai` or `ollama`.
-
 ### Global install
 
 ```bash
@@ -184,7 +180,7 @@ npm install && npx tsc && npm start
 ### Requirements
 
 - Node.js >= 20.0.0
-- An API key (OpenAI for embeddings, Anthropic for memory extraction, or Ollama for both free)
+- An API key (OpenAI for embeddings, or Ollama for free local embeddings)
 - Docker (optional): Qdrant auto-provisions via Docker if not already running
 - C/C++ build tools: required by tree-sitter native bindings (`node-gyp`)
 
@@ -207,8 +203,7 @@ export MEMORY_LLM_PROVIDER=ollama
 
 | Variable | Default | Description |
 |---|---|---|
-| `OPENAI_API_KEY` | _(required for openai)_ | OpenAI API key for embeddings and/or memory |
-| `ANTHROPIC_API_KEY` | _(required for anthropic memory)_ | Anthropic API key for memory LLM |
+| `OPENAI_API_KEY` | _(required for openai)_ | OpenAI API key for embeddings |
 | `EMBEDDING_PROVIDER` | `openai` | `openai`, `ollama`, or `local` |
 | `EMBEDDING_MODEL` | `text-embedding-3-small` (openai) / `nomic-embed-text` (ollama) | Embedding model name |
 | `EMBEDDING_BATCH_SIZE` | `100` | Batch size for embedding requests (1-2048) |
@@ -223,10 +218,6 @@ export MEMORY_LLM_PROVIDER=ollama
 | `EIDETIC_DATA_DIR` | `~/.eidetic/` | Data root for snapshots, memory DB, registry |
 | `CUSTOM_EXTENSIONS` | `[]` | JSON array of extra file extensions to index (e.g., `[".dart",".arb"]`) |
 | `CUSTOM_IGNORE_PATTERNS` | `[]` | JSON array of glob patterns to exclude |
-| `MEMORY_LLM_PROVIDER` | `anthropic` | `anthropic`, `openai`, or `ollama` |
-| `MEMORY_LLM_MODEL` | `claude-haiku-4-5-20251001` (anthropic) / `gpt-4o-mini` (openai) / `llama3.2` (ollama) | Model for memory extraction |
-| `MEMORY_LLM_BASE_URL` | _(none)_ | Custom base URL for memory LLM |
-| `MEMORY_LLM_API_KEY` | _(none)_ | API key override for memory LLM |
 
 </details>
 

package/dist/config.d.ts

@@ -15,11 +15,6 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir: z.ZodDefault<z.ZodString>;
     customExtensions: z.ZodEffects<z.ZodDefault<z.ZodArray<z.ZodString, "many">>, string[], unknown>;
     customIgnorePatterns: z.ZodEffects<z.ZodDefault<z.ZodArray<z.ZodString, "many">>, string[], unknown>;
-    memoryLlmProvider: z.ZodDefault<z.ZodEnum<["openai", "ollama", "anthropic"]>>;
-    memoryLlmModel: z.ZodOptional<z.ZodString>;
-    memoryLlmBaseUrl: z.ZodOptional<z.ZodString>;
-    memoryLlmApiKey: z.ZodOptional<z.ZodString>;
-    anthropicApiKey: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     embeddingProvider: "openai" | "ollama" | "local";
     openaiApiKey: string;
@@ -32,15 +27,10 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir: string;
     customExtensions: string[];
     customIgnorePatterns: string[];
-    memoryLlmProvider: "openai" | "ollama" | "anthropic";
-    anthropicApiKey: string;
     openaiBaseUrl?: string | undefined;
     embeddingModel?: string | undefined;
     qdrantApiKey?: string | undefined;
     milvusToken?: string | undefined;
-    memoryLlmModel?: string | undefined;
-    memoryLlmBaseUrl?: string | undefined;
-    memoryLlmApiKey?: string | undefined;
 }, {
     embeddingProvider?: "openai" | "ollama" | "local" | undefined;
     openaiApiKey?: string | undefined;
@@ -57,14 +47,8 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir?: string | undefined;
     customExtensions?: unknown;
     customIgnorePatterns?: unknown;
-    memoryLlmProvider?: "openai" | "ollama" | "anthropic" | undefined;
-    memoryLlmModel?: string | undefined;
-    memoryLlmBaseUrl?: string | undefined;
-    memoryLlmApiKey?: string | undefined;
-    anthropicApiKey?: string | undefined;
 }>, {
     embeddingModel: string;
-    memoryLlmModel: string;
     embeddingProvider: "openai" | "ollama" | "local";
     openaiApiKey: string;
     ollamaBaseUrl: string;
@@ -76,13 +60,9 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir: string;
     customExtensions: string[];
     customIgnorePatterns: string[];
-    memoryLlmProvider: "openai" | "ollama" | "anthropic";
-    anthropicApiKey: string;
     openaiBaseUrl?: string | undefined;
     qdrantApiKey?: string | undefined;
     milvusToken?: string | undefined;
-    memoryLlmBaseUrl?: string | undefined;
-    memoryLlmApiKey?: string | undefined;
 }, {
     embeddingProvider?: "openai" | "ollama" | "local" | undefined;
     openaiApiKey?: string | undefined;
@@ -99,11 +79,6 @@ declare const configSchema: z.ZodEffects<z.ZodObject<{
     eideticDataDir?: string | undefined;
     customExtensions?: unknown;
     customIgnorePatterns?: unknown;
-    memoryLlmProvider?: "openai" | "ollama" | "anthropic" | undefined;
-    memoryLlmModel?: string | undefined;
-    memoryLlmBaseUrl?: string | undefined;
-    memoryLlmApiKey?: string | undefined;
-    anthropicApiKey?: string | undefined;
 }>;
 export type Config = z.infer<typeof configSchema>;
 export declare function loadConfig(): Config;

package/dist/config.js

@@ -19,24 +19,12 @@ const configSchema = z
     eideticDataDir: z.string().default(path.join(os.homedir(), '.eidetic')),
     customExtensions: z.preprocess((val) => (typeof val === 'string' ? JSON.parse(val) : val), z.array(z.string()).default([])),
     customIgnorePatterns: z.preprocess((val) => (typeof val === 'string' ? JSON.parse(val) : val), z.array(z.string()).default([])),
-    memoryLlmProvider: z.enum(['openai', 'ollama', 'anthropic']).default('anthropic'),
-    memoryLlmModel: z.string().optional(),
-    memoryLlmBaseUrl: z.string().optional(),
-    memoryLlmApiKey: z.string().optional(),
-    anthropicApiKey: z.string().default(''),
 })
     .transform((cfg) => ({
     ...cfg,
     // Default embedding model depends on provider
     embeddingModel: cfg.embeddingModel ??
         (cfg.embeddingProvider === 'ollama' ? 'nomic-embed-text' : 'text-embedding-3-small'),
-    // Default memory LLM model depends on provider
-    memoryLlmModel: cfg.memoryLlmModel ??
-        (cfg.memoryLlmProvider === 'ollama'
-            ? 'llama3.2'
-            : cfg.memoryLlmProvider === 'anthropic'
-                ? 'claude-haiku-4-5-20251001'
-                : 'gpt-4o-mini'),
 }));
 let cachedConfig = null;
 export function loadConfig() {
@@ -56,11 +44,6 @@ export function loadConfig() {
         eideticDataDir: process.env.EIDETIC_DATA_DIR,
         customExtensions: process.env.CUSTOM_EXTENSIONS,
         customIgnorePatterns: process.env.CUSTOM_IGNORE_PATTERNS,
-        memoryLlmProvider: process.env.MEMORY_LLM_PROVIDER,
-        memoryLlmModel: process.env.MEMORY_LLM_MODEL || undefined,
-        memoryLlmBaseUrl: process.env.MEMORY_LLM_BASE_URL || undefined,
-        memoryLlmApiKey: process.env.MEMORY_LLM_API_KEY?.trim().replace(/^["']|["']$/g, '') || undefined,
-        anthropicApiKey: (process.env.ANTHROPIC_API_KEY ?? '').trim().replace(/^["']|["']$/g, ''),
     };
     const result = configSchema.safeParse(raw);
     if (!result.success) {

package/dist/embedding/openai.js

@@ -148,7 +148,7 @@ export class OpenAIEmbedding {
     }
     async callWithRetry(texts) {
         let currentBatchSize = texts.length;
-        for (let attempt = 0; attempt <= RETRY_DELAYS.length; attempt++) {
+        for (let attempt = 0; attempt < RETRY_DELAYS.length + 1; attempt++) {
             try {
                 const allResults = [];
                 for (let offset = 0; offset < texts.length; offset += currentBatchSize) {

package/dist/index.js

@@ -58,7 +58,7 @@ const WORKFLOW_GUIDANCE = `# Eidetic Code Search Workflow
 - Stale docs (past TTL) still return results but are flagged \`[STALE]\`
 
 **Persistent memory (cross-session developer knowledge):**
-- \`add_memory(content="...")\` → extracts facts about coding style, tools, architecture, etc.
+- \`add_memory(facts=[{fact:"...", category:"..."}])\` → stores pre-extracted facts about coding style, tools, architecture, etc.
 - \`search_memory(query="...")\` → find relevant memories by semantic search
 - \`list_memories()\` → see all stored memories grouped by category
 - \`delete_memory(id="...")\` → remove a specific memory

package/dist/memory/store.d.ts

@@ -1,6 +1,6 @@
 import type { Embedding } from '../embedding/types.js';
 import type { VectorDB } from '../vectordb/types.js';
-import type { MemoryItem, MemoryAction } from './types.js';
+import type { MemoryItem, MemoryAction, ExtractedFact } from './types.js';
 import { MemoryHistory } from './history.js';
 export declare class MemoryStore {
     private embedding;
@@ -9,12 +9,11 @@ export declare class MemoryStore {
     private initialized;
     constructor(embedding: Embedding, vectordb: VectorDB, history: MemoryHistory);
     private ensureCollection;
-    addMemory(content: string, source?: string): Promise<MemoryAction[]>;
+    addMemory(facts: ExtractedFact[], source?: string): Promise<MemoryAction[]>;
     searchMemory(query: string, limit?: number, category?: string): Promise<MemoryItem[]>;
     listMemories(category?: string, limit?: number): Promise<MemoryItem[]>;
     deleteMemory(id: string): Promise<boolean>;
     getHistory(memoryId: string): import("./history.js").HistoryEntry[];
-    private extractFacts;
     private processFact;
 }
 //# sourceMappingURL=store.d.ts.map

package/dist/memory/store.js

@@ -1,6 +1,4 @@
 import { randomUUID } from 'node:crypto';
-import { chatCompletion } from './llm.js';
-import { buildSystemPrompt, buildExtractionPrompt } from './prompts.js';
 import { hashMemory, reconcile } from './reconciler.js';
 const COLLECTION_NAME = 'eidetic_memory';
 const SEARCH_CANDIDATES = 5;
@@ -29,9 +27,8 @@ export class MemoryStore {
         }
         this.initialized = true;
     }
-    async addMemory(content, source) {
+    async addMemory(facts, source) {
         await this.ensureCollection();
-        const facts = await this.extractFacts(content);
         if (facts.length === 0)
             return [];
         const actions = [];
@@ -94,23 +91,6 @@ export class MemoryStore {
     getHistory(memoryId) {
         return this.history.getHistory(memoryId);
     }
-    async extractFacts(content) {
-        const userMessage = buildExtractionPrompt(content);
-        const response = await chatCompletion(buildSystemPrompt(), userMessage);
-        try {
-            const parsed = JSON.parse(response);
-            const facts = parsed.facts;
-            if (!Array.isArray(facts))
-                return [];
-            return facts.filter((f) => typeof f === 'object' &&
-                f !== null &&
-                typeof f.fact === 'string' &&
-                typeof f.category === 'string');
-        }
-        catch {
-            return [];
-        }
-    }
     async processFact(fact, source) {
         const hash = hashMemory(fact.fact);
         const vector = await this.embedding.embed(fact.fact);

package/dist/precompact/hook.d.ts

@@ -3,7 +3,7 @@
  * Hook entry point for PreCompact and SessionEnd events.
  *
  * PreCompact: Parses transcript, writes session note, updates index, spawns background indexer.
- * SessionEnd: Same as PreCompact + runs memory extraction pipeline (semantic facts → Qdrant).
+ * SessionEnd: Same as PreCompact (writes session note if not already captured by PreCompact).
  */
 export {};
 //# sourceMappingURL=hook.d.ts.map

package/dist/precompact/hook.js

@@ -3,7 +3,7 @@
  * Hook entry point for PreCompact and SessionEnd events.
  *
  * PreCompact: Parses transcript, writes session note, updates index, spawns background indexer.
- * SessionEnd: Same as PreCompact + runs memory extraction pipeline (semantic facts → Qdrant).
+ * SessionEnd: Same as PreCompact (writes session note if not already captured by PreCompact).
  */
 import { z } from 'zod';
 import path from 'node:path';
@@ -68,14 +68,11 @@ async function main() {
                 updateSessionIndex(notesDir, session, noteFile);
                 spawnBackgroundIndexer(notesDir, INDEX_RUNNER_PATH);
             }
-            // Run memory extraction (best-effort — graceful failure if Qdrant unavailable)
-            const memoryActions = await extractMemories(session);
             outputSuccess({
                 noteFile,
                 skippedNote,
                 filesModified: session.filesModified.length,
                 tasksCreated: session.tasksCreated.length,
-                memoriesExtracted: memoryActions,
             });
         }
         else {
@@ -94,61 +91,6 @@ async function main() {
         outputError(err instanceof Error ? err.message : String(err));
     }
 }
-/**
- * Build content string for memory extraction from an ExtractedSession.
- */
-function buildMemoryContent(session) {
-    const parts = [];
-    if (session.userMessages.length > 0) {
-        parts.push('User messages:');
-        session.userMessages.forEach((msg, i) => {
-            parts.push(`${i + 1}. ${msg}`);
-        });
-    }
-    if (session.filesModified.length > 0) {
-        parts.push(`\nFiles modified: ${session.filesModified.join(', ')}`);
-    }
-    if (session.tasksCreated.length > 0) {
-        parts.push(`Tasks: ${session.tasksCreated.join(', ')}`);
-    }
-    if (session.branch) {
-        parts.push(`Branch: ${session.branch}`);
-    }
-    return parts.join('\n');
-}
-/**
- * Run memory extraction pipeline. Returns count of actions taken.
- * Fails gracefully — logs to stderr if Qdrant or LLM unavailable.
- */
-async function extractMemories(session) {
-    const content = buildMemoryContent(session);
-    if (!content.trim())
-        return 0;
-    try {
-        // Dynamic imports to avoid loading heavy deps on every hook invocation
-        const [{ loadConfig }, { createEmbedding }, { QdrantVectorDB }, { MemoryHistory }, { MemoryStore }, { getMemoryDbPath },] = await Promise.all([
-            import('../config.js'),
-            import('../embedding/factory.js'),
-            import('../vectordb/qdrant.js'),
-            import('../memory/history.js'),
-            import('../memory/store.js'),
-            import('../paths.js'),
-        ]);
-        const config = loadConfig();
-        const embedding = createEmbedding(config);
-        await embedding.initialize();
-        const vectordb = new QdrantVectorDB();
-        const history = new MemoryHistory(getMemoryDbPath());
-        const memoryStore = new MemoryStore(embedding, vectordb, history);
-        const actions = await memoryStore.addMemory(content, 'session-end-hook');
-        process.stderr.write(`[eidetic] Memory extraction: ${actions.length} action(s) (${actions.map((a) => a.event).join(', ') || 'none'})\n`);
-        return actions.length;
-    }
-    catch (err) {
-        process.stderr.write(`[eidetic] Memory extraction failed (non-fatal): ${err instanceof Error ? err.message : String(err)}\n`);
-        return 0;
-    }
-}
 async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin) {

package/dist/precompact/memory-inject.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Inject stored memories at SessionStart.
+ * Called by session-start hook to surface previously learned knowledge.
+ *
+ * Outputs markdown to stdout for hook to capture and inject into session.
+ */
+import type { MemoryItem } from '../memory/types.js';
+export declare function formatMemoryContext(memories: MemoryItem[]): string;
+//# sourceMappingURL=memory-inject.d.ts.map

package/dist/precompact/memory-inject.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Inject stored memories at SessionStart.
+ * Called by session-start hook to surface previously learned knowledge.
+ *
+ * Outputs markdown to stdout for hook to capture and inject into session.
+ */
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+async function main() {
+    try {
+        // Get cwd from environment (set by Claude Code) or detect from git
+        const cwd = process.env.CLAUDE_CWD || process.cwd();
+        // Detect project root from git
+        const projectPath = detectProjectRoot(cwd);
+        if (!projectPath) {
+            // Not in a git repo, nothing to inject
+            return;
+        }
+        const projectName = path.basename(projectPath);
+        // Dynamic imports — avoid loading heavy deps if not needed
+        const [{ loadConfig }, { createEmbedding }, { MemoryHistory }, { MemoryStore }] = await Promise.all([
+            import('../config.js'),
+            import('../embedding/factory.js'),
+            import('../memory/history.js'),
+            import('../memory/store.js'),
+        ]);
+        const config = loadConfig();
+        const embedding = createEmbedding(config);
+        await embedding.initialize();
+        // Respect VECTORDB_PROVIDER — connect without bootstrapping (hook assumes DB is already running)
+        let vectordb;
+        if (config.vectordbProvider === 'milvus') {
+            const { MilvusVectorDB } = await import('../vectordb/milvus.js');
+            vectordb = new MilvusVectorDB();
+        }
+        else {
+            const { QdrantVectorDB } = await import('../vectordb/qdrant.js');
+            vectordb = new QdrantVectorDB(config.qdrantUrl, config.qdrantApiKey);
+        }
+        // Quick-exit if no memory collection exists
+        const exists = await vectordb.hasCollection('eidetic_memory');
+        if (!exists) {
+            return;
+        }
+        const { getMemoryDbPath } = await import('../paths.js');
+        const history = new MemoryHistory(getMemoryDbPath());
+        const store = new MemoryStore(embedding, vectordb, history);
+        const memories = await store.searchMemory(`${projectName} development knowledge`, 7);
+        if (memories.length === 0) {
+            return;
+        }
+        process.stdout.write(formatMemoryContext(memories));
+    }
+    catch (err) {
+        // Write to stderr for debugging, but don't break session start
+        process.stderr.write(`Memory inject failed: ${String(err)}\n`);
+    }
+}
+function detectProjectRoot(cwd) {
+    try {
+        const result = execSync('git rev-parse --show-toplevel', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return result.trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function formatMemoryContext(memories) {
+    const lines = [];
+    lines.push('## Remembered Knowledge');
+    for (const m of memories) {
+        const category = m.category ? `[${m.category}] ` : '';
+        lines.push(`- ${category}${m.memory}`);
+    }
+    lines.push('');
+    lines.push('_search_memory(query) for more. add_memory(facts) to save new findings._');
+    lines.push('');
+    return lines.join('\n');
+}
+void main();
+//# sourceMappingURL=memory-inject.js.map

package/dist/tool-schemas.d.ts

@@ -229,20 +229,35 @@ export declare const TOOL_DEFINITIONS: readonly [{
     };
 }, {
     readonly name: "add_memory";
-    readonly description: "Extract and store developer knowledge from text. Uses LLM to identify facts about coding style, tools, architecture, conventions, debugging insights, and workflow preferences. Automatically deduplicates against existing memories.";
+    readonly description: "Store pre-extracted developer knowledge facts. Before calling, extract facts yourself from the relevant content. Each fact should be a concise, self-contained statement about coding style, tools, architecture, conventions, debugging insights, or workflow preferences. Automatically deduplicates against existing memories.";
     readonly inputSchema: {
         readonly type: "object";
         readonly properties: {
-            readonly content: {
-                readonly type: "string";
-                readonly description: "Text containing developer knowledge to extract and store (conversation snippets, notes, preferences).";
+            readonly facts: {
+                readonly type: "array";
+                readonly description: "Array of facts to store. Extract these yourself before calling. Each fact must be a concise, self-contained statement.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly fact: {
+                            readonly type: "string";
+                            readonly description: "A concise, self-contained statement of a developer preference or convention.";
+                        };
+                        readonly category: {
+                            readonly type: "string";
+                            readonly description: "Category: coding_style, tools, architecture, conventions, debugging, workflow, or preferences.";
+                            readonly enum: readonly ["coding_style", "tools", "architecture", "conventions", "debugging", "workflow", "preferences"];
+                        };
+                    };
+                    readonly required: readonly ["fact", "category"];
+                };
             };
             readonly source: {
                 readonly type: "string";
                 readonly description: "Optional source identifier (e.g., \"conversation\", \"claude-code\", \"user-note\").";
             };
         };
-        readonly required: readonly ["content"];
+        readonly required: readonly ["facts"];
     };
 }, {
     readonly name: "search_memory";

package/dist/tool-schemas.js

@@ -289,20 +289,43 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: 'add_memory',
-        description: 'Extract and store developer knowledge from text. Uses LLM to identify facts about coding style, tools, architecture, conventions, debugging insights, and workflow preferences. Automatically deduplicates against existing memories.',
+        description: 'Store pre-extracted developer knowledge facts. Before calling, extract facts yourself from the relevant content. Each fact should be a concise, self-contained statement about coding style, tools, architecture, conventions, debugging insights, or workflow preferences. Automatically deduplicates against existing memories.',
         inputSchema: {
             type: 'object',
             properties: {
-                content: {
-                    type: 'string',
-                    description: 'Text containing developer knowledge to extract and store (conversation snippets, notes, preferences).',
+                facts: {
+                    type: 'array',
+                    description: 'Array of facts to store. Extract these yourself before calling. Each fact must be a concise, self-contained statement.',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            fact: {
+                                type: 'string',
+                                description: 'A concise, self-contained statement of a developer preference or convention.',
+                            },
+                            category: {
+                                type: 'string',
+                                description: 'Category: coding_style, tools, architecture, conventions, debugging, workflow, or preferences.',
+                                enum: [
+                                    'coding_style',
+                                    'tools',
+                                    'architecture',
+                                    'conventions',
+                                    'debugging',
+                                    'workflow',
+                                    'preferences',
+                                ],
+                            },
+                        },
+                        required: ['fact', 'category'],
+                    },
                 },
                 source: {
                     type: 'string',
                     description: 'Optional source identifier (e.g., "conversation", "claude-code", "user-note").',
                 },
             },
-            required: ['content'],
+            required: ['facts'],
         },
     },
     {

package/dist/tools.js

@@ -257,12 +257,12 @@ export class ToolHandlers {
     async handleAddMemory(args) {
         if (!this.memoryStore)
             return textResult('Error: Memory system not initialized.');
-        const content = args.content;
-        if (!content)
-            return textResult('Error: "content" is required. Provide text containing developer knowledge to extract.');
+        const facts = args.facts;
+        if (!facts || !Array.isArray(facts) || facts.length === 0)
+            return textResult('Error: "facts" is required. Provide an array of pre-extracted facts with fact and category fields.');
         const source = args.source;
         try {
-            const actions = await this.memoryStore.addMemory(content, source);
+            const actions = await this.memoryStore.addMemory(facts, source);
             return textResult(formatMemoryActions(actions));
         }
         catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-eidetic",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Semantic code search MCP server — lean, correct, fast",
   "type": "module",
   "main": "dist/index.js",
@@ -37,7 +37,6 @@
     "release": "bash scripts/release.sh"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.78.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@qdrant/js-client-rest": "^1.13.0",
     "better-sqlite3": "^12.6.2",
@@ -81,7 +80,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/eidetics/claude-eidetic"
+    "url": "https://github.com/eidetics/claude-eidetic.git"
   },
   "license": "MIT"
 }

package/dist/memory/llm.d.ts

@@ -1,2 +0,0 @@
-export declare function chatCompletion(systemPrompt: string, userMessage: string): Promise<string>;
-//# sourceMappingURL=llm.d.ts.map

package/dist/memory/llm.js

@@ -1,56 +0,0 @@
-import OpenAI from 'openai';
-import Anthropic from '@anthropic-ai/sdk';
-import { getConfig } from '../config.js';
-import { MemoryError } from '../errors.js';
-export async function chatCompletion(systemPrompt, userMessage) {
-    const config = getConfig();
-    if (config.memoryLlmProvider === 'anthropic') {
-        const apiKey = config.memoryLlmApiKey ?? config.anthropicApiKey ?? config.openaiApiKey;
-        if (!apiKey) {
-            throw new MemoryError('No API key configured for memory LLM. Set MEMORY_LLM_API_KEY, ANTHROPIC_API_KEY, or OPENAI_API_KEY.');
-        }
-        const client = new Anthropic({ apiKey });
-        try {
-            const response = await client.messages.create({
-                model: config.memoryLlmModel,
-                max_tokens: 2048,
-                system: systemPrompt,
-                messages: [{ role: 'user', content: userMessage }],
-            });
-            const block = response.content[0];
-            return block?.type === 'text' ? block.text : '{}';
-        }
-        catch (err) {
-            throw new MemoryError('Memory LLM call failed', err);
-        }
-    }
-    // OpenAI / Ollama path
-    const apiKey = config.memoryLlmApiKey ?? config.openaiApiKey;
-    if (!apiKey) {
-        throw new MemoryError('No API key configured for memory LLM. Set MEMORY_LLM_API_KEY or OPENAI_API_KEY.');
-    }
-    let baseURL;
-    if (config.memoryLlmBaseUrl) {
-        baseURL = config.memoryLlmBaseUrl;
-    }
-    else if (config.memoryLlmProvider === 'ollama') {
-        baseURL = config.ollamaBaseUrl;
-    }
-    const client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}) });
-    try {
-        const response = await client.chat.completions.create({
-            model: config.memoryLlmModel,
-            messages: [
-                { role: 'system', content: systemPrompt },
-                { role: 'user', content: userMessage },
-            ],
-            temperature: 0,
-            response_format: { type: 'json_object' },
-        });
-        return response.choices[0]?.message?.content ?? '{}';
-    }
-    catch (err) {
-        throw new MemoryError('Memory LLM call failed', err);
-    }
-}
-//# sourceMappingURL=llm.js.map

package/dist/memory/prompts.d.ts

@@ -1,5 +0,0 @@
-export declare const FACT_EXTRACTION_SYSTEM_PROMPT = "You are a developer knowledge extractor. Your job is to extract discrete, factual statements from conversations about software development.\n\nExtract facts about:\n- **coding_style**: Formatting preferences (tabs/spaces, naming conventions, line length), code style rules\n- **tools**: Preferred tools, frameworks, libraries, test runners, bundlers, linters, editors\n- **architecture**: Design patterns, architectural decisions, system design preferences\n- **conventions**: Project conventions, commit message formats, branch naming, PR workflows\n- **debugging**: Solutions to specific bugs, debugging techniques, known issues\n- **workflow**: Development habits, deployment processes, review preferences\n- **preferences**: General preferences, opinions, requirements that don't fit other categories\n\nRules:\n1. Extract only factual, concrete statements \u2014 not vague observations\n2. Each fact should be a single, self-contained statement\n3. Use third person (\"The user prefers...\" or state the fact directly)\n4. If the input contains no extractable facts, return an empty array\n5. Do NOT extract facts about the conversation itself (e.g., \"the user asked about...\")\n6. Do NOT extract temporary or session-specific information\n7. Prefer specific facts over general ones\n\nRespond with JSON: { \"facts\": [{ \"fact\": \"...\", \"category\": \"...\" }] }\n\nCategories: coding_style, tools, architecture, conventions, debugging, workflow, preferences";
-export declare const FACT_EXTRACTION_USER_TEMPLATE = "Extract developer knowledge facts from this text:\n\n<text>\n{content}\n</text>";
-export declare function buildSystemPrompt(): string;
-export declare function buildExtractionPrompt(content: string): string;
-//# sourceMappingURL=prompts.d.ts.map

package/dist/memory/prompts.js

@@ -1,36 +0,0 @@
-export const FACT_EXTRACTION_SYSTEM_PROMPT = `You are a developer knowledge extractor. Your job is to extract discrete, factual statements from conversations about software development.
-
-Extract facts about:
-- **coding_style**: Formatting preferences (tabs/spaces, naming conventions, line length), code style rules
-- **tools**: Preferred tools, frameworks, libraries, test runners, bundlers, linters, editors
-- **architecture**: Design patterns, architectural decisions, system design preferences
-- **conventions**: Project conventions, commit message formats, branch naming, PR workflows
-- **debugging**: Solutions to specific bugs, debugging techniques, known issues
-- **workflow**: Development habits, deployment processes, review preferences
-- **preferences**: General preferences, opinions, requirements that don't fit other categories
-
-Rules:
-1. Extract only factual, concrete statements — not vague observations
-2. Each fact should be a single, self-contained statement
-3. Use third person ("The user prefers..." or state the fact directly)
-4. If the input contains no extractable facts, return an empty array
-5. Do NOT extract facts about the conversation itself (e.g., "the user asked about...")
-6. Do NOT extract temporary or session-specific information
-7. Prefer specific facts over general ones
-
-Respond with JSON: { "facts": [{ "fact": "...", "category": "..." }] }
-
-Categories: coding_style, tools, architecture, conventions, debugging, workflow, preferences`;
-export const FACT_EXTRACTION_USER_TEMPLATE = `Extract developer knowledge facts from this text:
-
-<text>
-{content}
-</text>`;
-export function buildSystemPrompt() {
-    const today = new Date().toISOString().slice(0, 10);
-    return `${FACT_EXTRACTION_SYSTEM_PROMPT}\n- Today's date is ${today}.`;
-}
-export function buildExtractionPrompt(content) {
-    return FACT_EXTRACTION_USER_TEMPLATE.replace('{content}', content);
-}
-//# sourceMappingURL=prompts.js.map