opencode-memsearch 0.1.0 → 0.2.0

package/README.md

@@ -57,7 +57,7 @@ OpenCode will install the npm package automatically on startup.
 When the agent finishes responding (session goes idle), the plugin:
 
 1. Extracts the last conversation turn (user message + agent response)
-2. Summarizes it into 2-6 bullet points using Claude Haiku via `opencode run`
+2. Summarizes it into 2-6 bullet points using an LLM (Claude Haiku by default, [configurable](#summarization-model)) via `opencode run`
 3. Appends the summary to `.memsearch/memory/YYYY-MM-DD.md`
 4. Re-indexes the memory directory into the vector database
 
@@ -102,23 +102,134 @@ bun run scripts/seed-memories.ts
 bun run scripts/seed-memories.ts --days 30
 ```
 
-The script reads directly from the OpenCode SQLite database, summarizes each conversation turn with Claude Haiku, and writes the results to `.memsearch/memory/`.
+The script reads directly from the OpenCode SQLite database, summarizes each conversation turn, and writes the results to `.memsearch/memory/`. The seed script respects the same [configuration](#configuration) as the plugin (config file and environment variables).
 
 ## Configuration
 
-The plugin auto-configures memsearch to use local embeddings. If you want to use a remote Milvus instance instead of the default local database, configure it via the memsearch CLI:
+The plugin can be configured via a JSON config file and/or environment variables. Environment variables take precedence over config file values, and project-level config takes precedence over global config.
+
+### Config file
+
+The plugin looks for config in two locations (highest precedence first):
+
+1. **Project config**: `.memsearch/config.json` in your project root
+2. **Global config**: `~/.config/opencode/memsearch.config.json`
+
+Both files use the same schema. Values from the project config override the global config.
+
+**Example:**
+
+```json
+{
+  "summarization_model": "anthropic/claude-sonnet-4-5",
+  "auto_configure_embedding": true
+}
+```
+
+All fields are optional. The full schema:
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `summarization_model` | `string` | `"anthropic/claude-haiku-4-5"` | The OpenCode model ID used to summarize conversation turns |
+| `auto_configure_embedding` | `boolean` | `true` | Whether the plugin auto-configures memsearch to use local embeddings on startup |
+
+### Summarization model
+
+Each conversation turn is summarized by an LLM before being stored. By default, the plugin uses `anthropic/claude-haiku-4-5` — a fast, cheap model that produces good summaries.
+
+To use a different model, set it in your config file:
+
+```json
+{
+  "summarization_model": "anthropic/claude-sonnet-4-5"
+}
+```
+
+Or override it with an environment variable:
+
+```bash
+export MEMSEARCH_SUMMARIZATION_MODEL="openai/gpt-4.1-mini"
+```
+
+The model must be available in your OpenCode configuration (i.e., you must have the provider configured and authenticated). Any model ID that works with `opencode run --model <id>` will work here.
+
+### Milvus storage
+
+The plugin uses [Milvus](https://milvus.io/) (via memsearch) as its vector database. There are two modes:
+
+#### Local mode (default)
+
+By default, memsearch uses **Milvus Lite**, which stores data in a local `.db` file (typically `~/.memsearch/milvus.db`). This requires no server setup — it just works.
+
+In local mode, the plugin re-indexes the memory directory on session start (to pick up any memories written since the last session) and again after each new summary is appended. File locking prevents concurrent access issues, so no background watcher is needed.
+
+#### Remote mode
+
+For concurrent access from multiple sessions or machines, you can point memsearch at a remote Milvus server:
 
 ```bash
 memsearch config set milvus.uri http://localhost:19530
 ```
 
-In remote mode, the plugin starts a file watcher process that automatically re-indexes memory files when they change.
+In remote mode, the plugin starts a **file watcher** process that continuously re-indexes memory files whenever they change. The watcher runs as a background process with its PID stored in `.memsearch/.watch.pid`.
+
+To switch back to local mode:
+
+```bash
+memsearch config set milvus.uri "~/.memsearch/milvus.db"
+```
+
+### Embedding provider
+
+By default, the plugin auto-configures memsearch to use **local embeddings** (`embedding.provider = local`). This is important because memsearch's own default is `openai`, which would require an API key and make network requests for every index and search operation.
+
+With local embeddings, the `all-MiniLM-L6-v2` model runs on your machine — no API calls needed for vector search.
+
+To manage the embedding provider yourself (e.g., to use OpenAI embeddings or a custom endpoint), disable auto-configuration:
+
+```json
+{
+  "auto_configure_embedding": false
+}
+```
+
+Or via environment variable:
+
+```bash
+export MEMSEARCH_AUTO_CONFIGURE_EMBEDDING=false
+```
+
+Then configure memsearch directly:
 
-## Environment variables
+```bash
+# Example: use OpenAI embeddings
+memsearch config set embedding.provider openai
+memsearch config set embedding.api_key "env:OPENAI_API_KEY"
+
+# Example: use a custom OpenAI-compatible endpoint
+memsearch config set embedding.provider openai
+memsearch config set embedding.base_url http://localhost:11434/v1
+memsearch config set embedding.model nomic-embed-text
+```
+
+See the [memsearch documentation](https://github.com/nicobako/memsearch) for all available embedding options.
+
+### Environment variables
 
 | Variable | Description |
 |----------|-------------|
-| `MEMSEARCH_DISABLE` | Set to any value to disable the plugin (used internally to prevent recursion during summarization) |
+| `MEMSEARCH_SUMMARIZATION_MODEL` | Override the model used for summarization (takes precedence over config file) |
+| `MEMSEARCH_AUTO_CONFIGURE_EMBEDDING` | Set to `false` or `0` to disable automatic local embedding configuration |
+| `MEMSEARCH_DISABLE` | Set to any value to disable the plugin entirely (used internally to prevent recursion during summarization) |
+
+### Precedence
+
+Configuration values are resolved in this order (highest precedence first):
+
+1. Environment variables
+2. Project config (`.memsearch/config.json`)
+3. Global config (`~/.config/opencode/memsearch.config.json`)
+4. Built-in defaults
 
 ## License
 

package/dist/index.js

@@ -3,7 +3,33 @@ import { tool } from "@opencode-ai/plugin";
 import { createHash } from "crypto";
 import { readdir, readFile, appendFile, mkdir, writeFile, unlink } from "fs/promises";
 import { join, basename, resolve } from "path";
-import { tmpdir } from "os";
+import { tmpdir, homedir } from "os";
+var DEFAULT_SUMMARIZATION_MODEL = "anthropic/claude-haiku-4-5";
+var GLOBAL_CONFIG_PATH = join(homedir(), ".config", "opencode", "memsearch.config.json");
+async function loadJsonConfig(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function loadConfig(projectDir) {
+  const projectPath = join(projectDir, ".memsearch", "config.json");
+  const globalConfig = await loadJsonConfig(GLOBAL_CONFIG_PATH);
+  const projectConfig = await loadJsonConfig(projectPath);
+  return { ...globalConfig, ...projectConfig };
+}
+function getSummarizationModel(config) {
+  return process.env.MEMSEARCH_SUMMARIZATION_MODEL || config.summarization_model || DEFAULT_SUMMARIZATION_MODEL;
+}
+function shouldAutoConfigureEmbedding(config) {
+  const envVal = process.env.MEMSEARCH_AUTO_CONFIGURE_EMBEDDING;
+  if (envVal !== undefined) {
+    return envVal !== "0" && envVal.toLowerCase() !== "false";
+  }
+  return config.auto_configure_embedding !== false;
+}
 function deriveCollectionName(directory) {
   const abs = resolve(directory);
   const sanitized = basename(abs).toLowerCase().replace(/[^a-z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 40);
@@ -37,7 +63,6 @@ Rules:
 - Do NOT continue the conversation after the bullet points
 - Do NOT ask follow-up questions
 - STOP immediately after the last bullet point`;
-var HAIKU_MODEL = "anthropic/claude-haiku-4-5";
 var TEMP_DIR = join(tmpdir(), "memsearch-plugin");
 var memsearchPlugin = async ({ client, $, directory }) => {
   if (process.env.MEMSEARCH_DISABLE) {
@@ -202,12 +227,12 @@ ${tail}
     return lines.join(`
 `);
   }
-  async function summarizeTranscript(transcript, sessionID, turnIdx) {
+  async function summarizeTranscript(transcript, sessionID, turnIdx, model) {
     const tempFile = join(TEMP_DIR, `turn-${sessionID}-${turnIdx}.txt`);
     await mkdir(TEMP_DIR, { recursive: true });
     await writeFile(tempFile, transcript);
     try {
-      const rawOutput = await $`opencode run -f ${tempFile} --model ${HAIKU_MODEL} --format json ${SUMMARIZE_PROMPT}`.env({ ...process.env, MEMSEARCH_DISABLE: "1" }).nothrow().quiet().text();
+      const rawOutput = await $`opencode run -f ${tempFile} --model ${model} --format json ${SUMMARIZE_PROMPT}`.env({ ...process.env, MEMSEARCH_DISABLE: "1" }).nothrow().quiet().text();
       let summarizationSessionID;
       const textParts = [];
       for (const line of rawOutput.split(`
@@ -288,7 +313,9 @@ ${tail}
 `);
   }
   await ensureMemsearch();
-  if (memsearchCmd) {
+  const pluginConfig = await loadConfig(directory);
+  const summarizationModel = getSummarizationModel(pluginConfig);
+  if (memsearchCmd && shouldAutoConfigureEmbedding(pluginConfig)) {
     await configureLocalEmbedding();
   }
   return {
@@ -398,7 +425,7 @@ The above is recent memory context from past sessions. Use the memsearch_search
             return;
           let summary;
           try {
-            summary = await summarizeTranscript(transcript, sessionID, state.lastSummarizedMessageCount);
+            summary = await summarizeTranscript(transcript, sessionID, state.lastSummarizedMessageCount, summarizationModel);
           } catch {
             summary = "";
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-memsearch",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Persistent cross-session memory for OpenCode, powered by memsearch",
   "type": "module",
   "main": "dist/index.js",

package/scripts/seed-memories.ts

@@ -8,18 +8,54 @@
  * This script:
  * 1. Reads session + message data directly from the OpenCode SQLite database
  * 2. For each session, formats each conversation turn as a transcript
- * 3. Summarizes each turn via `opencode run` with claude-haiku (one process per turn)
+ * 3. Summarizes each turn via `opencode run` (model is configurable, see README)
  * 4. Writes summaries to .memsearch/memory/YYYY-MM-DD.md files per project
  * 5. Indexes all memory files with memsearch
  */
 
 import { Database } from "bun:sqlite"
 import { createHash } from "crypto"
-import { appendFile, mkdir, writeFile, unlink } from "fs/promises"
+import { appendFile, mkdir, readFile, writeFile, unlink } from "fs/promises"
 import { join, basename, resolve } from "path"
 import { homedir, tmpdir } from "os"
 import { $ } from "bun"
 
+// --- Configuration ---
+
+interface PluginConfig {
+  /** Model ID used for summarization (e.g. "anthropic/claude-haiku-4-5") */
+  summarization_model?: string
+  /** Whether to auto-configure memsearch to use local embeddings (default: true) */
+  auto_configure_embedding?: boolean
+}
+
+const DEFAULT_SUMMARIZATION_MODEL = "anthropic/claude-haiku-4-5"
+const GLOBAL_CONFIG_PATH = join(homedir(), ".config", "opencode", "memsearch.config.json")
+
+async function loadJsonConfig(path: string): Promise<Partial<PluginConfig>> {
+  try {
+    const content = await readFile(path, "utf-8")
+    return JSON.parse(content)
+  } catch {
+    return {}
+  }
+}
+
+async function loadConfig(projectDir: string): Promise<PluginConfig> {
+  const projectPath = join(projectDir, ".memsearch", "config.json")
+  const globalConfig = await loadJsonConfig(GLOBAL_CONFIG_PATH)
+  const projectConfig = await loadJsonConfig(projectPath)
+  return { ...globalConfig, ...projectConfig }
+}
+
+function getSummarizationModel(config: PluginConfig): string {
+  return (
+    process.env.MEMSEARCH_SUMMARIZATION_MODEL ||
+    config.summarization_model ||
+    DEFAULT_SUMMARIZATION_MODEL
+  )
+}
+
 // --- Config ---
 
 const SUMMARIZE_PROMPT = `You are a third-person note-taker. The attached file contains a transcript of ONE conversation turn between a human and an AI coding agent. Tool calls are labeled [Tool Call] and their results [Tool Result] or [Tool Error].
@@ -39,8 +75,6 @@ Rules:
 - Do NOT ask follow-up questions
 - STOP immediately after the last bullet point`
 
-const HAIKU_MODEL = "anthropic/claude-haiku-4-5"
-
 const DB_PATH = join(homedir(), ".local", "share", "opencode", "opencode.db")
 const TEMP_DIR = join(tmpdir(), "memsearch-seed")
 
@@ -287,14 +321,14 @@ async function detectMemsearch(): Promise<string[]> {
 }
 
 // Summarize a transcript via `opencode run`
-async function summarizeWithOpencode(transcript: string, tempFile: string): Promise<string> {
+async function summarizeWithOpencode(transcript: string, tempFile: string, model: string): Promise<string> {
   // Write transcript to temp file
   await writeFile(tempFile, transcript)
 
   try {
     // Disable all plugins during summarization to avoid memsearch plugin
     // interfering with the LLM output (e.g. injecting "[memsearch] Memory available")
-    const rawOutput = await $`opencode run -f ${tempFile} --model ${HAIKU_MODEL} ${SUMMARIZE_PROMPT}`
+    const rawOutput = await $`opencode run -f ${tempFile} --model ${model} ${SUMMARIZE_PROMPT}`
       .env({ ...process.env, OPENCODE_CONFIG_CONTENT: JSON.stringify({ plugin: [] }) })
       .nothrow()
       .quiet()
@@ -331,6 +365,11 @@ async function main() {
   const memsearchCmd = await detectMemsearch()
   console.log(`Using memsearch: ${memsearchCmd.join(" ")}`)
 
+  // Load config from cwd (the project root the seed script is run from)
+  const config = await loadConfig(process.cwd())
+  const summarizationModel = getSummarizationModel(config)
+  console.log(`Summarization model: ${summarizationModel}`)
+
   await mkdir(TEMP_DIR, { recursive: true })
 
   // Open database (read-only)
@@ -426,7 +465,7 @@ async function main() {
         const tempFile = join(TEMP_DIR, `turn-${sessionNum}-${turnIdx}.txt`)
         let summary = ""
         try {
-          summary = await summarizeWithOpencode(transcript, tempFile)
+          summary = await summarizeWithOpencode(transcript, tempFile, summarizationModel)
           if (summary) totalSummarized++
         } catch {
           // LLM failed