memorius 0.4.0__tar.gz → 0.4.2__tar.gz

{memorius-0.4.0/memorius.egg-info → memorius-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorius
-Version: 0.4.0
+Version: 0.4.2
 Summary: Self-contained memory vault for any AI agent — vector search, session diaries, and agent-agnostic hooks.
 Author-email: dimonapatrick243 <dimona.patrick@gmail.com>
 License-Expression: MIT
@@ -53,6 +53,10 @@ Dynamic: license-file
 > 🧠 **Works with Claude Code, Codex CLI, Gemini CLI, OpenClaude, OpenCode, Pi, and any MCP-compatible agent.**
 >
 > 🌐 **Landing page:** https://dream-pixels-forge.github.io/memorius/
+>
+> If you find this project useful, leaving a star ⭐ on the repository is the best way to support my work!
+
+
 
 ## Why Memorius?
 
@@ -99,6 +103,9 @@ memorius status
 memorius diary --session "session-001" --title "Research findings"
 ```
 
+<img width="979" height="632" alt="Screenshot from 2026-06-18 15-14-39" src="https://github.com/user-attachments/assets/6cbca59b-1a3c-4b1d-85e8-dd5b256b9061" />
+
+
 ## Architecture
 
 ```

{memorius-0.4.0 → memorius-0.4.2}/README.md

@@ -16,6 +16,10 @@
 > 🧠 **Works with Claude Code, Codex CLI, Gemini CLI, OpenClaude, OpenCode, Pi, and any MCP-compatible agent.**
 >
 > 🌐 **Landing page:** https://dream-pixels-forge.github.io/memorius/
+>
+> If you find this project useful, leaving a star ⭐ on the repository is the best way to support my work!
+
+
 
 ## Why Memorius?
 
@@ -62,6 +66,9 @@ memorius status
 memorius diary --session "session-001" --title "Research findings"
 ```
 
+<img width="979" height="632" alt="Screenshot from 2026-06-18 15-14-39" src="https://github.com/user-attachments/assets/6cbca59b-1a3c-4b1d-85e8-dd5b256b9061" />
+
+
 ## Architecture
 
 ```

{memorius-0.4.0 → memorius-0.4.2}/memorius/__init__.py

@@ -26,4 +26,4 @@ Architecture:
     memorius:  Main CLI — init, mine, search, diary, status, serve, hook
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

{memorius-0.4.0 → memorius-0.4.2}/memorius/cli/main.py

@@ -2,6 +2,7 @@
 
 Usage:
   memorius init              Initialize a new vault
+  memorius setup             Download ONNX model and initialize vault
   memorius status            Show vault status
   memorius store <text>      Store a memory
   memorius search <query>    Semantic search across memories
@@ -15,6 +16,7 @@ Usage:
   memorius obsidian list     List notes in an Obsidian vault
   memorius obsidian import   Import Obsidian notes as memories
   memorius obsidian export   Export memories as Obsidian notes
+  memorius web <query>     Search the internet (web fallback)
 """
 
 from __future__ import annotations
@@ -28,6 +30,7 @@ from pathlib import Path
 from memorius import __version__
 from memorius.config import load_config, DEFAULT_CONFIG_DIR, DEFAULT_CONFIG_PATH
 from memorius.vault import VaultEngine
+from memorius.web_search import web_fallback_enabled, should_fallback
 
 logging.basicConfig(
     level=logging.WARNING,
@@ -36,7 +39,21 @@ logging.basicConfig(
 logger = logging.getLogger("memorius.cli")
 
 
+def _ensure_utf8_streams():
+    """Force UTF-8 on stdout/stderr so emoji/icons (e.g. the factcheck verdict
+    glyphs) don't crash on Windows cp1252 consoles. Best-effort: a stream
+    that can't be reconfigured (e.g. piped to a file) is left untouched."""
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if callable(reconfigure):
+            try:
+                reconfigure(encoding="utf-8", errors="replace")
+            except (ValueError, OSError):
+                pass
+
+
 def main():
+    _ensure_utf8_streams()
     parser = argparse.ArgumentParser(
         "memorius",
         description="Memory vault for any AI agent — store, search, and organize memories.",
@@ -48,6 +65,11 @@ def main():
     subparsers = parser.add_subparsers(dest="command")
 
     subparsers.add_parser("init", help="Initialize a new vault")
+    
+    setup_p = subparsers.add_parser("setup", help="Download ONNX model and initialize vault")
+    setup_p.add_argument("--force", action="store_true", help="Re-download model even if exists")
+    setup_p.add_argument("--skip-model", action="store_true", help="Skip model download, only init vault")
+    
     subparsers.add_parser("status", help="Show vault status")
 
     store_p = subparsers.add_parser("store", help="Store a memory")
@@ -62,6 +84,7 @@ def main():
     search_p.add_argument("--n", type=int, default=10, help="Number of results")
     search_p.add_argument("--vault", default=None, help="Filter by vault")
     search_p.add_argument("--shelf", default=None, help="Filter by shelf")
+    search_p.add_argument("--web", action="store_true", help="Fall back to web search if local recall is thin")
 
     mine_p = subparsers.add_parser("mine", help="Mine memories from a transcript")
     mine_p.add_argument("file", nargs="?", default=None, help="Transcript file path")
@@ -106,11 +129,18 @@ def main():
     factcheck_p = subparsers.add_parser("factcheck", help="Fact-check against stored memories")
     factcheck_p.add_argument("statement", nargs="?", default=None, help="Statement to verify")
     factcheck_p.add_argument("--vault", default=None, help="Filter by vault")
+    factcheck_p.add_argument("--web", action="store_true", help="Cross-check uncertain claims against the web")
 
     context_p = subparsers.add_parser("context", help="Get memory context for injection")
     context_p.add_argument("query", nargs="?", default=None, help="Topic to search for")
     context_p.add_argument("--vault", default=None, help="Filter by vault")
     context_p.add_argument("--max", type=int, default=5, help="Max items")
+    context_p.add_argument("--web", action="store_true", help="Augment with web results if no local context")
+
+    web_p = subparsers.add_parser("web", help="Search the internet (web fallback)")
+    web_p.add_argument("query", nargs="?", default=None, help="Search query")
+    web_p.add_argument("--max", type=int, default=5, help="Max results")
+    web_p.add_argument("--provider", default=None, help="Provider override (duckduckgo|mock)")
 
     profile_p = subparsers.add_parser("profile", help="Build session memory profile")
     profile_p.add_argument("session_id", nargs="?", default=None, help="Session ID")
@@ -158,6 +188,7 @@ def main():
     # Dispatch
     commands = {
         "init": cmd_init,
+        "setup": cmd_setup,
         "status": cmd_status,
         "store": cmd_store,
         "search": cmd_search,
@@ -173,6 +204,7 @@ def main():
         "extract": cmd_extract,
         "factcheck": cmd_factcheck,
         "context": cmd_context,
+        "web": cmd_web,
         "profile": cmd_profile,
         "stats": cmd_stats,
     }
@@ -199,6 +231,56 @@ def cmd_init(engine, args, config):
     print(f"Embeddings: {config.get('embeddings', {}).get('provider', 'chroma-default')}")
 
 
+def cmd_setup(engine, args, config):
+    """Download ONNX model and initialize vault."""
+    from memorius.model_download import is_model_downloaded, setup_model, get_model_path
+    
+    print("memorius setup")
+    print("=" * 50)
+    
+    # Step 1: Initialize vault
+    print("\n1. Initializing vault...")
+    DEFAULT_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    if not DEFAULT_CONFIG_PATH.exists():
+        from memorius.config import DEFAULT_CONFIG_YAML
+        DEFAULT_CONFIG_PATH.write_text(DEFAULT_CONFIG_YAML)
+        print(f"   Created config: {DEFAULT_CONFIG_PATH}")
+    else:
+        print(f"   Config exists: {DEFAULT_CONFIG_PATH}")
+    
+    engine._meta.ensure_vault("main", "Main vault")
+    print("   Vault initialized: main")
+    
+    # Step 2: Download ONNX model
+    if args.skip_model:
+        print("\n2. Skipping model download (--skip-model)")
+    else:
+        print("\n2. Setting up ONNX model...")
+        if is_model_downloaded() and not args.force:
+            print(f"   Model already downloaded: {get_model_path()}")
+        else:
+            if args.force:
+                print("   Force mode: re-downloading model...")
+            success = setup_model(force=args.force)
+            if not success:
+                print("\nSetup completed with errors.")
+                print("The vault is ready, but the ONNX model failed to download.")
+                print("You can try again later with: memorius setup --force")
+                return
+    
+    # Step 3: Verify
+    print("\n3. Verification...")
+    status = engine.status()
+    print(f"   Embeddings: {status['embedding_provider']} (dim={status['embedding_dimension']})")
+    
+    print("\n" + "=" * 50)
+    print("Setup complete!")
+    print("\nNext steps:")
+    print("  memorius store 'My first memory'  # Store a memory")
+    print("  memorius search 'first memory'    # Search for it")
+    print("  memorius status                   # Check vault status")
+
+
 def cmd_status(engine, args, config):
     """Show vault status."""
     status = engine.status()
@@ -260,6 +342,24 @@ def cmd_search(engine, args, config):
             print("   ...")
         print()
 
+    # Web fallback — only if local recall is thin ("if needed").
+    if web_fallback_enabled(args, config) and should_fallback(len(results), config):
+        from memorius.web_search import get_web_provider
+        provider = get_web_provider(config)
+        if provider:
+            web = provider.search(
+                query,
+                max_results=config.get("retrieval", {}).get("web_max_results", 5),
+            )
+            print("Web results (from internet):")
+            if not web:
+                print("  (no web results)")
+            for r in web:
+                print(f"  - {r.title}")
+                print(f"    {r.url}")
+                if r.snippet:
+                    print(f"    {r.snippet[:160]}")
+
 
 def cmd_mine(engine, args, config):
     """Mine memories from a transcript."""
@@ -432,6 +532,47 @@ def cmd_factcheck(engine, args, config):
         for m in result.contradicting_memories:
             print(f"    - [{m['vault']}/{m['shelf']}] {m['content'][:100]}")
 
+    # Web cross-check when the vault can't settle the claim.
+    if result.verdict in ("uncertain", "no_match") and web_fallback_enabled(args, config):
+        from memorius.web_search import get_web_provider
+        provider = get_web_provider(config)
+        if provider:
+            web = provider.search(
+                result.statement,
+                max_results=config.get("retrieval", {}).get("web_max_results", 5),
+            )
+            if web:
+                print("  Web cross-check:")
+                for r in web[:3]:
+                    print(f"    - {r.title}: {r.url}")
+
+
+def cmd_web(engine, args, config):
+    """Search the internet (web fallback primitive)."""
+    from memorius.web_search import get_web_provider
+
+    query = args.query
+    if not query:
+        query = sys.stdin.read().strip()
+    if not query:
+        print("Error: query required (pass as argument or pipe to stdin)")
+        return
+
+    provider = get_web_provider(config, provider=args.provider)
+    if not provider:
+        print("Error: no web provider available")
+        return
+
+    results = provider.search(query, max_results=args.max)
+    print(f'Web search: "{query}"')
+    print(f"Results: {len(results)}")
+    print()
+    for i, r in enumerate(results, 1):
+        print(f"{i}. {r.title}")
+        print(f"   {r.url}")
+        if r.snippet:
+            print(f"   {r.snippet[:200]}")
+
 
 def cmd_context(engine, args, config):
     """Get memory context for injection."""
@@ -445,6 +586,23 @@ def cmd_context(engine, args, config):
     context = engine.get_context(query, vault=args.vault, max_items=args.max)
     if context:
         print(context)
+    elif web_fallback_enabled(args, config):
+        from memorius.web_search import get_web_provider
+        provider = get_web_provider(config)
+        if provider:
+            web = provider.search(
+                query,
+                max_results=config.get("retrieval", {}).get("web_max_results", 5),
+            )
+            if web:
+                print("No matching memories. Web results (from internet):")
+                for r in web:
+                    print(f"- {r.title}")
+                    print(f"  {r.url}")
+                    if r.snippet:
+                        print(f"  {r.snippet[:160]}")
+            else:
+                print("No relevant memories or web results found.")
     else:
         print("No relevant memories found.")
 

{memorius-0.4.0 → memorius-0.4.2}/memorius/config.py

@@ -37,6 +37,12 @@ vault:
 hooks:
   enabled: true
   config: ~/.memorius/hooks.yaml
+
+retrieval:
+  web_fallback: false      # opt-in: augment thin local recall with web (local-first / privacy)
+  web_provider: duckduckgo  # duckduckgo (keyless) | mock (tests)
+  web_min_results: 1       # if ZERO local hits, fall back to web
+  web_max_results: 5       # max web results to return
 """
 
 
@@ -98,6 +104,12 @@ def _ensure_defaults(config: dict[str, Any]):
     vault_cfg.setdefault("default", "main")
     vault_cfg.setdefault("max_note_size", 1000)
 
+    retrieval = config.setdefault("retrieval", {})
+    retrieval.setdefault("web_fallback", False)
+    retrieval.setdefault("web_provider", "duckduckgo")
+    retrieval.setdefault("web_min_results", 1)
+    retrieval.setdefault("web_max_results", 5)
+
     hooks = config.setdefault("hooks", {})
     hooks.setdefault("enabled", True)
     hooks.setdefault("config", "~/.memorius/hooks.yaml")
@@ -112,6 +124,8 @@ def _apply_env_overrides(config: dict[str, Any]):
         "MEMORIUS_REST_PORT": ("server", "rest_port"),
         "MEMORIUS_HOST": ("server", "host"),
         "MEMORIUS_DEFAULT_VAULT": ("vault", "default"),
+        "MEMORIUS_WEB_FALLBACK": ("retrieval", "web_fallback"),
+        "MEMORIUS_WEB_PROVIDER": ("retrieval", "web_provider"),
     }
     for env_key, (section, key) in overrides.items():
         val = os.environ.get(env_key)

{memorius-0.4.0 → memorius-0.4.2}/memorius/embeddings.py

@@ -112,6 +112,7 @@ class ChromaDefaultProvider(EmbeddingProvider):
     """ChromaDB's built-in embedding function (ONNX all-MiniLM-L6-v2).
     
     No extra dependencies — ChromaDB ships its own ONNX runtime.
+    Auto-downloads the ONNX model on first use if not already present.
     """
     def __init__(self):
         try:
@@ -122,9 +123,31 @@ class ChromaDefaultProvider(EmbeddingProvider):
                 "  pip install memorius  (includes chromadb)\n"
                 "  or: pip install chromadb"
             )
+        
+        # Auto-download ONNX model if not present
+        self._ensure_model_downloaded()
+        
         self._fn = ef.DefaultEmbeddingFunction()
         self._dim = 384
 
+    def _ensure_model_downloaded(self):
+        """Ensure the ONNX model is downloaded before initializing.
+
+        Non-fatal: if the pre-download fails (e.g. no network), we warn
+        and continue — chromadb's DefaultEmbeddingFunction fetches its own
+        copy on first use.
+        """
+        from memorius.model_download import is_model_downloaded, setup_model
+
+        if not is_model_downloaded():
+            print("ONNX model not found. Downloading now...")
+            if not setup_model():
+                print(
+                    "Warning: could not pre-download the ONNX model via "
+                    "'memorius setup'. chromadb will attempt its own "
+                    "download on first use — ensure network access."
+                )
+
     def embed(self, texts: list[str]) -> list[list[float]]:
         result = self._fn(texts)
         return result

memorius-0.4.2/memorius/model_download.py

@@ -0,0 +1,183 @@
+"""ONNX model download utility for memorius.
+
+Downloads the all-MiniLM-L6-v2 ONNX model for ChromaDB's default embedding function.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import sys
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import Callable, Optional
+
+import httpx
+
+# Model configuration
+MODEL_NAME = "all-MiniLM-L6-v2"
+MODEL_URL = "https://chroma-onnx-models.s3.amazonaws.com/all-MiniLM-L6-v2/onnx.tar.gz"
+MODEL_SHA256 = "913d7300ceae3b2dbc2c50d1de4baacab4be7b9380491c27fab7418616a16ec3"
+EXTRACTED_FOLDER_NAME = "onnx"
+ARCHIVE_FILENAME = "onnx.tar.gz"
+
+# Default cache directory
+DEFAULT_CACHE_DIR = Path.home() / ".cache" / "memorius" / "onnx_models"
+
+
+def get_model_cache_dir() -> Path:
+    """Get the model cache directory from env var or default."""
+    env_dir = os.environ.get("MEMORIUS_MODEL_CACHE_DIR")
+    if env_dir:
+        return Path(env_dir)
+    return DEFAULT_CACHE_DIR
+
+
+def get_model_path() -> Path:
+    """Get the path to the extracted ONNX model."""
+    cache_dir = get_model_cache_dir()
+    return cache_dir / MODEL_NAME / EXTRACTED_FOLDER_NAME
+
+
+def is_model_downloaded() -> bool:
+    """Check if the ONNX model is already downloaded."""
+    model_path = get_model_path()
+    onnx_file = model_path / "model.onnx"
+    return onnx_file.exists()
+
+
+def _verify_sha256(file_path: Path, expected_hash: str) -> bool:
+    """Verify the SHA256 hash of a file."""
+    sha256 = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            sha256.update(chunk)
+    return sha256.hexdigest() == expected_hash
+
+
+def download_model(
+    force: bool = False,
+    progress_callback: Optional[Callable] = None,
+) -> Path:
+    """Download the ONNX model if not already present.
+    
+    Args:
+        force: If True, re-download even if model exists
+        progress_callback: Optional callback for progress updates (bytes_downloaded, total_bytes)
+    
+    Returns:
+        Path to the extracted model directory
+        
+    Raises:
+        RuntimeError: If download or extraction fails
+    """
+    cache_dir = get_model_cache_dir()
+    model_dir = cache_dir / MODEL_NAME
+    archive_path = model_dir / ARCHIVE_FILENAME
+    extracted_path = model_dir / EXTRACTED_FOLDER_NAME
+    
+    # Check if already downloaded
+    if not force and is_model_downloaded():
+        print(f"ONNX model already downloaded: {extracted_path}")
+        return extracted_path
+    
+    # Create directories
+    model_dir.mkdir(parents=True, exist_ok=True)
+    
+    print(f"Downloading ONNX model ({MODEL_NAME})...")
+    print(f"  URL: {MODEL_URL}")
+    print(f"  Destination: {model_dir}")
+    
+    try:
+        # Download with progress
+        with httpx.stream("GET", MODEL_URL, timeout=None) as response:
+            response.raise_for_status()
+            total_bytes = int(response.headers.get("content-length", 0))
+            
+            downloaded = 0
+            with open(archive_path, "wb") as f:
+                for chunk in response.iter_bytes(chunk_size=8192):
+                    f.write(chunk)
+                    downloaded += len(chunk)
+                    if progress_callback:
+                        progress_callback(downloaded, total_bytes)
+                    elif total_bytes > 0:
+                        percent = (downloaded / total_bytes) * 100
+                        print(f"\r  Progress: {percent:.1f}% ({downloaded}/{total_bytes} bytes)", end="", flush=True)
+            
+            if total_bytes > 0:
+                print()  # New line after progress
+            
+        print("Download complete. Verifying hash...")
+        
+        # Verify hash
+        if not _verify_sha256(archive_path, MODEL_SHA256):
+            raise RuntimeError(
+                f"Hash verification failed. Expected: {MODEL_SHA256}\n"
+                "The downloaded file may be corrupted. Please try again with --force."
+            )
+        
+        print("Hash verified. Extracting...")
+        
+        # Extract
+        with tarfile.open(archive_path, "r:gz") as tar:
+            tar.extractall(path=model_dir)
+        
+        # Clean up archive
+        archive_path.unlink()
+        
+        # Verify extraction
+        if not is_model_downloaded():
+            raise RuntimeError(
+                f"Extraction failed. Model file not found at: {extracted_path / 'model.onnx'}"
+            )
+        
+        print(f"Model downloaded successfully: {extracted_path}")
+        return extracted_path
+        
+    except httpx.HTTPError as e:
+        raise RuntimeError(
+            f"Failed to download ONNX model: {e}\n"
+            "Check your internet connection and try again."
+        )
+    except tarfile.TarError as e:
+        raise RuntimeError(
+            f"Failed to extract ONNX model: {e}\n"
+            "The downloaded file may be corrupted. Please try again with --force."
+        )
+    finally:
+        # Clean up partial downloads on failure
+        if archive_path.exists() and not is_model_downloaded():
+            archive_path.unlink()
+
+
+def setup_model(force: bool = False) -> bool:
+    """Setup the ONNX model. Returns True if successful."""
+    try:
+        download_model(force=force)
+        return True
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return False
+
+
+if __name__ == "__main__":
+    # Allow running as a script for testing
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Download ONNX model for memorius")
+    parser.add_argument("--force", action="store_true", help="Re-download even if model exists")
+    parser.add_argument("--check", action="store_true", help="Check if model is downloaded")
+    args = parser.parse_args()
+    
+    if args.check:
+        if is_model_downloaded():
+            print(f"Model is downloaded: {get_model_path()}")
+            sys.exit(0)
+        else:
+            print("Model is not downloaded.")
+            sys.exit(1)
+    
+    success = setup_model(force=args.force)
+    sys.exit(0 if success else 1)

{memorius-0.4.0 → memorius-0.4.2}/memorius/rest_server.py

@@ -28,7 +28,7 @@ class MemoriusAPI:
     def __init__(self, engine):
         self._engine = engine
         self._request_counts: dict[str, list[float]] = {}  # IP -> [timestamps]
-        self._rate_limit_max = 100  # requests per minute
+        self._rate_limit_max = 500  # requests per minute
         self._rate_limit_window = 60  # seconds
 
     def create_app(self):
@@ -46,9 +46,10 @@ class MemoriusAPI:
         # CORS — restrictive by default
         app.add_middleware(
             CORSMiddleware,
-            allow_origins=["http://127.0.0.1", "http://localhost"],
-            allow_methods=["GET", "POST"],
+            allow_origins=["http://127.0.0.1", "http://localhost", "http://127.0.0.1:*", "http://localhost:*", "app://obsidian.md", "file://"],
+            allow_methods=["GET", "POST", "OPTIONS"],
             allow_headers=["Content-Type", "Authorization"],
+            allow_credentials=True,
         )
 
         # API key authentication