memorius 0.4.2__tar.gz → 0.4.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorius
-Version: 0.4.2
+Version: 0.4.3
 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

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

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

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

@@ -40,7 +40,8 @@ hooks:
 
 retrieval:
   web_fallback: false      # opt-in: augment thin local recall with web (local-first / privacy)
-  web_provider: duckduckgo  # duckduckgo (keyless) | mock (tests)
+  web_provider: duckduckgo  # duckduckgo (keyless) | tavily (keyed) | mock (tests)
+  tavily_api_key: null      # or set TAVILY_API_KEY env var
   web_min_results: 1       # if ZERO local hits, fall back to web
   web_max_results: 5       # max web results to return
 """
@@ -107,6 +108,7 @@ def _ensure_defaults(config: dict[str, Any]):
     retrieval = config.setdefault("retrieval", {})
     retrieval.setdefault("web_fallback", False)
     retrieval.setdefault("web_provider", "duckduckgo")
+    retrieval.setdefault("tavily_api_key", None)
     retrieval.setdefault("web_min_results", 1)
     retrieval.setdefault("web_max_results", 5)
 
@@ -126,6 +128,7 @@ def _apply_env_overrides(config: dict[str, Any]):
         "MEMORIUS_DEFAULT_VAULT": ("vault", "default"),
         "MEMORIUS_WEB_FALLBACK": ("retrieval", "web_fallback"),
         "MEMORIUS_WEB_PROVIDER": ("retrieval", "web_provider"),
+        "MEMORIUS_TAVILY_API_KEY": ("retrieval", "tavily_api_key"),
     }
     for env_key, (section, key) in overrides.items():
         val = os.environ.get(env_key)

{memorius-0.4.2 → memorius-0.4.3}/memorius/web_search.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import html
 import logging
+import os
 import urllib.parse
 import urllib.request
 from abc import ABC, abstractmethod
@@ -82,6 +83,68 @@ class DuckDuckGoProvider(WebSearchProvider):
         return _parse_ddg_lite(raw, max_results)
 
 
+class TavilyProvider(WebSearchProvider):
+    """Tavily web search — API key required, best signal-to-noise for agents.
+
+    Key from ``api_key`` arg, config ``retrieval.tavily_api_key``, or
+    the ``TAVILY_API_KEY`` env var. Missing key -> warns + returns [].
+    """
+
+    name = "tavily"
+    _ENDPOINT = "https://api.tavily.com/search"
+
+    def __init__(self, api_key: str | None = None, timeout: float = 15.0):
+        self._api_key = api_key
+        self.timeout = timeout
+
+    def _resolve_key(self) -> str:
+        key = self._api_key or os.environ.get("TAVILY_API_KEY")
+        if not key:
+            raise RuntimeError(
+                "Tavily requires an API key: set TAVILY_API_KEY or "
+                "retrieval.tavily_api_key in config."
+            )
+        return key
+
+    def search(self, query: str, max_results: int = 5) -> list[WebResult]:
+        import json
+        try:
+            key = self._resolve_key()
+        except RuntimeError as e:
+            logger.warning(str(e))
+            return []
+        payload = {
+            "api_key": key,
+            "query": query,
+            "max_results": max_results,
+            "search_depth": "basic",
+            "include_answer": False,
+            "include_raw_content": False,
+        }
+        data = json.dumps(payload).encode()
+        req = urllib.request.Request(
+            self._ENDPOINT,
+            data=data,
+            headers={"Content-Type": "application/json"},
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                body = json.loads(resp.read().decode("utf-8", "replace"))
+        except Exception as e:  # network/timeout/auth — never crash the CLI
+            logger.warning("Tavily search failed: %s", e)
+            return []
+        out: list[WebResult] = []
+        for r in body.get("results", [])[:max_results]:
+            out.append(
+                WebResult(
+                    title=r.get("title", ""),
+                    url=r.get("url", ""),
+                    snippet=r.get("content", ""),
+                )
+            )
+        return out
+
+
 class MockProvider(WebSearchProvider):
     """Test double: returns canned results from a ``query -> [WebResult]`` map."""
 
@@ -164,6 +227,9 @@ def get_web_provider(
     """Build the configured web provider, or ``None`` if unavailable."""
     retrieval = config.get("retrieval", {}) if isinstance(config, dict) else {}
     name = (provider or retrieval.get("web_provider", "duckduckgo")).lower()
+    if name == "tavily":
+        retrieval = config.get("retrieval", {}) if isinstance(config, dict) else {}
+        return TavilyProvider(api_key=retrieval.get("tavily_api_key"))
     if name == "mock":
         return MockProvider()
     if name == "duckduckgo":

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorius
-Version: 0.4.2
+Version: 0.4.3
 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

{memorius-0.4.2 → memorius-0.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "memorius"
-version = "0.4.2"
+version = "0.4.3"
 description = "Self-contained memory vault for any AI agent — vector search, session diaries, and agent-agnostic hooks."
 readme = "README.md"
 requires-python = ">=3.11"

{memorius-0.4.2 → memorius-0.4.3}/tests/test_web_search.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from memorius.web_search import (
     DuckDuckGoProvider,
     MockProvider,
+    TavilyProvider,
     WebResult,
     _parse_ddg_lite,
     get_web_provider,
@@ -67,11 +68,51 @@ def test_get_web_provider_mock():
     assert isinstance(p, MockProvider)
 
 
+def test_get_web_provider_tavily():
+    p = get_web_provider(_cfg(web_provider="tavily"))
+    assert isinstance(p, TavilyProvider)
+
+
 def test_get_web_provider_unknown_falls_back_to_duckduckgo(caplog):
     p = get_web_provider(_cfg(web_provider="bogus"))
     assert isinstance(p, DuckDuckGoProvider)
 
 
+def test_tavily_provider_parses_response(monkeypatch):
+    import json
+    import urllib.request
+
+    fake = json.dumps({
+        "results": [
+            {"title": "Tavily A", "url": "https://a", "content": "snippet A"},
+            {"title": "Tavily B", "url": "https://b", "content": "snippet B"},
+        ]
+    }).encode()
+
+    class _Resp:
+        def read(self):
+            return fake
+        def __enter__(self):
+            return self
+        def __exit__(self, *a):
+            return False
+
+    monkeypatch.setattr(urllib.request, "urlopen", lambda *a, **k: _Resp())
+    p = TavilyProvider(api_key="tvly-x")
+    out = p.search("query", max_results=5)
+    assert len(out) == 2
+    assert out[0].title == "Tavily A"
+    assert out[0].url == "https://a"
+    assert out[0].snippet == "snippet A"
+
+
+def test_tavily_provider_no_key_returns_empty(monkeypatch, capsys):
+    monkeypatch.delenv("TAVILY_API_KEY", raising=False)
+    p = TavilyProvider(api_key=None)
+    assert p.search("q") == []   # warns, never crashes
+
+
+
 # ── Fallback decision ─────────────────────────────────────────────────────
 def test_should_fallback_true_when_local_empty():
     assert should_fallback(0, _cfg()) is True