dao-ai 0.0.27__py3-none-any.whl → 0.0.29__py3-none-any.whl

dao_ai/agent_as_code.py

@@ -7,6 +7,9 @@ from mlflow.pyfunc import ResponsesAgent
 
 from dao_ai.config import AppConfig
 
+mlflow.set_registry_uri("databricks-uc")
+mlflow.set_tracking_uri("databricks")
+
 mlflow.langchain.autolog()
 
 model_config: ModelConfig = ModelConfig()

dao_ai/config.py

@@ -895,6 +895,55 @@ class SearchParametersModel(BaseModel):
     query_type: Optional[str] = "ANN"
 
 
+class RerankParametersModel(BaseModel):
+    """
+    Configuration for reranking retrieved documents using FlashRank.
+
+    FlashRank provides fast, local reranking without API calls using lightweight
+    cross-encoder models. Reranking improves retrieval quality by reordering results
+    based on semantic relevance to the query.
+
+    Typical workflow:
+    1. Retrieve more documents than needed (e.g., 50 via num_results)
+    2. Rerank all retrieved documents
+    3. Return top_n best matches (e.g., 5)
+
+    Example:
+        ```yaml
+        retriever:
+          search_parameters:
+            num_results: 50  # Retrieve more candidates
+          rerank:
+            model: ms-marco-MiniLM-L-12-v2
+            top_n: 5  # Return top 5 after reranking
+        ```
+
+    Available models (from fastest to most accurate):
+    - "ms-marco-TinyBERT-L-2-v2" (fastest, smallest)
+    - "ms-marco-MiniLM-L-6-v2"
+    - "ms-marco-MiniLM-L-12-v2" (default, good balance)
+    - "rank-T5-flan" (most accurate, slower)
+    """
+
+    model_config = ConfigDict(use_enum_values=True, extra="forbid")
+
+    model: str = Field(
+        default="ms-marco-MiniLM-L-12-v2",
+        description="FlashRank model name. Default provides good balance of speed and accuracy.",
+    )
+    top_n: Optional[int] = Field(
+        default=None,
+        description="Number of documents to return after reranking. If None, uses search_parameters.num_results.",
+    )
+    cache_dir: Optional[str] = Field(
+        default="/tmp/flashrank_cache",
+        description="Directory to cache downloaded model weights.",
+    )
+    columns: Optional[list[str]] = Field(
+        default_factory=list, description="Columns to rerank using DatabricksReranker"
+    )
+
+
 class RetrieverModel(BaseModel):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
     vector_store: VectorStoreModel
@@ -902,6 +951,10 @@ class RetrieverModel(BaseModel):
     search_parameters: SearchParametersModel = Field(
         default_factory=SearchParametersModel
     )
+    rerank: Optional[RerankParametersModel | bool] = Field(
+        default=None,
+        description="Optional reranking configuration. Set to true for defaults, or provide ReRankParametersModel for custom settings.",
+    )
 
     @model_validator(mode="after")
     def set_default_columns(self):
@@ -910,6 +963,13 @@ class RetrieverModel(BaseModel):
             self.columns = columns
         return self
 
+    @model_validator(mode="after")
+    def set_default_reranker(self):
+        """Convert bool to ReRankParametersModel with defaults."""
+        if isinstance(self.rerank, bool) and self.rerank:
+            self.rerank = RerankParametersModel()
+        return self
+
 
 class FunctionType(str, Enum):
     PYTHON = "python"

dao_ai/providers/databricks.py

@@ -219,6 +219,13 @@ class DatabricksProvider(ServiceProvider):
         logger.debug("Creating agent...")
         mlflow.set_registry_uri("databricks-uc")
 
+        # Set up experiment for proper tracking
+        experiment: Experiment = self.get_or_create_experiment(config)
+        mlflow.set_experiment(experiment_id=experiment.experiment_id)
+        logger.debug(
+            f"Using experiment: {experiment.name} (ID: {experiment.experiment_id})"
+        )
+
         llms: Sequence[LLMModel] = list(config.resources.llms.values())
         vector_indexes: Sequence[IndexModel] = list(
             config.resources.vector_stores.values()

dao_ai/tools/genie.py

@@ -1,6 +1,5 @@
 import bisect
 import json
-import logging
 import os
 import time
 from dataclasses import asdict, dataclass
@@ -184,7 +183,7 @@ class Genie:
                         conversation_id, result, query_str, description
                     )
                 elif state in ["RUNNING", "PENDING"]:
-                    logging.debug("Waiting for query result...")
+                    logger.debug("Waiting for query result...")
                     time.sleep(self.poll_interval)
                 else:
                     return GenieResponse(
@@ -250,7 +249,7 @@ class Genie:
                     )
                 # includes EXECUTING_QUERY, Genie can retry after this status
                 else:
-                    logging.debug(f"Waiting...: {resp['status']}")
+                    logger.debug(f"Waiting...: {resp['status']}")
                     time.sleep(self.poll_interval)
             return GenieResponse(
                 conversation_id,
@@ -299,9 +298,6 @@ def create_genie_tool(
     if isinstance(genie_room, dict):
         genie_room = GenieRoomModel(**genie_room)
 
-    space_id: AnyVariable = genie_room.space_id or os.environ.get(
-        "DATABRICKS_GENIE_SPACE_ID"
-    )
     space_id: AnyVariable = genie_room.space_id or os.environ.get(
         "DATABRICKS_GENIE_SPACE_ID"
     )

dao_ai/tools/vector_search.py

@@ -1,10 +1,21 @@
-from typing import Any, Optional, Sequence
+from typing import Annotated, Any, Callable, List, Optional, Sequence
 
 import mlflow
-from databricks_langchain.vector_search_retriever_tool import VectorSearchRetrieverTool
-from langchain_core.tools import BaseTool
+from databricks.vector_search.reranker import DatabricksReranker
+from databricks_ai_bridge.vector_search_retriever_tool import (
+    FilterItem,
+    VectorSearchRetrieverToolInput,
+)
+from databricks_langchain.vectorstores import DatabricksVectorSearch
+from flashrank import Ranker, RerankRequest
+from langchain_core.documents import Document
+from langchain_core.tools import InjectedToolCallId, tool
+from langgraph.prebuilt import InjectedState
+from loguru import logger
+from mlflow.entities import SpanType
 
 from dao_ai.config import (
+    RerankParametersModel,
     RetrieverModel,
     VectorStoreModel,
 )
@@ -14,13 +25,13 @@ def create_vector_search_tool(
     retriever: RetrieverModel | dict[str, Any],
     name: Optional[str] = None,
     description: Optional[str] = None,
-) -> BaseTool:
+) -> Callable:
     """
     Create a Vector Search tool for retrieving documents from a Databricks Vector Search index.
 
     This function creates a tool that enables semantic search over product information,
-    documentation, or other content. It also registers the retriever schema with MLflow
-    for proper integration with the model serving infrastructure.
+    documentation, or other content using the @tool decorator pattern. It supports optional
+    reranking of results using FlashRank for improved relevance.
 
     Args:
         retriever: Configuration details for the vector search retriever, including:
@@ -32,32 +43,69 @@ def create_vector_search_tool(
             - vector_store: Dictionary with 'endpoint_name' and 'index' for vector search
             - columns: List of columns to retrieve from the vector store
             - search_parameters: Additional parameters for customizing the search behavior
+            - rerank: Optional rerank configuration for result reranking
+        name: Optional custom name for the tool
+        description: Optional custom description for the tool
 
     Returns:
-        A BaseTool instance that can perform vector search operations
+        A LangChain tool that performs vector search with optional reranking
     """
 
     if isinstance(retriever, dict):
         retriever = RetrieverModel(**retriever)
 
-    vector_store: VectorStoreModel = retriever.vector_store
+    vector_store_config: VectorStoreModel = retriever.vector_store
+
+    # Index is required for vector search
+    if vector_store_config.index is None:
+        raise ValueError("vector_store.index is required for vector search")
 
-    index_name: str = vector_store.index.full_name
-    columns: Sequence[str] = retriever.columns
+    index_name: str = vector_store_config.index.full_name
+    columns: Sequence[str] = retriever.columns or []
     search_parameters: dict[str, Any] = retriever.search_parameters.model_dump()
-    primary_key: str = vector_store.primary_key
-    doc_uri: str = vector_store.doc_uri
-    text_column: str = vector_store.embedding_source_column
-
-    vector_search_tool: BaseTool = VectorSearchRetrieverTool(
-        name=name,
-        tool_name=name,
-        description=description,
-        tool_description=description,
+    primary_key: str = vector_store_config.primary_key or ""
+    doc_uri: str = vector_store_config.doc_uri or ""
+    text_column: str = vector_store_config.embedding_source_column
+
+    # Extract reranker configuration
+    reranker_config: Optional[RerankParametersModel] = retriever.rerank
+
+    # Initialize FlashRank ranker once if reranking is enabled
+    # This is expensive (loads model weights), so we do it once and reuse across invocations
+    ranker: Optional[Ranker] = None
+    if reranker_config:
+        logger.debug(
+            f"Creating vector search tool with reranking: '{name}' "
+            f"(model: {reranker_config.model}, top_n: {reranker_config.top_n or 'auto'})"
+        )
+        try:
+            ranker = Ranker(
+                model_name=reranker_config.model, cache_dir=reranker_config.cache_dir
+            )
+            logger.info(
+                f"FlashRank ranker initialized successfully (model: {reranker_config.model})"
+            )
+        except Exception as e:
+            logger.warning(
+                f"Failed to initialize FlashRank ranker during tool creation: {e}. "
+                "Reranking will be disabled for this tool."
+            )
+            # Set reranker_config to None so we don't attempt reranking
+            reranker_config = None
+    else:
+        logger.debug(
+            f"Creating vector search tool without reranking: '{name}' (standard similarity search only)"
+        )
+
+    # Initialize the vector store
+    # Note: text_column is only required for self-managed embeddings
+    # For Databricks-managed embeddings, it's automatically determined from the index
+    vector_store: DatabricksVectorSearch = DatabricksVectorSearch(
         index_name=index_name,
+        text_column=None,  # Let DatabricksVectorSearch determine this from the index
         columns=columns,
-        **search_parameters,
-        workspace_client=vector_store.workspace_client,
+        include_score=True,
+        workspace_client=vector_store_config.workspace_client,
     )
 
     # Register the retriever schema with MLflow for model serving integration
@@ -66,7 +114,169 @@ def create_vector_search_tool(
         primary_key=primary_key,
         text_column=text_column,
         doc_uri=doc_uri,
-        other_columns=columns,
+        other_columns=list(columns),
+    )
+
+    # Helper function to perform vector similarity search
+    @mlflow.trace(name="find_documents", span_type=SpanType.RETRIEVER)
+    def _find_documents(
+        query: str, filters: Optional[List[FilterItem]] = None
+    ) -> List[Document]:
+        """Perform vector similarity search."""
+        # Convert filters to dict format
+        filters_dict: dict[str, Any] = {}
+        if filters:
+            for item in filters:
+                item_dict = dict(item)
+                filters_dict[item_dict["key"]] = item_dict["value"]
+
+        # Merge with any configured filters
+        combined_filters: dict[str, Any] = {
+            **filters_dict,
+            **search_parameters.get("filters", {}),
+        }
+
+        # Perform similarity search
+        num_results: int = search_parameters.get("num_results", 10)
+        query_type: str = search_parameters.get("query_type", "ANN")
+
+        logger.debug(
+            f"Performing vector search: query='{query[:50]}...', k={num_results}, filters={combined_filters}"
+        )
+
+        # Build similarity search kwargs
+        search_kwargs = {
+            "query": query,
+            "k": num_results,
+            "filter": combined_filters if combined_filters else None,
+            "query_type": query_type,
+        }
+
+        # Add DatabricksReranker if configured with columns
+        if reranker_config and reranker_config.columns:
+            search_kwargs["reranker"] = DatabricksReranker(
+                columns_to_rerank=reranker_config.columns
+            )
+
+        documents: List[Document] = vector_store.similarity_search(**search_kwargs)
+
+        logger.debug(f"Retrieved {len(documents)} documents from vector search")
+        return documents
+
+    # Helper function to rerank documents
+    @mlflow.trace(name="rerank_documents", span_type=SpanType.RETRIEVER)
+    def _rerank_documents(query: str, documents: List[Document]) -> List[Document]:
+        """Rerank documents using FlashRank.
+
+        Uses the ranker instance initialized at tool creation time (captured in closure).
+        This avoids expensive model loading on every invocation.
+        """
+        if not reranker_config or ranker is None:
+            return documents
+
+        logger.debug(
+            f"Starting reranking for {len(documents)} documents using model '{reranker_config.model}'"
+        )
+
+        # Prepare passages for reranking
+        passages: List[dict[str, Any]] = [
+            {"text": doc.page_content, "meta": doc.metadata} for doc in documents
+        ]
+
+        # Create reranking request
+        rerank_request: RerankRequest = RerankRequest(query=query, passages=passages)
+
+        # Perform reranking
+        logger.debug(f"Reranking {len(passages)} passages for query: '{query[:50]}...'")
+        results: List[dict[str, Any]] = ranker.rerank(rerank_request)
+
+        # Apply top_n filtering
+        top_n: int = reranker_config.top_n or len(documents)
+        results = results[:top_n]
+        logger.debug(
+            f"Reranking complete. Filtered to top {top_n} results from {len(documents)} candidates"
+        )
+
+        # Convert back to Document objects with reranking scores
+        reranked_docs: List[Document] = []
+        for result in results:
+            # Find original document by matching text
+            orig_doc: Optional[Document] = next(
+                (doc for doc in documents if doc.page_content == result["text"]), None
+            )
+            if orig_doc:
+                # Add reranking score to metadata
+                reranked_doc: Document = Document(
+                    page_content=orig_doc.page_content,
+                    metadata={
+                        **orig_doc.metadata,
+                        "reranker_score": result["score"],
+                    },
+                )
+                reranked_docs.append(reranked_doc)
+
+        logger.debug(
+            f"Reranked {len(documents)} documents → {len(reranked_docs)} results "
+            f"(model: {reranker_config.model}, top score: {reranked_docs[0].metadata.get('reranker_score', 0):.4f})"
+            if reranked_docs
+            else f"Reranking completed with {len(reranked_docs)} results"
+        )
+
+        return reranked_docs
+
+    # Create the main vector search tool using @tool decorator
+    # Note: args_schema provides descriptions for query and filters,
+    # so Annotated is only needed for injected LangGraph parameters
+    @tool(
+        name_or_callable=name or index_name,
+        description=description or "Search for documents using vector similarity",
+        args_schema=VectorSearchRetrieverToolInput,
     )
+    def vector_search_tool(
+        query: str,
+        filters: Optional[List[FilterItem]] = None,
+        state: Annotated[dict, InjectedState] = None,
+        tool_call_id: Annotated[str, InjectedToolCallId] = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search for documents using vector similarity with optional reranking.
+
+        This tool performs a two-stage retrieval process:
+        1. Vector similarity search to find candidate documents
+        2. Optional reranking using cross-encoder model for improved relevance
+
+        Both stages are traced in MLflow for observability.
+
+        Returns:
+            Command with ToolMessage containing the retrieved documents
+        """
+        logger.debug(
+            f"Vector search tool called: query='{query[:50]}...', reranking={reranker_config is not None}"
+        )
+
+        # Step 1: Perform vector similarity search
+        documents: List[Document] = _find_documents(query, filters)
+
+        # Step 2: If reranking is enabled, rerank the documents
+        if reranker_config:
+            logger.debug(
+                f"Reranking enabled (model: '{reranker_config.model}', top_n: {reranker_config.top_n or 'all'})"
+            )
+            documents = _rerank_documents(query, documents)
+            logger.debug(f"Returning {len(documents)} reranked documents")
+        else:
+            logger.debug("Reranking disabled, returning original vector search results")
+
+        # Return Command with ToolMessage containing the documents
+        # Serialize documents to dicts for proper ToolMessage handling
+        serialized_docs: list[dict[str, Any]] = [
+            {
+                "page_content": doc.page_content,
+                "metadata": doc.metadata,
+            }
+            for doc in documents
+        ]
+
+        return serialized_docs
 
     return vector_search_tool

dao_ai/utils.py

@@ -100,6 +100,7 @@ def get_installed_packages() -> dict[str, str]:
         f"databricks-mcp=={version('databricks-mcp')}",
         f"databricks-sdk[openai]=={version('databricks-sdk')}",
         f"duckduckgo-search=={version('duckduckgo-search')}",
+        f"flashrank=={version('flashrank')}",
         f"langchain=={version('langchain')}",
         f"langchain-mcp-adapters=={version('langchain-mcp-adapters')}",
         f"langchain-openai=={version('langchain-openai')}",

{dao_ai-0.0.27.dist-info → dao_ai-0.0.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.0.27
+Version: 0.0.29
 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
@@ -18,17 +18,19 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
-Requires-Python: >=3.12
+Requires-Python: >=3.11
 Requires-Dist: databricks-agents>=1.7.0
 Requires-Dist: databricks-langchain>=0.8.1
 Requires-Dist: databricks-mcp>=0.3.0
 Requires-Dist: databricks-sdk[openai]>=0.67.0
 Requires-Dist: duckduckgo-search>=8.0.2
+Requires-Dist: flashrank>=0.2.8
 Requires-Dist: gepa>=0.0.17
 Requires-Dist: grandalf>=0.8
 Requires-Dist: langchain-mcp-adapters>=0.1.10
@@ -56,7 +58,7 @@ Requires-Dist: tomli>=2.3.0
 Requires-Dist: unitycatalog-ai[databricks]>=0.3.0
 Provides-Extra: databricks
 Requires-Dist: databricks-connect>=15.0.0; extra == 'databricks'
-Requires-Dist: databricks-vectorsearch>=0.56; extra == 'databricks'
+Requires-Dist: databricks-vectorsearch>=0.63; extra == 'databricks'
 Requires-Dist: pyspark>=3.5.0; extra == 'databricks'
 Provides-Extra: dev
 Requires-Dist: mypy>=1.0.0; extra == 'dev'

{dao_ai-0.0.27.dist-info → dao_ai-0.0.29.dist-info}/RECORD

@@ -1,9 +1,9 @@
 dao_ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dao_ai/agent_as_code.py,sha256=kPSeDz2-1jRaed1TMs4LA3VECoyqe9_Ed2beRLB9gXQ,472
+dao_ai/agent_as_code.py,sha256=sviZQV7ZPxE5zkZ9jAbfegI681nra5i8yYxw05e3X7U,552
 dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
 dao_ai/chat_models.py,sha256=uhwwOTeLyHWqoTTgHrs4n5iSyTwe4EQcLKnh3jRxPWI,8626
 dao_ai/cli.py,sha256=gq-nsapWxDA1M6Jua3vajBvIwf0Oa6YLcB58lEtMKUo,22503
-dao_ai/config.py,sha256=DRFj_1W5sfGH5f2tGQaeC733pTIDTqvbyAt14v8FQYs,70296
+dao_ai/config.py,sha256=qqBdYV-ElIMYDKzY4lBejyJ6ysmwnBkqyGMWRBwWGVo,72507
 dao_ai/graph.py,sha256=9kjJx0oFZKq5J9-Kpri4-0VCJILHYdYyhqQnj0_noxQ,8913
 dao_ai/guardrails.py,sha256=4TKArDONRy8RwHzOT1plZ1rhy3x9GF_aeGpPCRl6wYA,4016
 dao_ai/messages.py,sha256=xl_3-WcFqZKCFCiov8sZOPljTdM3gX3fCHhxq-xFg2U,7005
@@ -12,7 +12,7 @@ dao_ai/nodes.py,sha256=iQ_5vL6mt1UcRnhwgz-l1D8Ww4CMQrSMVnP_Lu7fFjU,8781
 dao_ai/prompts.py,sha256=7Hcstmv514P0s9s-TVoIlbkDV2XXOphGCW6gcPeyUYE,1628
 dao_ai/state.py,sha256=_lF9krAYYjvFDMUwZzVKOn0ZnXKcOrbjWKdre0C5B54,1137
 dao_ai/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dao_ai/utils.py,sha256=xfBo9-6k9ss1c7QlC26QDCwS2sY3mgUYgWzTTV6443M,6662
+dao_ai/utils.py,sha256=4FV9y0EVn0tmxfkn4EdUAkOewoAF_T0pHDAHe6hJx-M,6708
 dao_ai/vector_search.py,sha256=jlaFS_iizJ55wblgzZmswMM3UOL-qOp2BGJc0JqXYSg,2839
 dao_ai/hooks/__init__.py,sha256=LlHGIuiZt6vGW8K5AQo1XJEkBP5vDVtMhq0IdjcLrD4,417
 dao_ai/hooks/core.py,sha256=ZShHctUSoauhBgdf1cecy9-D7J6-sGn-pKjuRMumW5U,6663
@@ -22,20 +22,20 @@ dao_ai/memory/core.py,sha256=DnEjQO3S7hXr3CDDd7C2eE7fQUmcCS_8q9BXEgjPH3U,4271
 dao_ai/memory/postgres.py,sha256=vvI3osjx1EoU5GBA6SCUstTBKillcmLl12hVgDMjfJY,15346
 dao_ai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dao_ai/providers/base.py,sha256=-fjKypCOk28h6vioPfMj9YZSw_3Kcbi2nMuAyY7vX9k,1383
-dao_ai/providers/databricks.py,sha256=W_lXSMbPTULMAx-KW7zBJfP7LtkcPGRnEfGcSYuu708,65824
+dao_ai/providers/databricks.py,sha256=QwQS0Mad6nZNOB2k_h3lTrwLRzI5ApLQjxOz4CpvhlI,66130
 dao_ai/tools/__init__.py,sha256=G5-5Yi6zpQOH53b5IzLdtsC6g0Ep6leI5GxgxOmgw7Q,1203
 dao_ai/tools/agent.py,sha256=WbQnyziiT12TLMrA7xK0VuOU029tdmUBXbUl-R1VZ0Q,1886
 dao_ai/tools/core.py,sha256=Kei33S8vrmvPOAyrFNekaWmV2jqZ-IPS1QDSvU7RZF0,1984
-dao_ai/tools/genie.py,sha256=8HSOCzSg6PlBzBYXMmNfUnl-LO03p3Ki3fxLPm_dhPg,15051
+dao_ai/tools/genie.py,sha256=wt6pVykukNStOUlrTyjWUj-S2Wb47IuMr5HztEcN3Wg,14925
 dao_ai/tools/human_in_the_loop.py,sha256=yk35MO9eNETnYFH-sqlgR-G24TrEgXpJlnZUustsLkI,3681
 dao_ai/tools/mcp.py,sha256=5aQoRtx2z4xm6zgRslc78rSfEQe-mfhqov2NsiybYfc,8416
 dao_ai/tools/python.py,sha256=XcQiTMshZyLUTVR5peB3vqsoUoAAy8gol9_pcrhddfI,1831
 dao_ai/tools/slack.py,sha256=SCvyVcD9Pv_XXPXePE_fSU1Pd8VLTEkKDLvoGTZWy2Y,4775
 dao_ai/tools/time.py,sha256=Y-23qdnNHzwjvnfkWvYsE7PoWS1hfeKy44tA7sCnNac,8759
 dao_ai/tools/unity_catalog.py,sha256=uX_h52BuBAr4c9UeqSMI7DNz3BPRLeai5tBVW4sJqRI,13113
-dao_ai/tools/vector_search.py,sha256=EDYQs51zIPaAP0ma1D81wJT77GQ-v-cjb2XrFVWfWdg,2621
-dao_ai-0.0.27.dist-info/METADATA,sha256=iKbZTl0tFi0S2XUir9uIGh6WyOTvM9yH-4FHCHOzsuE,42695
-dao_ai-0.0.27.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dao_ai-0.0.27.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
-dao_ai-0.0.27.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
-dao_ai-0.0.27.dist-info/RECORD,,
+dao_ai/tools/vector_search.py,sha256=h6yCgEtOA3h-anJG0hGB3VvcmC3Os7_qnhz8xxRjv1E,11346
+dao_ai-0.0.29.dist-info/METADATA,sha256=ze54m_V26Rh451YBjImiAAf_ZgZ3j41XscMLMoSrHGc,42778
+dao_ai-0.0.29.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dao_ai-0.0.29.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.0.29.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.0.29.dist-info/RECORD,,

{dao_ai-0.0.27.dist-info → dao_ai-0.0.29.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any