dao-ai 0.1.18__py3-none-any.whl → 0.1.19__py3-none-any.whl

dao_ai/genie/cache/lru.py

@@ -124,9 +124,7 @@ class LRUCacheService(GenieServiceBase):
         if self._cache:
             oldest_key: str = next(iter(self._cache))
             del self._cache[oldest_key]
-            logger.trace(
-                "Evicted cache entry", layer=self.name, key_prefix=oldest_key[:50]
-            )
+            logger.trace("Evicted cache entry", layer=self.name, key=oldest_key[:50])
 
     def _get(self, key: str) -> SQLCacheEntry | None:
         """Get from cache, returning None if not found or expired."""
@@ -137,7 +135,7 @@ class LRUCacheService(GenieServiceBase):
 
         if self._is_expired(entry):
             del self._cache[key]
-            logger.trace("Expired cache entry", layer=self.name, key_prefix=key[:50])
+            logger.trace("Expired cache entry", layer=self.name, key=key[:50])
             return None
 
         self._cache.move_to_end(key)
@@ -157,11 +155,11 @@ class LRUCacheService(GenieServiceBase):
             conversation_id=response.conversation_id,
             created_at=datetime.now(),
         )
-        logger.info(
+        logger.debug(
             "Stored cache entry",
             layer=self.name,
-            key_prefix=key[:50],
-            sql_prefix=response.query[:50] if response.query else None,
+            key=key[:50],
+            sql=response.query[:50] if response.query else None,
             cache_size=len(self._cache),
             capacity=self.capacity,
         )
@@ -180,7 +178,7 @@ class LRUCacheService(GenieServiceBase):
         w: WorkspaceClient = self.warehouse.workspace_client
         warehouse_id: str = str(self.warehouse.warehouse_id)
 
-        logger.trace("Executing cached SQL", layer=self.name, sql_prefix=sql[:100])
+        logger.trace("Executing cached SQL", layer=self.name, sql=sql[:100])
 
         statement_response: StatementResponse = w.statement_execution.execute_statement(
             statement=sql,
@@ -258,13 +256,17 @@ class LRUCacheService(GenieServiceBase):
             cached: SQLCacheEntry | None = self._get(key)
 
         if cached is not None:
+            cache_age_seconds = (datetime.now() - cached.created_at).total_seconds()
             logger.info(
                 "Cache HIT",
                 layer=self.name,
-                question_prefix=question[:50],
+                question=question[:80],
                 conversation_id=conversation_id,
+                cached_sql=cached.query[:80] if cached.query else None,
+                cache_age_seconds=round(cache_age_seconds, 1),
                 cache_size=self.size,
                 capacity=self.capacity,
+                ttl_seconds=self.parameters.time_to_live_seconds,
             )
 
             # Re-execute the cached SQL to get fresh data
@@ -286,17 +288,19 @@ class LRUCacheService(GenieServiceBase):
         logger.info(
             "Cache MISS",
             layer=self.name,
-            question_prefix=question[:50],
+            question=question[:80],
             conversation_id=conversation_id,
             cache_size=self.size,
             capacity=self.capacity,
+            ttl_seconds=self.parameters.time_to_live_seconds,
             delegating_to=type(self.impl).__name__,
         )
 
         result: CacheResult = self.impl.ask_question(question, conversation_id)
         with self._lock:
             self._put(key, result.response)
-        return CacheResult(response=result.response, cache_hit=False, served_by=None)
+        # Propagate the inner cache's result - if it was a hit there, preserve that info
+        return result
 
     @property
     def space_id(self) -> str:

dao_ai/genie/cache/semantic.py

@@ -497,6 +497,7 @@ class SemanticCacheService(GenieServiceBase):
         conversation_context: str,
         question_embedding: list[float],
         context_embedding: list[float],
+        conversation_id: str | None = None,
     ) -> tuple[SQLCacheEntry, float] | None:
         """
         Find a semantically similar cached entry using dual embedding matching.
@@ -509,6 +510,7 @@ class SemanticCacheService(GenieServiceBase):
             conversation_context: The conversation context string
             question_embedding: The embedding vector of just the question
             context_embedding: The embedding vector of the conversation context
+            conversation_id: Optional conversation ID (for logging)
 
         Returns:
             Tuple of (SQLCacheEntry, combined_similarity_score) if found, None otherwise
@@ -576,8 +578,9 @@ class SemanticCacheService(GenieServiceBase):
                     logger.info(
                         "Cache MISS (no entries)",
                         layer=self.name,
-                        question_prefix=question[:50],
+                        question=question[:50],
                         space=self.space_id,
+                        delegating_to=type(self.impl).__name__,
                     )
                     return None
 
@@ -602,8 +605,8 @@ class SemanticCacheService(GenieServiceBase):
                     context_sim=f"{context_similarity:.4f}",
                     combined_sim=f"{combined_similarity:.4f}",
                     is_valid=is_valid,
-                    cached_question_prefix=cached_question[:50],
-                    cached_context_prefix=cached_context[:80],
+                    cached_question=cached_question[:50],
+                    cached_context=cached_context[:80],
                 )
 
                 # Check BOTH similarity thresholds (dual embedding precision check)
@@ -613,6 +616,7 @@ class SemanticCacheService(GenieServiceBase):
                         layer=self.name,
                         question_sim=f"{question_similarity:.4f}",
                         threshold=self.parameters.similarity_threshold,
+                        delegating_to=type(self.impl).__name__,
                     )
                     return None
 
@@ -622,6 +626,7 @@ class SemanticCacheService(GenieServiceBase):
                         layer=self.name,
                         context_sim=f"{context_similarity:.4f}",
                         threshold=self.parameters.context_similarity_threshold,
+                        delegating_to=type(self.impl).__name__,
                     )
                     return None
 
@@ -635,17 +640,32 @@ class SemanticCacheService(GenieServiceBase):
                         layer=self.name,
                         combined_sim=f"{combined_similarity:.4f}",
                         ttl_seconds=ttl_seconds,
-                        cached_question_prefix=cached_question[:50],
+                        cached_question=cached_question[:50],
+                        delegating_to=type(self.impl).__name__,
                     )
                     return None
 
+                from datetime import datetime as dt
+
+                cache_age_seconds = (
+                    (dt.now(created_at.tzinfo) - created_at).total_seconds()
+                    if created_at
+                    else None
+                )
                 logger.info(
                     "Cache HIT",
                     layer=self.name,
-                    question_sim=f"{question_similarity:.4f}",
-                    context_sim=f"{context_similarity:.4f}",
-                    combined_sim=f"{combined_similarity:.4f}",
-                    cached_question_prefix=cached_question[:50],
+                    question=question[:80],
+                    conversation_id=conversation_id,
+                    matched_question=cached_question[:80],
+                    cache_age_seconds=round(cache_age_seconds, 1)
+                    if cache_age_seconds
+                    else None,
+                    question_similarity=f"{question_similarity:.4f}",
+                    context_similarity=f"{context_similarity:.4f}",
+                    combined_similarity=f"{combined_similarity:.4f}",
+                    cached_sql=sql_query[:80] if sql_query else None,
+                    ttl_seconds=self.parameters.time_to_live_seconds,
                 )
 
                 entry = SQLCacheEntry(
@@ -696,12 +716,12 @@ class SemanticCacheService(GenieServiceBase):
                         response.conversation_id,
                     ),
                 )
-                logger.info(
+                logger.debug(
                     "Stored cache entry",
                     layer=self.name,
-                    question_prefix=question[:50],
-                    context_prefix=conversation_context[:80],
-                    sql_prefix=response.query[:50] if response.query else None,
+                    question=question[:50],
+                    context=conversation_context[:80],
+                    sql=response.query[:50] if response.query else None,
                     space=self.space_id,
                     table=self.table_name,
                 )
@@ -796,7 +816,11 @@ class SemanticCacheService(GenieServiceBase):
 
         # Check cache using dual embedding similarity
         cache_result: tuple[SQLCacheEntry, float] | None = self._find_similar(
-            question, conversation_context, question_embedding, context_embedding
+            question,
+            conversation_context,
+            question_embedding,
+            context_embedding,
+            conversation_id,
         )
 
         if cache_result is not None:
@@ -805,7 +829,8 @@ class SemanticCacheService(GenieServiceBase):
                 "Semantic cache hit",
                 layer=self.name,
                 combined_similarity=f"{combined_similarity:.3f}",
-                question_prefix=question[:50],
+                question=question[:50],
+                conversation_id=conversation_id,
             )
 
             # Re-execute the cached SQL to get fresh data
@@ -825,16 +850,25 @@ class SemanticCacheService(GenieServiceBase):
             return CacheResult(response=response, cache_hit=True, served_by=self.name)
 
         # Cache miss - delegate to wrapped service
-        logger.trace("Cache miss", layer=self.name, question_prefix=question[:50])
+        logger.info(
+            "Cache MISS",
+            layer=self.name,
+            question=question[:80],
+            conversation_id=conversation_id,
+            space_id=self.space_id,
+            similarity_threshold=self.similarity_threshold,
+            delegating_to=type(self.impl).__name__,
+        )
 
         result: CacheResult = self.impl.ask_question(question, conversation_id)
 
         # Store in cache if we got a SQL query
         if result.response.query:
-            logger.info(
+            logger.debug(
                 "Storing new cache entry",
                 layer=self.name,
-                question_prefix=question[:50],
+                question=question[:50],
+                conversation_id=conversation_id,
                 space=self.space_id,
             )
             self._store_entry(
@@ -848,7 +882,7 @@ class SemanticCacheService(GenieServiceBase):
             logger.warning(
                 "Not caching: response has no SQL query",
                 layer=self.name,
-                question_prefix=question[:50],
+                question=question[:50],
             )
 
         return CacheResult(response=result.response, cache_hit=False, served_by=None)

dao_ai/tools/genie.py

@@ -25,13 +25,19 @@ from pydantic import BaseModel
 from dao_ai.config import (
     AnyVariable,
     CompositeVariableModel,
+    GenieInMemorySemanticCacheParametersModel,
     GenieLRUCacheParametersModel,
     GenieRoomModel,
     GenieSemanticCacheParametersModel,
     value_of,
 )
 from dao_ai.genie import GenieService, GenieServiceBase
-from dao_ai.genie.cache import CacheResult, LRUCacheService, SemanticCacheService
+from dao_ai.genie.cache import (
+    CacheResult,
+    InMemorySemanticCacheService,
+    LRUCacheService,
+    SemanticCacheService,
+)
 from dao_ai.state import AgentState, Context, SessionState
 
 
@@ -67,6 +73,9 @@ def create_genie_tool(
     semantic_cache_parameters: GenieSemanticCacheParametersModel
     | dict[str, Any]
     | None = None,
+    in_memory_semantic_cache_parameters: GenieInMemorySemanticCacheParametersModel
+    | dict[str, Any]
+    | None = None,
 ) -> Callable[..., Command]:
     """
     Create a tool for interacting with Databricks Genie for natural language queries to databases.
@@ -84,7 +93,9 @@ def create_genie_tool(
         truncate_results: Whether to truncate large query results to fit token limits
         lru_cache_parameters: Optional LRU cache configuration for SQL query caching
         semantic_cache_parameters: Optional semantic cache configuration using pg_vector
-            for similarity-based query matching
+            for similarity-based query matching (requires PostgreSQL/Lakebase)
+        in_memory_semantic_cache_parameters: Optional in-memory semantic cache configuration
+            for similarity-based query matching (no database required)
 
     Returns:
         A LangGraph tool that processes natural language queries through Genie
@@ -97,6 +108,7 @@ def create_genie_tool(
         name=name,
         has_lru_cache=lru_cache_parameters is not None,
         has_semantic_cache=semantic_cache_parameters is not None,
+        has_in_memory_semantic_cache=in_memory_semantic_cache_parameters is not None,
     )
 
     if isinstance(genie_room, dict):
@@ -110,6 +122,11 @@ def create_genie_tool(
             **semantic_cache_parameters
         )
 
+    if isinstance(in_memory_semantic_cache_parameters, dict):
+        in_memory_semantic_cache_parameters = GenieInMemorySemanticCacheParametersModel(
+            **in_memory_semantic_cache_parameters
+        )
+
     space_id: AnyVariable = genie_room.space_id or os.environ.get(
         "DATABRICKS_GENIE_SPACE_ID"
     )
@@ -165,7 +182,7 @@ GenieResponse: A response object containing the conversation ID and result from
 
         genie_service: GenieServiceBase = GenieService(genie)
 
-        # Wrap with semantic cache first (checked second due to decorator pattern)
+        # Wrap with semantic cache first (checked second/third due to decorator pattern)
         if semantic_cache_parameters is not None:
             genie_service = SemanticCacheService(
                 impl=genie_service,
@@ -173,6 +190,14 @@ GenieResponse: A response object containing the conversation ID and result from
                 workspace_client=workspace_client,
             ).initialize()
 
+        # Wrap with in-memory semantic cache (alternative to PostgreSQL semantic cache)
+        if in_memory_semantic_cache_parameters is not None:
+            genie_service = InMemorySemanticCacheService(
+                impl=genie_service,
+                parameters=in_memory_semantic_cache_parameters,
+                workspace_client=workspace_client,
+            ).initialize()
+
         # Wrap with LRU cache last (checked first - fast O(1) exact match)
         if lru_cache_parameters is not None:
             genie_service = LRUCacheService(

{dao_ai-0.1.18.dist-info → dao_ai-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.1.18
+Version: 0.1.19
 Summary: DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML.
 Project-URL: Homepage, https://github.com/natefleming/dao-ai
 Project-URL: Documentation, https://natefleming.github.io/dao-ai
@@ -409,7 +409,8 @@ The `config/examples/` directory contains ready-to-use configurations organized
 
 - `01_getting_started/minimal.yaml` - Simplest possible agent
 - `02_tools/vector_search_with_reranking.yaml` - RAG with improved accuracy
-- `04_genie/genie_semantic_cache.yaml` - NL-to-SQL with two-tier caching
+- `04_genie/genie_semantic_cache.yaml` - NL-to-SQL with PostgreSQL semantic caching
+- `04_genie/genie_in_memory_semantic_cache.yaml` - NL-to-SQL with in-memory semantic caching (no database)
 - `05_memory/conversation_summarization.yaml` - Long conversation handling
 - `06_on_behalf_of_user/obo_basic.yaml` - User-level access control
 - `07_human_in_the_loop/human_in_the_loop.yaml` - Approval workflows

{dao_ai-0.1.18.dist-info → dao_ai-0.1.19.dist-info}/RECORD

@@ -1,7 +1,7 @@
 dao_ai/__init__.py,sha256=18P98ExEgUaJ1Byw440Ct1ty59v6nxyWtc5S6Uq2m9Q,1062
 dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
 dao_ai/cli.py,sha256=Mcw03hemsT4O63lAH6mqTaPZjx0Q01YTgj5CN0thODI,52121
-dao_ai/config.py,sha256=lPWOCTL8NxoARkI8MRZlDJ2HiCAXgBB-SAyqCQQUVC8,145474
+dao_ai/config.py,sha256=CseNaB42FRKFz0NnfoCKmFROwVItwAHNAiipQqdwZbA,150445
 dao_ai/evaluation.py,sha256=4dveWDwFnUxaybswr0gag3ydZ5RGVCTRaiE3eKLClD4,18161
 dao_ai/graph.py,sha256=1-uQlo7iXZQTT3uU8aYu0N5rnhw5_g_2YLwVsAs6M-U,1119
 dao_ai/logging.py,sha256=lYy4BmucCHvwW7aI3YQkQXKJtMvtTnPDu9Hnd7_O4oc,1556
@@ -20,11 +20,12 @@ dao_ai/apps/resources.py,sha256=5l6UxfMq6uspOql-HNDyUikfqRAa9eH_TiJHrGgMb6s,4002
 dao_ai/apps/server.py,sha256=neWbVnC2z9f-tJZBnho70FytNDEVOdOM1YngoGc5KHI,1264
 dao_ai/genie/__init__.py,sha256=vdEyGhrt6L8GlK75SyYvTnl8QpHKDCJC5hJKLg4DesQ,1063
 dao_ai/genie/core.py,sha256=HPKbocvhnnw_PkQwfoq5bpgQmL9lZyyS6_goTJL8yiY,1073
-dao_ai/genie/cache/__init__.py,sha256=JfgCJl1NYQ1aZvZ4kly4T6uQK6ZCJ6PX_htuq7nJF50,1203
+dao_ai/genie/cache/__init__.py,sha256=ssLDdBgPFeiCcvHgd1cujomUu2R0COHCmBpPGDMU17w,1318
 dao_ai/genie/cache/base.py,sha256=_MhHqYrHejVGrJjSLX26TdHwvQZb-HgiantRYSB8fJY,1961
-dao_ai/genie/cache/core.py,sha256=1hvV72kMJ5md78Am4cdAi6wpTC6vV7mn6Srpb8Pti_M,2544
-dao_ai/genie/cache/lru.py,sha256=E7zBqdLvuFj_hzZhjcoMyfacbtfTgkVRNuFqVYi2Ic4,11835
-dao_ai/genie/cache/semantic.py,sha256=P1TrlFLMmSgLPFeZYbQTSbsjNpgXmovgqxBO92zINFM,38075
+dao_ai/genie/cache/core.py,sha256=48sDY7dbrsmflb96OFEE8DYarNB6zyiFxZQG-qfhXD4,2537
+dao_ai/genie/cache/in_memory_semantic.py,sha256=1Q7dpqZUcnpxRkzwWp13G9u7-iV4DG2gcx2N7KbUJx0,32426
+dao_ai/genie/cache/lru.py,sha256=c8_qkJ6NkCz9Jnr3KuCgTZDBWvHeuGnWyjMNy-l510I,12130
+dao_ai/genie/cache/semantic.py,sha256=Fshc2qB1UGgLAO_1gwH7v_taEJw3838bppfrUI_x4o4,39411
 dao_ai/hooks/__init__.py,sha256=uA4DQdP9gDf4SyNjNx9mWPoI8UZOcTyFsCXV0NraFvQ,463
 dao_ai/hooks/core.py,sha256=yZAfRfB0MyMo--uwGr4STtVxxen5s4ZUrNTnR3a3qkA,1721
 dao_ai/memory/__init__.py,sha256=Us3wFehvug_h83m-UJ7OXdq2qZ0e9nHBQE7m5RwoAd8,559
@@ -63,7 +64,7 @@ dao_ai/tools/__init__.py,sha256=NfRpAKds_taHbx6gzLPWgtPXve-YpwzkoOAUflwxceM,1734
 dao_ai/tools/agent.py,sha256=plIWALywRjaDSnot13nYehBsrHRpBUpsVZakoGeajOE,1858
 dao_ai/tools/core.py,sha256=bRIN3BZhRQX8-Kpu3HPomliodyskCqjxynQmYbk6Vjs,3783
 dao_ai/tools/email.py,sha256=A3TsCoQgJR7UUWR0g45OPRGDpVoYwctFs1MOZMTt_d4,7389
-dao_ai/tools/genie.py,sha256=b0R51N5D58H1vpOCUCA88ALjLs58KSMn6nl80ap8_c0,11009
+dao_ai/tools/genie.py,sha256=Zq3k7sfz0Jy5cm-RM5uNaWR5Q2sq-syaTwcgmxCWXUs,12114
 dao_ai/tools/instructed_retriever.py,sha256=iEu7oH1Z9_-Id0SMaq-dAgCNigeRrJDDTSZTcOJLl6k,12990
 dao_ai/tools/instruction_reranker.py,sha256=_1kGwrXkJk4QR2p8n3lAaYkUVoidxCxV9wNCtoS0qco,6730
 dao_ai/tools/mcp.py,sha256=4uvag52OJPInUEnxFLwpE0JRugTrgHeWbkP5lzIx4lg,22620
@@ -77,8 +78,8 @@ dao_ai/tools/time.py,sha256=tufJniwivq29y0LIffbgeBTIDE6VgrLpmVf8Qr90qjw,9224
 dao_ai/tools/unity_catalog.py,sha256=oBlW6pH-Ne08g60QW9wVi_tyeVYDiecuNoxQbIIFmN8,16515
 dao_ai/tools/vector_search.py,sha256=34uhd58FKHzvcdgHHoACRdZAUJWTaUuPYiwIqBwvGqk,29061
 dao_ai/tools/verifier.py,sha256=ociBVsGkQNyhWS6F6G8x17V7zAQfSuTe4Xcd6Y-7lPE,4975
-dao_ai-0.1.18.dist-info/METADATA,sha256=_458v0KntzrWOU-pc8hs0YsRjfW0Oacgf91gqNloT5w,16836
-dao_ai-0.1.18.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-dao_ai-0.1.18.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
-dao_ai-0.1.18.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
-dao_ai-0.1.18.dist-info/RECORD,,
+dao_ai-0.1.19.dist-info/METADATA,sha256=KnF0S-dwcgBA2YPOWBoVQFhBk9mVW57XAQ0bV8rL3RY,16954
+dao_ai-0.1.19.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dao_ai-0.1.19.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.1.19.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.1.19.dist-info/RECORD,,