feat(isolation): add user_id and session_id support for multi-tenant memory isolation

- Add user_id and session_id fields to MemoryEntry model with optional serialization
- Extend MemeBuilder with user_id() and session_id() configuration methods
- Add Scope struct to VectorStore for filtering queries by user/session context
- Update all CLI commands (add, ask, export, import, list) with --user-id and --session-id flags
- Implement automatic scope injection in Meme::store_entries and Meme::import

Author: gitctrlx

.github/workflows/rust-publish.yml

@@ -36,9 +36,4 @@ jobs:
         env:
           CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
         run: |
-          for pkg in meme meme-cli; do
-            echo "Publishing $pkg..."
-            cargo publish -p "$pkg"
-            echo "Waiting for crates.io to index $pkg..."
-            sleep 30
-          done
+          cargo publish

meme-cli/src/commands/add.rs

@@ -19,6 +19,14 @@ pub struct AddCmd {
     /// Import dialogues from a JSONL file.
     #[arg(long, value_name = "FILE")]
     pub file: Option<String>,
+
+    /// User identifier for memory isolation.
+    #[arg(long)]
+    pub user_id: Option<String>,
+
+    /// Session identifier for memory isolation.
+    #[arg(long)]
+    pub session_id: Option<String>,
 }
 
 impl AddCmd {
@@ -54,10 +62,14 @@ impl AddCmd {
             })
             .transpose()?;
 
-        let meme = meme::MemeBuilder::new()
-            .build()
-            .await
-            .map_err(|e| anyhow::anyhow!("{e}"))?;
+        let mut builder = meme::MemeBuilder::new();
+        if let Some(uid) = &self.user_id {
+            builder = builder.user_id(uid);
+        }
+        if let Some(sid) = &self.session_id {
+            builder = builder.session_id(sid);
+        }
+        let meme = builder.build().await.map_err(|e| anyhow::anyhow!("{e}"))?;
         meme.add_dialogue(speaker, content, timestamp)
             .await
             .map_err(|e| anyhow::anyhow!("{e}"))?;
@@ -96,10 +108,14 @@ impl AddCmd {
         }
 
         let count = dialogues.len();
-        let meme = meme::MemeBuilder::new()
-            .build()
-            .await
-            .map_err(|e| anyhow::anyhow!("{e}"))?;
+        let mut builder = meme::MemeBuilder::new();
+        if let Some(uid) = &self.user_id {
+            builder = builder.user_id(uid);
+        }
+        if let Some(sid) = &self.session_id {
+            builder = builder.session_id(sid);
+        }
+        let meme = builder.build().await.map_err(|e| anyhow::anyhow!("{e}"))?;
         meme.add_dialogues(dialogues)
             .await
             .map_err(|e| anyhow::anyhow!("{e}"))?;

meme-cli/src/commands/ask.rs

@@ -7,6 +7,14 @@ use clap::Args;
 pub struct AskCmd {
     /// The question to ask.
     pub question: String,
+
+    /// User identifier for memory isolation.
+    #[arg(long)]
+    pub user_id: Option<String>,
+
+    /// Session identifier for memory isolation.
+    #[arg(long)]
+    pub session_id: Option<String>,
 }
 
 impl AskCmd {
@@ -16,10 +24,14 @@ impl AskCmd {
     ///
     /// Returns an error if the query fails.
     pub async fn run(&self) -> anyhow::Result<()> {
-        let meme = meme::MemeBuilder::new()
-            .build()
-            .await
-            .map_err(|e| anyhow::anyhow!("{e}"))?;
+        let mut builder = meme::MemeBuilder::new();
+        if let Some(uid) = &self.user_id {
+            builder = builder.user_id(uid);
+        }
+        if let Some(sid) = &self.session_id {
+            builder = builder.session_id(sid);
+        }
+        let meme = builder.build().await.map_err(|e| anyhow::anyhow!("{e}"))?;
 
         let answer = meme
             .ask(&self.question)

meme-cli/src/commands/export.rs

@@ -8,6 +8,14 @@ pub struct ExportCmd {
     /// Output file path (stdout if not specified).
     #[arg(short, long)]
     pub output: Option<String>,
+
+    /// User identifier for memory isolation.
+    #[arg(long)]
+    pub user_id: Option<String>,
+
+    /// Session identifier for memory isolation.
+    #[arg(long)]
+    pub session_id: Option<String>,
 }
 
 impl ExportCmd {
@@ -17,10 +25,14 @@ impl ExportCmd {
     ///
     /// Returns an error if the export fails.
     pub async fn run(&self) -> anyhow::Result<()> {
-        let meme = meme::MemeBuilder::new()
-            .build()
-            .await
-            .map_err(|e| anyhow::anyhow!("{e}"))?;
+        let mut builder = meme::MemeBuilder::new();
+        if let Some(uid) = &self.user_id {
+            builder = builder.user_id(uid);
+        }
+        if let Some(sid) = &self.session_id {
+            builder = builder.session_id(sid);
+        }
+        let meme = builder.build().await.map_err(|e| anyhow::anyhow!("{e}"))?;
 
         let entries = meme
             .get_all_memories()
@@ -45,6 +57,14 @@ impl ExportCmd {
 pub struct ImportCmd {
     /// Input file path.
     pub file: String,
+
+    /// User identifier for memory isolation.
+    #[arg(long)]
+    pub user_id: Option<String>,
+
+    /// Session identifier for memory isolation.
+    #[arg(long)]
+    pub session_id: Option<String>,
 }
 
 impl ImportCmd {
@@ -53,16 +73,29 @@ impl ImportCmd {
     /// # Errors
     ///
     /// Returns an error if the import fails.
-    #[allow(clippy::unused_async)]
     pub async fn run(&self) -> anyhow::Result<()> {
         let content = std::fs::read_to_string(&self.file)?;
-        let entries: Vec<meme::model::MemoryEntry> = serde_json::from_str(&content)?;
+        let mut entries: Vec<meme::model::MemoryEntry> = serde_json::from_str(&content)?;
 
         let count = entries.len();
-        println!("Parsed {count} entries from {}", self.file);
-        println!("Note: Direct entry import requires embedding recomputation.");
-        println!("Use `meme add --file` for JSONL dialogue import instead.");
+        println!(
+            "Importing {count} entries from {} (recomputing embeddings)...",
+            self.file
+        );
+
+        let mut builder = meme::MemeBuilder::new();
+        if let Some(uid) = &self.user_id {
+            builder = builder.user_id(uid);
+        }
+        if let Some(sid) = &self.session_id {
+            builder = builder.session_id(sid);
+        }
+        let meme = builder.build().await.map_err(|e| anyhow::anyhow!("{e}"))?;
+        meme.import_entries(&mut entries)
+            .await
+            .map_err(|e| anyhow::anyhow!("{e}"))?;
 
+        println!("Imported {count} entries successfully.");
         Ok(())
     }
 }

meme-cli/src/commands/list.rs

@@ -13,6 +13,14 @@ pub struct ListCmd {
     /// Output as JSON.
     #[arg(long)]
     pub json: bool,
+
+    /// User identifier for memory isolation.
+    #[arg(long)]
+    pub user_id: Option<String>,
+
+    /// Session identifier for memory isolation.
+    #[arg(long)]
+    pub session_id: Option<String>,
 }
 
 impl ListCmd {
@@ -22,10 +30,14 @@ impl ListCmd {
     ///
     /// Returns an error if the query fails.
     pub async fn run(&self) -> anyhow::Result<()> {
-        let meme = meme::MemeBuilder::new()
-            .build()
-            .await
-            .map_err(|e| anyhow::anyhow!("{e}"))?;
+        let mut builder = meme::MemeBuilder::new();
+        if let Some(uid) = &self.user_id {
+            builder = builder.user_id(uid);
+        }
+        if let Some(sid) = &self.session_id {
+            builder = builder.session_id(sid);
+        }
+        let meme = builder.build().await.map_err(|e| anyhow::anyhow!("{e}"))?;
 
         let entries = meme
             .get_all_memories()

meme/src/embedding/api.rs

@@ -12,6 +12,7 @@ pub struct ApiEmbedding {
     api_key: String,
     model: String,
     dimension: usize,
+    max_retries: u32,
 }
 
 impl ApiEmbedding {
@@ -29,6 +30,7 @@ impl ApiEmbedding {
             api_key: api_key.into(),
             model: model.into(),
             dimension,
+            max_retries: 3,
         }
     }
 
@@ -86,6 +88,25 @@ impl ApiEmbedding {
     }
 
     async fn embed(&self, input: Vec<String>) -> Result<Vec<Vec<f32>>> {
+        let mut last_err = None;
+        for attempt in 0..self.max_retries {
+            match self.call_embed_api(&input).await {
+                Ok(vectors) => return Ok(vectors),
+                Err(e) => {
+                    tracing::warn!(attempt = attempt + 1, error = %e, "embedding API call failed");
+                    last_err = Some(e);
+                    if attempt + 1 < self.max_retries {
+                        let wait = 1u64 << attempt;
+                        tokio::time::sleep(std::time::Duration::from_secs(wait)).await;
+                    }
+                }
+            }
+        }
+        Err(last_err
+            .unwrap_or_else(|| Error::Embedding("all embedding retries exhausted".to_owned())))
+    }
+
+    async fn call_embed_api(&self, input: &[String]) -> Result<Vec<Vec<f32>>> {
         let url = format!("{}/embeddings", self.base_url);
 
         let body = serde_json::json!({