Merge branch 'main' into add-platform-builds

Author: Gioee

API.md

@@ -32,7 +32,7 @@ sqlite-memory enables semantic search over text content stored in SQLite. It:
 
 ## Sync Behavior
 
-All `memory_sync_*` functions use **content-hash change detection** to avoid redundant embedding computation. Each piece of content is hashed before processing — if the hash already exists in the database, the content is skipped.
+All `memory_add_*` functions use **content-hash change detection** to avoid redundant embedding computation. Each piece of content is hashed before processing — if the hash already exists in the database, the content is skipped.
 
 ### Change Detection
 
@@ -114,6 +114,7 @@ Configures the embedding model to use.
 - Remote embedding requires a free API key from [vectors.space](https://vectors.space) (set via `memory_set_apikey`)
 - Settings are persisted in `dbmem_settings` table
 - For local models, the embedding engine is initialized immediately
+- **Automatic reindex**: If a model was previously configured and the new provider/model differs, all existing content is automatically re-embedded with the new model. File-based entries are re-read from disk; text-based entries are re-embedded from stored content. Errors on individual entries are silently skipped (best-effort)
 
 **Example:**
 ```sql
@@ -200,7 +201,7 @@ SELECT memory_get_option('provider');
 
 ### Memory Management Functions
 
-#### `memory_sync_text(content TEXT [, context TEXT])`
+#### `memory_add_text(content TEXT [, context TEXT])`
 
 Syncs text content to memory. Duplicate content (same hash) is skipped automatically.
 
@@ -222,15 +223,15 @@ Syncs text content to memory. Duplicate content (same hash) is skipped automatic
 **Example:**
 ```sql
 -- Add text without context
-SELECT memory_sync_text('SQLite is a C-language library that implements a small, fast, self-contained SQL database engine.');
+SELECT memory_add_text('SQLite is a C-language library that implements a small, fast, self-contained SQL database engine.');
 
 -- Add text with context
-SELECT memory_sync_text('Important meeting notes from 2024-01-15...', 'meetings');
+SELECT memory_add_text('Important meeting notes from 2024-01-15...', 'meetings');
 ```
 
 ---
 
-#### `memory_sync_file(path TEXT [, context TEXT])`
+#### `memory_add_file(path TEXT [, context TEXT])`
 
 Syncs a file to memory. Unchanged files are skipped; modified files are atomically replaced.
 
@@ -250,13 +251,13 @@ Syncs a file to memory. Unchanged files are skipped; modified files are atomical
 
 **Example:**
 ```sql
-SELECT memory_sync_file('/docs/readme.md');
-SELECT memory_sync_file('/docs/api.md', 'documentation');
+SELECT memory_add_file('/docs/readme.md');
+SELECT memory_add_file('/docs/api.md', 'documentation');
 ```
 
 ---
 
-#### `memory_sync_directory(path TEXT [, context TEXT])`
+#### `memory_add_directory(path TEXT [, context TEXT])`
 
 Synchronizes a directory with memory. Adds new files, reindexes modified files, and removes entries for deleted files.
 
@@ -282,13 +283,13 @@ Synchronizes a directory with memory. Adds new files, reindexes modified files,
 
 **Example:**
 ```sql
-SELECT memory_sync_directory('/path/to/docs');
+SELECT memory_add_directory('/path/to/docs');
 -- Returns: 42 (number of new files processed)
 
-SELECT memory_sync_directory('/project/notes', 'project-notes');
+SELECT memory_add_directory('/project/notes', 'project-notes');
 
 -- Safe to call again — unchanged files are skipped
-SELECT memory_sync_directory('/path/to/docs');
+SELECT memory_add_directory('/path/to/docs');
 -- Returns: 0 (nothing changed)
 ```
 
@@ -476,7 +477,7 @@ The extension tracks two timestamps for each memory:
 
 ### `created_at`
 
-- Set automatically when content is added via `memory_sync_text`, `memory_sync_file`, or `memory_sync_directory`
+- Set automatically when content is added via `memory_add_text`, `memory_add_file`, or `memory_add_directory`
 - Stored as Unix timestamp (seconds since 1970-01-01 00:00:00 UTC)
 - Never updated after initial creation
 
@@ -517,8 +518,8 @@ SELECT memory_set_option('max_tokens', 512);
 SELECT memory_set_option('min_score', 0.75);
 
 -- Add content
-SELECT memory_sync_text('SQLite is a C library that provides a lightweight disk-based database.', 'sqlite-docs');
-SELECT memory_sync_directory('/docs/sqlite', 'sqlite-docs');
+SELECT memory_add_text('SQLite is a C library that provides a lightweight disk-based database.', 'sqlite-docs');
+SELECT memory_add_directory('/docs/sqlite', 'sqlite-docs');
 
 -- Search
 SELECT path, snippet, ranking
@@ -546,9 +547,9 @@ SELECT memory_clear();
 
 ```sql
 -- Add memories with different contexts
-SELECT memory_sync_text('Meeting notes...', 'meetings');
-SELECT memory_sync_text('API documentation...', 'api-docs');
-SELECT memory_sync_text('Tutorial content...', 'tutorials');
+SELECT memory_add_text('Meeting notes...', 'meetings');
+SELECT memory_add_text('API documentation...', 'api-docs');
+SELECT memory_add_text('Tutorial content...', 'tutorials');
 
 -- Search within a context
 SELECT * FROM memory_search
@@ -618,6 +619,6 @@ Errors can be caught using standard SQLite error handling mechanisms.
 
 ```sql
 -- Example error handling in application code
-SELECT memory_sync_text(123);  -- Error: expects TEXT parameter
+SELECT memory_add_text(123);  -- Error: expects TEXT parameter
 SELECT memory_delete('abc');  -- Error: expects INTEGER parameter
 ```

README.md

@@ -83,16 +83,16 @@ SELECT memory_set_model('local', '/path/to/nomic-embed-text-v1.5.Q8_0.gguf');
 -- SELECT memory_set_apikey('your-vectorspace-api-key');
 
 -- Add some knowledge
-SELECT memory_sync_text('SQLite is a C-language library that implements a small, fast,
+SELECT memory_add_text('SQLite is a C-language library that implements a small, fast,
 self-contained, high-reliability, full-featured, SQL database engine. SQLite is the
 most used database engine in the world.', 'sqlite-docs');
 
-SELECT memory_sync_text('Vector databases store data as high-dimensional vectors,
+SELECT memory_add_text('Vector databases store data as high-dimensional vectors,
 enabling similarity search. They are essential for semantic search, recommendation
 systems, and AI applications.', 'concepts');
 
 -- Sync an entire documentation directory
-SELECT memory_sync_directory('/path/to/docs', 'project-docs');
+SELECT memory_add_directory('/path/to/docs', 'project-docs');
 
 -- Search your memory semantically
 SELECT path, snippet, ranking
@@ -124,7 +124,7 @@ conn.execute("SELECT memory_set_model('local', './models/nomic-embed-text-v1.5.Q
 
 # Store conversation context
 def remember(content, context="conversation"):
-    conn.execute("SELECT memory_sync_text(?, ?)", (content, context))
+    conn.execute("SELECT memory_add_text(?, ?)", (content, context))
     conn.commit()
 
 # Retrieve relevant memories
@@ -147,11 +147,11 @@ memories = recall("what's the project timeline")
 
 ## Intelligent Sync
 
-All `memory_sync_*` functions use content-hash change detection to avoid redundant work:
+All `memory_add_*` functions use content-hash change detection to avoid redundant work:
 
-- **`memory_sync_text`** — Computes a hash of the content. If the same content was already indexed, it is skipped entirely. No duplicate embeddings are ever created.
-- **`memory_sync_file`** — Reads the file and hashes its content. If the file was previously indexed with different content, the old entry (chunks, embeddings, FTS) is atomically replaced. Unchanged files are skipped.
-- **`memory_sync_directory`** — Performs a full two-phase sync:
+- **`memory_add_text`** — Computes a hash of the content. If the same content was already indexed, it is skipped entirely. No duplicate embeddings are ever created.
+- **`memory_add_file`** — Reads the file and hashes its content. If the file was previously indexed with different content, the old entry (chunks, embeddings, FTS) is atomically replaced. Unchanged files are skipped.
+- **`memory_add_directory`** — Performs a full two-phase sync:
   1. **Cleanup**: Removes database entries for files that no longer exist on disk
   2. **Scan**: Recursively processes all matching files — adding new ones, replacing modified ones, and skipping unchanged ones
 
@@ -240,7 +240,7 @@ make test
 
 - **Local Engine**: Built-in llama.cpp for on-device embeddings (requires GGUF model)
 - **Remote Engine**: [vectors.space](https://vectors.space) API for cloud embeddings (requires free API key)
-- **File I/O**: `memory_sync_file` and `memory_sync_directory` functions
+- **File I/O**: `memory_add_file` and `memory_add_directory` functions
 
 You can also combine options manually:
 

src/dbmem-embed.h

@@ -22,15 +22,13 @@ typedef struct {
     float    *embedding;            // Pointer to embedding (points to engine's buffer, do not free)
 } embedding_result_t;
 
-dbmem_local_engine_t *dbmem_local_engine_init (const char *model_path, char err_msg[DBMEM_ERRBUF_SIZE]);
+dbmem_local_engine_t *dbmem_local_engine_init (void *ctx, const char *model_path, char err_msg[DBMEM_ERRBUF_SIZE]);
 int  dbmem_local_compute_embedding (dbmem_local_engine_t *engine, const char *text, int text_len, embedding_result_t *result);
 bool dbmem_local_engine_warmup (dbmem_local_engine_t *engine);
 void dbmem_local_engine_free (dbmem_local_engine_t *engine);
-const char *dbmem_local_errmsg (dbmem_local_engine_t *engine);
 
-dbmem_remote_engine_t *dbmem_remote_engine_init (const char *provider, const char *model, char err_msg[DBMEM_ERRBUF_SIZE]);
+dbmem_remote_engine_t *dbmem_remote_engine_init (void *ctx, const char *provider, const char *model, char err_msg[DBMEM_ERRBUF_SIZE]);
 int  dbmem_remote_compute_embedding (dbmem_remote_engine_t *engine, const char *text, int text_len, embedding_result_t *result);
 void dbmem_remote_engine_free (dbmem_remote_engine_t *engine);
-const char *dbmem_remote_errmsg (dbmem_remote_engine_t *engine);
 
 #endif

src/dbmem-lembed.c

@@ -6,20 +6,22 @@
 //
 
 #include "dbmem-embed.h"
+#include "sqlite-memory.h"
 #include "llama.h"
 #include "ggml.h"
 
 #include <math.h>
 #include <string.h>
 
 struct dbmem_local_engine_t {
+    dbmem_context               *context;
+    
     // Model and context
     struct llama_model          *model;                     // Loaded GGUF model weights and architecture
     struct llama_context        *ctx;                       // Inference context with KV cache and compute buffers
     const struct llama_vocab    *vocab;                     // Tokenizer vocabulary for text-to-token conversion
     enum llama_pooling_type     pooling;                    // Pooling strategy (NONE, MEAN, CLS, LAST, RANK)
     llama_memory_t              mem;                        // KV cache memory handle for clearing between batches
-    char                        err_msg[DBMEM_ERRBUF_SIZE]; // Error message
 
     // Model info
     int                         n_embd;                     // Embedding dimension (e.g., 768 for nomic-embed)
@@ -98,7 +100,7 @@ void dbmem_logger (enum ggml_log_level level, const char *text, void *user_data)
 
 // MARK: -
 
-dbmem_local_engine_t *dbmem_local_engine_init (const char *model_path, char err_msg[DBMEM_ERRBUF_SIZE]) {
+dbmem_local_engine_t *dbmem_local_engine_init (void *ctx, const char *model_path, char err_msg[DBMEM_ERRBUF_SIZE]) {
     dbmem_local_engine_t *engine = (dbmem_local_engine_t *)dbmem_zeroalloc(sizeof(dbmem_local_engine_t));
     if (!engine) return NULL;
 
@@ -203,15 +205,14 @@ bool dbmem_local_engine_warmup (dbmem_local_engine_t *engine) {
 }
 
 int dbmem_local_compute_embedding (dbmem_local_engine_t *engine, const char *text, int text_len, embedding_result_t *result) {
-    engine->err_msg[0] = 0;
     memset(result, 0, sizeof(embedding_result_t));
     if (text_len == -1) text_len = (int)strlen(text);
     if (text_len == 0) return 0;
 
     // Tokenize
     int n_tokens = llama_tokenize(engine->vocab, text, text_len, engine->tokens, engine->tokens_capacity, true, true);
     if (n_tokens < 0) {
-        snprintf(engine->err_msg, DBMEM_ERRBUF_SIZE, "Tokenization failed (text too long?)");
+        dbmem_context_set_error(engine->context, "Tokenization failed (text too long?)");
         return -1;
     }
 
@@ -241,7 +242,7 @@ int dbmem_local_compute_embedding (dbmem_local_engine_t *engine, const char *tex
     // Encode
     int ret = llama_encode(engine->ctx, batch);
     if (ret != 0) {
-        snprintf(engine->err_msg, DBMEM_ERRBUF_SIZE, "llama_encode failed");
+        dbmem_context_set_error(engine->context, "Llama_encode failed");
         return -1;
     }
 
@@ -254,7 +255,7 @@ int dbmem_local_compute_embedding (dbmem_local_engine_t *engine, const char *tex
     }
 
     if (!emb_ptr) {
-        snprintf(engine->err_msg, DBMEM_ERRBUF_SIZE, "Failed to get embeddings");
+        dbmem_context_set_error(engine->context, "Failed to get embeddings");
         return -1;
     }
 
@@ -302,6 +303,3 @@ void dbmem_local_engine_free (dbmem_local_engine_t *engine) {
     llama_backend_free();
 }
 
-const char *dbmem_local_errmsg (dbmem_local_engine_t *engine) {
-    return engine->err_msg;
-}