schema-search 0.1.2__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-0.1.2.dist-info/METADATA

@@ -0,0 +1,275 @@
+Metadata-Version: 2.4
+Name: schema-search
+Version: 0.1.2
+Summary: Natural language search for database schemas with graph-aware semantic retrieval
+Home-page: https://github.com/neehan/schema-search
+Author: 
+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.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy>=1.4.0
+Requires-Dist: sentence-transformers>=2.2.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: openai>=1.0.0
+Requires-Dist: rapidfuzz>=3.0.0
+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: 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
+
+```bash
+# With uv - PostgreSQL (recommended)
+uv pip install "schema-search[postgres,mcp]"
+
+# With pip - PostgreSQL
+pip install "schema-search[postgres,mcp]"
+
+# Other databases
+uv pip install "schema-search[mysql,mcp]"      # MySQL
+uv pip install "schema-search[snowflake,mcp]"  # Snowflake
+uv pip install "schema-search[bigquery,mcp]"   # BigQuery
+```
+
+## 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 config.yml path", "optional llm_api_key", "optional llm_base_url"]
+    }
+  }
+}
+```
+
+**Using pip:**
+```json
+{
+  "mcpServers": {
+    "schema-search": {
+      "command": "path/to/schema-search-mcp", // conda: /Users/<username>/opt/miniconda3/envs/<your env>/bin/schema-search-mcp",
+      "args": ["postgresql://user:pass@localhost/db", "optional config.yml path", "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-mcp "postgresql://user:pass@localhost/db"
+```
+
+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)
+
+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=0, limit=5, search_type="semantic")
+
+```
+
+`SchemaSearch.index()` automatically detects schema changes and refreshes cached metadata, so you rarely need to force a reindex manually.
+
+## Configuration
+
+Edit `[config.yml](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: "hybrid"
+  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
+```
+
+## Search Strategies
+
+Schema Search supports four search strategies:
+
+- **semantic**: Embedding-based similarity search using sentence transformers
+- **bm25**: Lexical search using BM25 ranking algorithm
+- **fuzzy**: String matching on table/column names using fuzzy matching
+- **hybrid**: Combines semantic and bm25 scores (default: 67% semantic, 33% fuzzy)
+
+Each strategy performs its own initial ranking, then optionally applies CrossEncoder reranking if `reranker.model` is configured. 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](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](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:
+
+1. Set `strategy: "llm"` in `config.yml`
+2. 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 `.schema_search_cache/` (configurable in `config.yml`)
+
+## License
+
+MIT

schema_search-0.1.2.dist-info/RECORD

@@ -0,0 +1,38 @@
+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=LRAr0DjyjjTucKuwfH8m2wMY3qPVX-0uEJg886js_N8,2479
+schema_search/metrics.py,sha256=veyPo23aysiU_1MCwTVbBcVNreZFr_RGJwMCKBq1RAs,913
+schema_search/schema_extractor.py,sha256=tpFF5FNPT694qZNoPZoRBjMSZySDt0CxUU0Ljtno6Z8,4280
+schema_search/schema_search.py,sha256=60Xk8R3K--Sjsg4TUOiciEKqVe-lNns7K7O1iFsoxq0,8845
+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=oSkAKZA6naH14gftViKUnqwKV_cPtBSXGYkE5l3xyeg,1618
+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=7n2zJQ2OeaqPPs37mRAdpw1R2s3-gPzVCejLKJNEJ7Y,3571
+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=pD-Wzqi67XQc3rwx-oOjvZzi-XMd_rRkIsNYtEjfJDI,1210
+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-0.1.2.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=xQwrNXpipaDxk-vIKqSy0nOIl-3Nadtof58nZpsAsZA,15333
+schema_search-0.1.2.dist-info/METADATA,sha256=f7dxa2ZNVeHaY2gUpTbBofEFv5bMu6lBomgAPhCQgOw,9268
+schema_search-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+schema_search-0.1.2.dist-info/entry_points.txt,sha256=I4R8SZvsYXlrDbnGydQrWSw-s-QnZ2VmQl5s_q3qUHI,68
+schema_search-0.1.2.dist-info/top_level.txt,sha256=NZTdQFHoJMezNIhtZICGPOuXlCXQkQduQV925Oqf4sk,20
+schema_search-0.1.2.dist-info/RECORD,,

schema_search-0.1.2.dist-info/WHEEL

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

schema_search-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+schema-search-mcp = schema_search.mcp_server:main

schema_search-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adib Hasan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

schema_search-0.1.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+schema_search
+tests