schema-search 0.1.10__py3-none-any.whl

schema_search/search/factory.py

@@ -0,0 +1,61 @@
+from typing import Callable, Dict, Optional
+
+from schema_search.search.semantic import SemanticSearchStrategy
+from schema_search.search.fuzzy import FuzzySearchStrategy
+from schema_search.search.bm25 import BM25SearchStrategy
+from schema_search.search.hybrid import HybridSearchStrategy
+from schema_search.search.base import BaseSearchStrategy
+from schema_search.embedding_cache import BaseEmbeddingCache
+from schema_search.rankers.base import BaseRanker
+
+
+def create_search_strategy(
+    config: Dict,
+    get_embedding_cache: Callable[[], BaseEmbeddingCache],
+    get_bm25_cache: Callable,
+    get_reranker: Callable[[], Optional[BaseRanker]],
+    strategy_type: Optional[str],
+) -> BaseSearchStrategy:
+    search_config = config["search"]
+    strategy_type = strategy_type or search_config["strategy"]
+
+    initial_top_k = search_config["initial_top_k"]
+    rerank_top_k = search_config["rerank_top_k"]
+
+    reranker = get_reranker()
+
+    if strategy_type == "semantic":
+        return SemanticSearchStrategy(
+            embedding_cache=get_embedding_cache(),
+            initial_top_k=initial_top_k,
+            rerank_top_k=rerank_top_k,
+            reranker=reranker,
+        )
+
+    if strategy_type == "bm25":
+        return BM25SearchStrategy(
+            bm25_cache=get_bm25_cache(),
+            initial_top_k=initial_top_k,
+            rerank_top_k=rerank_top_k,
+            reranker=reranker,
+        )
+
+    if strategy_type == "fuzzy":
+        return FuzzySearchStrategy(
+            initial_top_k=initial_top_k,
+            rerank_top_k=rerank_top_k,
+            reranker=reranker,
+        )
+
+    if strategy_type == "hybrid":
+        semantic_weight = search_config["semantic_weight"]
+        return HybridSearchStrategy(
+            embedding_cache=get_embedding_cache(),
+            bm25_cache=get_bm25_cache(),
+            initial_top_k=initial_top_k,
+            rerank_top_k=rerank_top_k,
+            reranker=reranker,
+            semantic_weight=semantic_weight,
+        )
+
+    raise ValueError(f"Unknown search strategy: {strategy_type}")

schema_search/search/fuzzy.py

@@ -0,0 +1,56 @@
+from typing import Dict, List, Optional
+
+from rapidfuzz import fuzz
+
+from schema_search.search.base import BaseSearchStrategy
+from schema_search.types import TableSchema, SearchResultItem
+from schema_search.chunkers import Chunk
+from schema_search.graph_builder import GraphBuilder
+from schema_search.rankers.base import BaseRanker
+
+
+class FuzzySearchStrategy(BaseSearchStrategy):
+    def __init__(
+        self, initial_top_k: int, rerank_top_k: int, reranker: Optional[BaseRanker]
+    ):
+        super().__init__(reranker, initial_top_k, rerank_top_k)
+
+    def _initial_ranking(
+        self,
+        query: str,
+        schemas: Dict[str, TableSchema],
+        chunks: List[Chunk],
+        graph_builder: GraphBuilder,
+        hops: int,
+    ) -> List[SearchResultItem]:
+        scored_tables: List[tuple[str, float]] = []
+
+        for table_name, schema in schemas.items():
+            searchable_text = self._build_searchable_text(table_name, schema)
+            score = fuzz.ratio(query, searchable_text, score_cutoff=0) / 100.0
+            scored_tables.append((table_name, score))
+
+        scored_tables.sort(key=lambda x: x[1], reverse=True)
+
+        results: List[SearchResultItem] = []
+        for table_name, score in scored_tables[: self.initial_top_k]:
+            result = self._build_result_item(
+                table_name=table_name,
+                score=score,
+                schema=schemas[table_name],
+                matched_chunks=[],
+                graph_builder=graph_builder,
+                hops=hops,
+            )
+            results.append(result)
+
+        return results
+
+    def _build_searchable_text(self, table_name: str, schema: TableSchema) -> str:
+        parts = [table_name]
+
+        if schema["indices"]:
+            for idx in schema["indices"]:
+                parts.append(idx["name"])
+
+        return " ".join(parts)

schema_search/search/hybrid.py

@@ -0,0 +1,82 @@
+from typing import Dict, List, Optional, TYPE_CHECKING
+
+import numpy as np
+
+from schema_search.search.base import BaseSearchStrategy
+from schema_search.types import TableSchema, SearchResultItem
+from schema_search.chunkers import Chunk
+from schema_search.graph_builder import GraphBuilder
+from schema_search.embedding_cache import BaseEmbeddingCache
+from schema_search.rankers.base import BaseRanker
+
+if TYPE_CHECKING:
+    from schema_search.embedding_cache.bm25 import BM25Cache
+
+
+class HybridSearchStrategy(BaseSearchStrategy):
+    def __init__(
+        self,
+        embedding_cache: BaseEmbeddingCache,
+        bm25_cache: "BM25Cache",
+        initial_top_k: int,
+        rerank_top_k: int,
+        reranker: Optional[BaseRanker],
+        semantic_weight: float,
+    ):
+        super().__init__(reranker, initial_top_k, rerank_top_k)
+        assert 0 <= semantic_weight <= 1, "semantic_weight must be between 0 and 1"
+        self.embedding_cache = embedding_cache
+        self.bm25_cache = bm25_cache
+        self.semantic_weight = semantic_weight
+        self.bm25_weight = 1 - semantic_weight
+
+    def _initial_ranking(
+        self,
+        query: str,
+        schemas: Dict[str, TableSchema],
+        chunks: List[Chunk],
+        graph_builder: GraphBuilder,
+        hops: int,
+    ) -> List[SearchResultItem]:
+        query_embedding = self.embedding_cache.encode_query(query)
+        semantic_scores = self.embedding_cache.compute_similarities(query_embedding)
+
+        bm25_scores = self.bm25_cache.get_scores(query)
+
+        semantic_min = semantic_scores.min()
+        semantic_max = semantic_scores.max()
+        semantic_range = semantic_max - semantic_min
+        if semantic_range > 0:
+            semantic_scores_norm = (semantic_scores - semantic_min) / semantic_range
+        else:
+            semantic_scores_norm = np.zeros_like(semantic_scores)
+
+        bm25_min = bm25_scores.min()
+        bm25_max = bm25_scores.max()
+        bm25_range = bm25_max - bm25_min
+        if bm25_range > 0:
+            bm25_scores_norm = (bm25_scores - bm25_min) / bm25_range
+        else:
+            bm25_scores_norm = np.zeros_like(bm25_scores)
+
+        hybrid_scores = (
+            self.semantic_weight * semantic_scores_norm
+            + self.bm25_weight * bm25_scores_norm
+        )
+
+        top_indices = hybrid_scores.argsort()[::-1][: self.initial_top_k]
+
+        results: List[SearchResultItem] = []
+        for idx in top_indices:
+            chunk = chunks[idx]
+            result = self._build_result_item(
+                table_name=chunk.table_name,
+                score=float(hybrid_scores[idx]),
+                schema=schemas[chunk.table_name],
+                matched_chunks=[chunk.content],
+                graph_builder=graph_builder,
+                hops=hops,
+            )
+            results.append(result)
+
+        return results

schema_search/search/semantic.py

@@ -0,0 +1,49 @@
+from typing import Dict, List, Optional
+
+import numpy as np
+
+from schema_search.search.base import BaseSearchStrategy
+from schema_search.types import TableSchema, SearchResultItem
+from schema_search.chunkers import Chunk
+from schema_search.graph_builder import GraphBuilder
+from schema_search.embedding_cache import BaseEmbeddingCache
+from schema_search.rankers.base import BaseRanker
+
+
+class SemanticSearchStrategy(BaseSearchStrategy):
+    def __init__(
+        self,
+        embedding_cache: BaseEmbeddingCache,
+        initial_top_k: int,
+        rerank_top_k: int,
+        reranker: Optional[BaseRanker],
+    ):
+        super().__init__(reranker, initial_top_k, rerank_top_k)
+        self.embedding_cache = embedding_cache
+
+    def _initial_ranking(
+        self,
+        query: str,
+        schemas: Dict[str, TableSchema],
+        chunks: List[Chunk],
+        graph_builder: GraphBuilder,
+        hops: int,
+    ) -> List[SearchResultItem]:
+        query_embedding = self.embedding_cache.encode_query(query)
+        embedding_scores = self.embedding_cache.compute_similarities(query_embedding)
+        top_indices = embedding_scores.argsort()[::-1][: self.initial_top_k]
+
+        results: List[SearchResultItem] = []
+        for idx in top_indices:
+            chunk = chunks[idx]
+            result = self._build_result_item(
+                table_name=chunk.table_name,
+                score=float(embedding_scores[idx]),
+                schema=schemas[chunk.table_name],
+                matched_chunks=[chunk.content],
+                graph_builder=graph_builder,
+                hops=hops,
+            )
+            results.append(result)
+
+        return results

schema_search/types.py

@@ -0,0 +1,57 @@
+from typing import TypedDict, List, Literal, Optional
+
+
+SearchType = Literal["semantic", "fuzzy", "bm25", "hybrid"]
+
+
+class ColumnInfo(TypedDict):
+    name: str
+    type: str
+    nullable: bool
+    default: Optional[str]
+
+
+class ForeignKeyInfo(TypedDict):
+    constrained_columns: List[str]
+    referred_table: str
+    referred_columns: List[str]
+
+
+class IndexInfo(TypedDict):
+    name: str
+    columns: List[str]
+    unique: bool
+
+
+class ConstraintInfo(TypedDict):
+    name: Optional[str]
+    columns: List[str]
+
+
+class TableSchema(TypedDict):
+    name: str
+    primary_keys: List[str]
+    columns: Optional[List[ColumnInfo]]
+    foreign_keys: Optional[List[ForeignKeyInfo]]
+    indices: Optional[List[IndexInfo]]
+    unique_constraints: Optional[List[ConstraintInfo]]
+    check_constraints: Optional[List[ConstraintInfo]]
+
+
+class IndexResult(TypedDict):
+    tables: int
+    chunks: int
+    latency_sec: float
+
+
+class SearchResultItem(TypedDict):
+    table: str
+    score: float
+    schema: TableSchema
+    matched_chunks: List[str]
+    related_tables: List[str]
+
+
+class SearchResult(TypedDict):
+    results: List[SearchResultItem]
+    latency_sec: float

schema_search/utils/lazy_import.py

@@ -0,0 +1,26 @@
+from typing import Any
+from importlib import import_module
+
+
+def lazy_import_check(module_name: str, extra_name: str, feature: str) -> Any:
+    """
+    Lazily import a module and provide helpful error if missing.
+
+    Args:
+        module_name: Python module to import (e.g., "sentence_transformers")
+        extra_name: pip extra name (e.g., "semantic")
+        feature: User-facing feature description (e.g., "semantic search")
+
+    Returns:
+        Imported module
+
+    Raises:
+        ImportError: With installation instructions if module not found
+    """
+    try:
+        return import_module(module_name)
+    except ImportError as e:
+        raise ImportError(
+            f"'{module_name}' is required for {feature}. "
+            f"Install with: pip install schema-search[{extra_name}]"
+        ) from e

schema_search-0.1.10.dist-info/METADATA

@@ -0,0 +1,308 @@
+Metadata-Version: 2.4
+Name: schema-search
+Version: 0.1.10
+Summary: Natural language database schema search with graph-aware semantic retrieval
+Home-page: https://adibhasan.com/blog/schema-search/
+Author: Adib Hasan
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy>=1.4.0
+Requires-Dist: networkx>=2.8.0
+Requires-Dist: bm25s>=0.2.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: rapidfuzz>=3.0.0
+Provides-Extra: semantic
+Requires-Dist: sentence-transformers>=2.2.0; extra == "semantic"
+Provides-Extra: llm
+Requires-Dist: openai>=1.0.0; extra == "llm"
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=2.0.0; extra == "mcp"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: python-dotenv>=1.0.0; extra == "test"
+Requires-Dist: psutil>=5.9.0; extra == "test"
+Requires-Dist: datasets>=2.0.0; extra == "test"
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "postgres"
+Provides-Extra: mysql
+Requires-Dist: pymysql>=1.0.0; extra == "mysql"
+Provides-Extra: snowflake
+Requires-Dist: snowflake-sqlalchemy>=1.4.0; extra == "snowflake"
+Requires-Dist: snowflake-connector-python>=3.0.0; extra == "snowflake"
+Provides-Extra: bigquery
+Requires-Dist: sqlalchemy-bigquery>=1.6.0; extra == "bigquery"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Schema Search
+
+An MCP Server for Natural Language Search over RDBMS Schemas. Find exact tables you need, with all their relationships mapped out, in milliseconds. No vector database setup is required.
+
+## Why
+
+You have 200 tables in your database. Someone asks "where are user refunds stored?"
+
+You could:
+- Grep through SQL files for 20 minutes
+- Pass the full schema to an LLM and watch it struggle with 200 tables
+
+Or **build schematic embeddings of your tables, store in-memory, and query in natural language in an MCP server**.
+
+### Benefits
+- No vector database setup is required
+- Small memory footprint -- easily scales up to 1000 tables and 10,000+ columns.
+- Millisecond query latency
+
+## Install
+
+**Fast by default** - Base install uses only BM25/fuzzy search (no PyTorch):
+
+```bash
+# Minimal install (BM25 + fuzzy only, ~10MB)
+pip install "schema-search[postgres]"
+
+# With semantic/hybrid search support (~500MB with PyTorch)
+pip install "schema-search[postgres,semantic]"
+
+# With LLM chunking
+pip install "schema-search[postgres,semantic,llm]"
+
+# With MCP server
+pip install "schema-search[postgres,semantic,mcp]"
+
+# Other databases
+pip install "schema-search[mysql,semantic]"      # MySQL
+pip install "schema-search[snowflake,semantic]"  # Snowflake
+pip install "schema-search[bigquery,semantic]"   # BigQuery
+```
+
+**Extras:**
+- `[semantic]`: Enables semantic/hybrid search and CrossEncoder reranking (adds sentence-transformers)
+- `[llm]`: Enables LLM-based schema chunking (adds openai)
+- `[mcp]`: MCP server support (adds fastmcp)
+
+## Configuration
+
+Edit [`config.yml`](https://github.com/Neehan/schema-search/blob/main/config.yml):
+
+```yaml
+logging:
+  level: "WARNING"
+
+embedding:
+  location: "memory" # Options: "memory", "vectordb" (coming soon)
+  model: "multi-qa-MiniLM-L6-cos-v1"
+  metric: "cosine" # Options: "cosine", "euclidean", "manhattan", "dot"
+  batch_size: 32
+  show_progress: false
+  cache_dir: "/tmp/.schema_search_cache"
+
+chunking:
+  strategy: "raw" # Options: "raw", "llm"
+  max_tokens: 256
+  overlap_tokens: 50
+  model: "gpt-4o-mini"
+
+search:
+  # Search strategy: "semantic" (embeddings), "bm25" (BM25 lexical), "fuzzy" (fuzzy string matching), "hybrid" (semantic + bm25)
+  strategy: "bm25"
+  initial_top_k: 20
+  rerank_top_k: 5
+  semantic_weight: 0.67 # For hybrid search (bm25_weight = 1 - semantic_weight)
+  hops: 1 # Number of foreign key hops for graph expansion (0-2 recommended)
+
+reranker:
+  # CrossEncoder model for reranking. Set to null to disable reranking
+  model: null # "Alibaba-NLP/gte-reranker-modernbert-base"
+
+schema:
+  include_columns: true
+  include_indices: true
+  include_foreign_keys: true
+  include_constraints: true
+```
+
+
+## MCP Server
+
+Integrate with Claude Desktop or any MCP client.
+
+### Setup
+
+Add to your MCP config (e.g., `~/.cursor/mcp.json` or Claude Desktop config):
+
+**Using uv (Recommended):**
+```json
+{
+  "mcpServers": {
+    "schema-search": {
+      "command": "uvx",
+      "args": [
+        "schema-search[postgres,mcp]", 
+        "postgresql://user:pass@localhost/db", 
+        "optional/path/to/config.yml", 
+        "optional llm_api_key", 
+        "optional llm_base_url"
+      ]
+    }
+  }
+}
+```
+
+**Using pip:**
+```json
+{
+  "mcpServers": {
+    "schema-search": {
+      // conda: /Users/<username>/opt/miniconda3/envs/<your env>/bin/schema-search",
+      "command": "path/to/schema-search",
+      "args": [
+        "postgresql://user:pass@localhost/db", 
+        "optional/path/to/config.yml", 
+        "optional llm_api_key", 
+        "optional llm_base_url"
+      ]
+    }
+  }
+}
+```
+
+
+The LLM API key and base url are only required if you use LLM-generated schema summaries (`config.chunking.strategy = 'llm'`).
+
+### CLI Usage
+
+```bash
+schema-search "postgresql://user:pass@localhost/db" "optional/path/to/config.yml"
+```
+
+Optional args: `[config_path] [llm_api_key] [llm_base_url]`
+
+The server exposes `schema_search(query, hops, limit)` for natural language schema queries.
+
+## Python Use
+
+```python
+from sqlalchemy import create_engine
+from schema_search import SchemaSearch
+
+engine = create_engine("postgresql://user:pass@localhost/db")
+search = SchemaSearch(
+  engine=engine, 
+  config_path="optional/path/to/config.yml", # default: config.yml
+  llm_api_key="optional llm api key", 
+  llm_base_url="optional llm base url"
+  )
+
+search.index(force=False) # default is False
+results = search.search("where are user refunds stored?")
+
+for result in results['results']:
+    print(result['table'])           # "refund_transactions"
+    print(result['schema'])           # Full column info, types, constraints
+    print(result['related_tables'])   # ["users", "payments", "transactions"]
+
+# Override hops, limit, search strategy
+results = search.search("user_table", hops=1, limit=5, search_type="hybrid")
+
+```
+
+`SchemaSearch.index()` automatically detects schema changes and refreshes cached metadata, so you rarely need to force a reindex manually.
+
+## Search Strategies
+
+Schema Search supports four search strategies:
+
+- **bm25**: Lexical search using BM25 ranking algorithm (no ML dependencies)
+- **fuzzy**: String matching on table/column names using fuzzy matching (no ML dependencies)
+- **semantic**: Embedding-based similarity search using sentence transformers (requires `[semantic]`)
+- **hybrid**: Combines semantic and bm25 scores (default: 67% semantic, 33% bm25) (requires `[semantic]`)
+
+Each strategy performs its own initial ranking, then optionally applies CrossEncoder reranking if `reranker.model` is configured (requires `[semantic]`). Set `reranker.model` to `null` to disable reranking.
+
+## Performance Comparison
+We [benchmarked](/tests/test_spider_eval.py) on the Spider dataset (1,234 train queries across 18 databases) using the default `config.yml`.  
+
+**Memory:** The embedding model requires ~90 MB and the optional reranker adds ~155 MB. Actual process memory depends on your Python runtime.
+
+### Without Reranker (`reranker.model: null`)
+![Without Reranker](https://raw.githubusercontent.com/Neehan/schema-search/refs/heads/main/img/spider_benchmark_without_reranker.png)
+- **Indexing:** 0.22s ± 0.08s per database (18 total).
+- **Accuracy:** Hybrid leads with Recall@1 62% / MRR 0.93; Semantic follows at Recall@1 58% / MRR 0.89.
+- **Latency:** BM25 and Fuzzy return in ~5ms; Semantic spends ~15ms; Hybrid (semantic + fuzzy) averages 52ms.
+- **Fuzzy baseline:** Recall@1 22%, highlighting the need for semantic signals on natural-language queries.
+
+### With Reranker (`Alibaba-NLP/gte-reranker-modernbert-base`)
+![With Reranker](https://raw.githubusercontent.com/Neehan/schema-search/refs/heads/main/img/spider_benchmark_with_reranker.png)
+- **Indexing:** 0.25s ± 0.05s per database (same 18 DBs).
+- **Accuracy:** All strategies converge around Recall@1 62% and MRR ≈ 0.92; Fuzzy jumps from 51% → 92% MRR.
+- **Latency trade-off:** Extra CrossEncoder pass lifts per-query latency to ~0.18–0.29s depending on strategy.
+- **Recommendation:** Enable the reranker when accuracy matters most; disable it for ultra-low-latency lookups.
+
+
+You can override the search strategy, hops, and limit at query time:
+
+```python
+# Use fuzzy search instead of default
+results = search.search("user_table", search_type="fuzzy")
+
+# Use BM25 for keyword-based search
+results = search.search("transactions payments", search_type="bm25")
+
+# Use hybrid for best of both worlds
+results = search.search("where are user refunds?", search_type="hybrid")
+
+# Override hops and limit
+results = search.search("user refunds", hops=2, limit=10)  # Expand 2 hops, return 10 tables
+
+# Disable graph expansion
+results = search.search("user_table", hops=0)  # Only direct matches, no foreign key traversal
+```
+
+### LLM Chunking
+
+Use LLM to generate semantic summaries instead of raw schema text (requires `[llm]` extra):
+
+1. Install: `pip install "schema-search[postgres,llm]"`
+2. Set `strategy: "llm"` in `config.yml`
+3. Pass API credentials:
+
+```python
+search = SchemaSearch(
+    engine,
+    llm_api_key="sk-...",
+    llm_base_url="https://api.openai.com/v1/"  # optional
+)
+```
+
+## How It Works
+
+1. **Extract schemas** from database using SQLAlchemy inspector
+2. **Chunk schemas** into digestible pieces (markdown or LLM-generated summaries)
+3. **Initial search** using selected strategy (semantic/BM25/fuzzy)
+4. **Expand via foreign keys** to find related tables (configurable hops)
+5. **Optional reranking** with CrossEncoder to refine results
+6. Return top tables with full schema and relationships
+
+Cache stored in `/tmp/.schema_search_cache/` (configurable in `config.yml`)
+
+## License
+
+MIT

schema_search-0.1.10.dist-info/RECORD

@@ -0,0 +1,40 @@
+schema_search/__init__.py,sha256=06680k1q7pUf1m-1MNhKJGgHyT2NYiyJTLUIOP74dJY,486
+schema_search/graph_builder.py,sha256=oKiVdVI_EB_ZmnxNiIV7Dt-jyKjV8B1RlbiSWpOSe30,2140
+schema_search/mcp_server.py,sha256=uFTGONeQ8Zib9r2zw-YO_uzZgVdIVh-_o8deMmNA2i0,2241
+schema_search/metrics.py,sha256=veyPo23aysiU_1MCwTVbBcVNreZFr_RGJwMCKBq1RAs,913
+schema_search/schema_extractor.py,sha256=tpFF5FNPT694qZNoPZoRBjMSZySDt0CxUU0Ljtno6Z8,4280
+schema_search/schema_search.py,sha256=VubGHXDyHQp9VPf4VXfC-oGFHkRQlgyV8hPsXS_XJwA,9260
+schema_search/types.py,sha256=0CbG57j6orJawBaKjAMG28sfFARh3jSusoQ6gsA4PRc,1156
+schema_search/chunkers/__init__.py,sha256=nBZZCZHIvqpmWBR5Noef7j5yyTEcFZz_ZNZuDCYuQt0,314
+schema_search/chunkers/base.py,sha256=J7K-EO5SCZ9x0m7mnpjCjud9z5mLyq5zB-wt1ziHheY,2841
+schema_search/chunkers/factory.py,sha256=ue2M9MUIEtLZN_3sHXumHmUKXDrYD4Hu7L6EIYgBk1s,1108
+schema_search/chunkers/llm.py,sha256=VSBxfL5SBu7q4583wvWrYOqjkyiL33CBfl4FvZFH4xw,1808
+schema_search/chunkers/markdown.py,sha256=LBFr9E3LVQV0UPW6X-qyNlfTYSfJGE8oxCl_FzbkAEw,940
+schema_search/embedding_cache/__init__.py,sha256=cOOPGCcQqw_ywnMxcZbOJXfHHoqTRVS1Mj638kHjJoU,299
+schema_search/embedding_cache/base.py,sha256=D9Izn3h319_HQIz9I_SrjWrdemnYg4aV8dQ0rppa3Y4,978
+schema_search/embedding_cache/bm25.py,sha256=D_wiXWnigJhnOU_wD3p4xbjtUB70sL_7yYrV6eAuTy0,1940
+schema_search/embedding_cache/factory.py,sha256=XJ6_PJV0Vsk-XNwW0xFJcuMO12vNExOhDcrgrZEH_u8,739
+schema_search/embedding_cache/inmemory.py,sha256=_1gQzrjAk0HQJI-6ZmmJLRL5bYDfNx_3WCE9mabjZNA,3991
+schema_search/rankers/__init__.py,sha256=0pNYKAvWSuspeksB9uaCLYuXD82rT7jqT_jEBXzJ-rw,238
+schema_search/rankers/base.py,sha256=HpYM_ljsRseMXJPgjKcDse58VdVRhg0aAYgmLJm-rZU,1467
+schema_search/rankers/cross_encoder.py,sha256=AT8-vgO0iqhFW-6GgkqDH1kCMjBDmEwpPpDqjVGW-qg,1563
+schema_search/rankers/factory.py,sha256=EVwd_kaHyg4TlVji1gt6Qb9BQS7D8kP7DsSq8DoNt4M,368
+schema_search/search/__init__.py,sha256=pWMX755FaxAr0hbaZp4Qk2V8KH5W4CDjSbxFRavMmgw,545
+schema_search/search/base.py,sha256=XmG8UewFfr0f4bEw0aMZPVoX2HxInGHZ-5ebB1x9ZEY,2573
+schema_search/search/bm25.py,sha256=jQHRFTuKGhIcSt3UdM7JVd5MIbpsuIi9uAevRn6ranE,1539
+schema_search/search/factory.py,sha256=wgcx-xnZ8c7uSvu6oP3Fpoabd2Gl8FyJxn7zu3zZYMs,2062
+schema_search/search/fuzzy.py,sha256=Urn2GtJ5h6j0R3HsRkrMfQCLSTU8jtGaHdfYXL_Nb3A,1865
+schema_search/search/hybrid.py,sha256=T1O46SLCPgpCOnTw2bznnCWmqP9EUkUBLqu5AeQu7oQ,2864
+schema_search/search/semantic.py,sha256=brw7x2hZMCep6QK7WWMT451RnpVcSMuNIZtp51kC6Bo,1673
+schema_search/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schema_search/utils/lazy_import.py,sha256=ZDF7gZ1axIBp-U4r5NqA4YgR3iYTBm1eEA1a93LfUdA,813
+schema_search-0.1.10.dist-info/licenses/LICENSE,sha256=jOHFAJEjJCD7iBjS2dBe73X5IGDJdAWGosGOUxfCHTM,1067
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_integration.py,sha256=8Iiq9NAwAxMoZcnfR19oOcBEGTyIOmt6nSafG6LWpj0,11959
+tests/test_llm_sql_generation.py,sha256=bj6iwTqXfNEvlrSXnbPxbrgEM2nscbrmYHbT-rNBJZ4,11834
+tests/test_spider_eval.py,sha256=aSN9Mh01E_R3uqFgP9gbBwys1K-iBv81Cw76eoiUK98,15442
+schema_search-0.1.10.dist-info/METADATA,sha256=4Px4pxsTDssJqOy6CQC4TtLy3L3Z5snWJiqVMKksynU,10436
+schema_search-0.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+schema_search-0.1.10.dist-info/entry_points.txt,sha256=9FAtZWOuIlmRNBPX_v7bn8x_aUcfojAKWU6ruSo48GM,64
+schema_search-0.1.10.dist-info/top_level.txt,sha256=NZTdQFHoJMezNIhtZICGPOuXlCXQkQduQV925Oqf4sk,20
+schema_search-0.1.10.dist-info/RECORD,,

schema_search-0.1.10.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+