tabella-enable 0.1.0__py3-none-any.whl

tabella_enable/__init__.py

@@ -0,0 +1,5 @@
+"""tabella-enable: AI-enablement generators (REST access layer, MCP tool manifest).
+
+M2 adds the live MCP server and RAG vectorization (chunking, embeddings,
+pgvector indexing) per descriptor vectorization profiles.
+"""

tabella_enable/mcp_server.py

@@ -0,0 +1,94 @@
+"""Live MCP server over a Tabella catalog (stdio transport).
+
+Tools are generated from the catalog exactly per the tool-manifest spec:
+`query_<asset>` (equality filters + pagination) for every MCP-enabled asset,
+plus `search_<asset>` (semantic search) for vectorized assets when a search
+service is configured.
+
+The tool listing and dispatch are pure functions (`catalog_tools`,
+`call_catalog_tool`) so they are testable without an MCP client; the stdio
+wiring in `run_stdio` is a thin shell over the official `mcp` SDK.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from tabella_core.connectors import get_connector
+from tabella_core.models import AssetDescriptor
+
+from tabella_enable.tools import build_manifest
+
+_RESERVED = {"limit", "offset"}
+
+
+def catalog_tools(
+    catalog: list[AssetDescriptor], *, with_search: bool
+) -> list[dict[str, Any]]:
+    manifest = build_manifest(catalog)
+    tools = manifest["tools"]
+    if not with_search:
+        tools = [t for t in tools if not t["name"].startswith("search_")]
+    return tools
+
+
+def call_catalog_tool(
+    catalog: list[AssetDescriptor],
+    name: str,
+    arguments: dict[str, Any],
+    *,
+    search=None,
+) -> dict[str, Any]:
+    by_tool = {t["name"]: t for t in catalog_tools(catalog, with_search=search is not None)}
+    if name not in by_tool:
+        raise KeyError(f"Unknown tool: {name}")
+    asset_id = by_tool[name]["asset"]
+    descriptor = next(d for d in catalog if d.id == asset_id)
+
+    if name.startswith("search_"):
+        results = search.search(
+            descriptor, arguments["query"], int(arguments.get("top_k", 5))
+        )
+        return {"data": results, "asset": asset_id}
+
+    limit = min(int(arguments.get("limit", 100)), descriptor.access.row_limit)
+    offset = int(arguments.get("offset", 0))
+    filters = {k: v for k, v in arguments.items() if k not in _RESERVED}
+    connector = get_connector(descriptor.source.connector)
+    records, total = connector.fetch(descriptor, filters=filters, limit=limit, offset=offset)
+    return {
+        "data": records,
+        "pagination": {"limit": limit, "offset": offset, "total": total},
+        "asset": asset_id,
+    }
+
+
+async def run_stdio(catalog: list[AssetDescriptor], *, search=None) -> None:
+    import mcp.types as types
+    from mcp.server import Server
+    from mcp.server.stdio import stdio_server
+
+    server = Server("tabella")
+
+    @server.list_tools()
+    async def list_tools() -> list[types.Tool]:
+        return [
+            types.Tool(
+                name=t["name"],
+                description=t["description"],
+                inputSchema=t["input_schema"],
+            )
+            for t in catalog_tools(catalog, with_search=search is not None)
+        ]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict[str, Any]) -> list[types.TextContent]:
+        try:
+            result = call_catalog_tool(catalog, name, arguments or {}, search=search)
+        except Exception as exc:
+            result = {"error": str(exc)}
+        return [types.TextContent(type="text", text=json.dumps(result, default=str))]
+
+    async with stdio_server() as (read, write):
+        await server.run(read, write, server.create_initialization_options())

tabella_enable/rag/__init__.py

@@ -0,0 +1,13 @@
+"""RAG vectorization and semantic search (spec/ai-artifact-manifest.md, part 2)."""
+
+from tabella_enable.rag.embeddings import embedding_provider_from_env
+from tabella_enable.rag.pipeline import vectorize_asset
+from tabella_enable.rag.search import SearchService
+from tabella_enable.rag.store import vector_store_from_env
+
+__all__ = [
+    "SearchService",
+    "embedding_provider_from_env",
+    "vector_store_from_env",
+    "vectorize_asset",
+]

tabella_enable/rag/chunking.py

@@ -0,0 +1,46 @@
+"""Chunking strategies for RAG vectorization.
+
+- `document`: one chunk per record — right for short records (tickets, rows).
+- `fixed`: character windows with 10% overlap.
+- `semantic`: sentence-boundary packing up to chunk_size (v0.1 approximation
+  of semantic chunking; embedding-based splitting is a later refinement).
+"""
+
+from __future__ import annotations
+
+import re
+
+from tabella_core.models import ChunkingStrategy
+
+_SENTENCE_END = re.compile(r"(?<=[.!?])\s+")
+
+
+def chunk_text(text: str, strategy: ChunkingStrategy, chunk_size: int) -> list[str]:
+    text = text.strip()
+    if not text:
+        return []
+    if strategy == ChunkingStrategy.document or len(text) <= chunk_size:
+        return [text]
+    if strategy == ChunkingStrategy.semantic:
+        return _pack_sentences(text, chunk_size)
+    return _fixed_windows(text, chunk_size)
+
+
+def _fixed_windows(text: str, chunk_size: int) -> list[str]:
+    overlap = max(chunk_size // 10, 1)
+    step = chunk_size - overlap
+    return [text[start : start + chunk_size] for start in range(0, len(text), step)]
+
+
+def _pack_sentences(text: str, chunk_size: int) -> list[str]:
+    chunks: list[str] = []
+    current = ""
+    for sentence in _SENTENCE_END.split(text):
+        if current and len(current) + len(sentence) + 1 > chunk_size:
+            chunks.append(current)
+            current = sentence
+        else:
+            current = f"{current} {sentence}".strip()
+    if current:
+        chunks.append(current)
+    return chunks

tabella_enable/rag/embeddings.py

@@ -0,0 +1,85 @@
+"""Embedding providers.
+
+- `hash` — deterministic, offline, dependency-free: token-hash bag-of-words
+  vectors. Not semantically meaningful, but stable and cheap; the dev/test
+  default so the whole RAG path runs with no API key or model server.
+- `openai` — any OpenAI-compatible /v1/embeddings endpoint (OpenAI, LiteLLM,
+  Ollama, vLLM...). Configure via TABELLA_EMBED_* env vars.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import os
+import re
+
+from tabella_core.interfaces import EmbeddingProvider
+
+_TOKEN = re.compile(r"[a-z0-9]+")
+
+
+class HashEmbeddings(EmbeddingProvider):
+    name = "hash"
+
+    def __init__(self, dimensions: int = 256):
+        self.dimensions = dimensions
+        self.model = f"tabella-hash-{dimensions}"
+
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        return [self._embed_one(t) for t in texts]
+
+    def _embed_one(self, text: str) -> list[float]:
+        vector = [0.0] * self.dimensions
+        for token in _TOKEN.findall(text.lower()):
+            digest = hashlib.sha256(token.encode()).digest()
+            index = int.from_bytes(digest[:4], "big") % self.dimensions
+            sign = 1.0 if digest[4] % 2 == 0 else -1.0
+            vector[index] += sign
+        norm = math.sqrt(sum(v * v for v in vector)) or 1.0
+        return [v / norm for v in vector]
+
+
+class OpenAICompatibleEmbeddings(EmbeddingProvider):
+    name = "openai"
+
+    def __init__(
+        self,
+        api_url: str | None = None,
+        api_key: str | None = None,
+        model: str | None = None,
+    ):
+        self.api_url = (
+            api_url or os.environ.get("TABELLA_EMBED_API_URL", "https://api.openai.com/v1")
+        ).rstrip("/")
+        self.api_key = api_key or os.environ.get("TABELLA_EMBED_API_KEY", "")
+        self.model = model or os.environ.get("TABELLA_EMBED_MODEL", "text-embedding-3-small")
+        self.dimensions = 0  # discovered from the first response
+
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        import httpx  # lazy: hash provider needs no HTTP stack
+
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        resp = httpx.post(
+            f"{self.api_url}/embeddings",
+            json={"model": self.model, "input": texts},
+            headers=headers,
+            timeout=60.0,
+        )
+        resp.raise_for_status()
+        data = sorted(resp.json()["data"], key=lambda d: d["index"])
+        vectors = [d["embedding"] for d in data]
+        if vectors:
+            self.dimensions = len(vectors[0])
+        return vectors
+
+
+def embedding_provider_from_env() -> EmbeddingProvider:
+    provider = os.environ.get("TABELLA_EMBED_PROVIDER", "hash")
+    if provider == "openai":
+        return OpenAICompatibleEmbeddings()
+    if provider == "hash":
+        return HashEmbeddings(int(os.environ.get("TABELLA_EMBED_DIM", "256")))
+    raise ValueError(f"Unknown TABELLA_EMBED_PROVIDER: {provider!r} (hash|openai)")

tabella_enable/rag/pipeline.py

@@ -0,0 +1,94 @@
+"""The vectorization pipeline: records -> chunks -> embeddings -> vector store.
+
+Produces the RAG index manifest entry per asset (spec/ai-artifact-manifest.md,
+part 2). Idempotent: re-running replaces the asset's collection.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from tabella_core.connectors import get_connector
+from tabella_core.interfaces import EmbeddingProvider, VectorStore
+from tabella_core.models import TABELLA_SPEC_VERSION, AssetDescriptor
+
+from tabella_enable.rag.chunking import chunk_text
+
+_PAGE_SIZE = 500
+
+
+def collection_name(descriptor: AssetDescriptor) -> str:
+    return f"tabella_{descriptor.id.replace('.', '_')}"
+
+
+def _record_ref(descriptor: AssetDescriptor, record: dict, index: int) -> str:
+    pk = descriptor.asset_schema.primary_key
+    if pk:
+        return ",".join(str(record.get(k)) for k in pk)
+    return str(index)
+
+
+def vectorize_asset(
+    descriptor: AssetDescriptor,
+    embedder: EmbeddingProvider,
+    store: VectorStore,
+) -> dict[str, Any]:
+    """Vectorize one asset per its profile; returns its rag.json index entry."""
+    profile = descriptor.enablement.vectorization
+    if not profile.enabled:
+        raise ValueError(f"Asset '{descriptor.id}' has vectorization disabled")
+    content_fields = profile.content_fields or [
+        f.name for f in descriptor.asset_schema.fields if f.type.value == "string"
+    ]
+
+    connector = get_connector(descriptor.source.connector)
+    chunks: list[dict] = []
+    offset = 0
+    while True:
+        records, _total = connector.fetch(descriptor, limit=_PAGE_SIZE, offset=offset)
+        for index, record in enumerate(records):
+            text = "\n".join(
+                str(record[f]) for f in content_fields if record.get(f) is not None
+            )
+            ref = _record_ref(descriptor, record, offset + index)
+            metadata = {f: record.get(f) for f in profile.metadata_fields}
+            for chunk_index, piece in enumerate(
+                chunk_text(text, profile.chunking, profile.chunk_size)
+            ):
+                chunks.append(
+                    {
+                        "id": f"{descriptor.id}:{ref}:{chunk_index}",
+                        "record_ref": ref,
+                        "content": piece,
+                        "metadata": metadata,
+                    }
+                )
+        if len(records) < _PAGE_SIZE:
+            break
+        offset += _PAGE_SIZE
+
+    embeddings = embedder.embed([c["content"] for c in chunks]) if chunks else []
+    for chunk, embedding in zip(chunks, embeddings, strict=True):
+        chunk["embedding"] = embedding
+    dimensions = len(embeddings[0]) if embeddings else embedder.dimensions
+
+    collection = collection_name(descriptor)
+    store.replace_collection(collection, chunks, dimensions)
+
+    return {
+        "asset": descriptor.id,
+        "content_fields": content_fields,
+        "chunking": {
+            "strategy": profile.chunking.value,
+            "chunk_size": profile.chunk_size,
+        },
+        "embedding": {"model": embedder.model, "dimensions": dimensions},
+        "store": {"backend": store.name, "collection": collection},
+        "metadata_fields": profile.metadata_fields,
+        "search_endpoint": {"method": "POST", "path": f"/assets/{descriptor.id}/search"},
+        "chunk_count": len(chunks),
+    }
+
+
+def build_rag_manifest(entries: list[dict[str, Any]]) -> dict[str, Any]:
+    return {"tabella_version": TABELLA_SPEC_VERSION, "indexes": entries}

tabella_enable/rag/search.py

@@ -0,0 +1,22 @@
+"""Semantic search service: embed the query, search the asset's collection."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from tabella_core.interfaces import EmbeddingProvider, VectorStore
+from tabella_core.models import AssetDescriptor
+
+from tabella_enable.rag.pipeline import collection_name
+
+
+class SearchService:
+    def __init__(self, embedder: EmbeddingProvider, store: VectorStore):
+        self.embedder = embedder
+        self.store = store
+
+    def search(
+        self, descriptor: AssetDescriptor, query: str, top_k: int = 5
+    ) -> list[dict[str, Any]]:
+        (query_embedding,) = self.embedder.embed([query])
+        return self.store.search(collection_name(descriptor), query_embedding, top_k)

tabella_enable/rag/store.py

@@ -0,0 +1,140 @@
+"""Vector store backends.
+
+- `local` — one JSON file per collection under a directory; pure-python cosine
+  search. Zero infrastructure: dev, tests, small catalogs.
+- `pgvector` — production backend (psycopg, lazy import). Built against the
+  pgvector SQL surface; live validation happens in the AWS test batch along
+  with OM/Glue.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+from pathlib import Path
+
+from tabella_core.interfaces import VectorStore
+
+
+def cosine(a: list[float], b: list[float]) -> float:
+    dot = sum(x * y for x, y in zip(a, b, strict=True))
+    norm_a = math.sqrt(sum(x * x for x in a)) or 1.0
+    norm_b = math.sqrt(sum(x * x for x in b)) or 1.0
+    return dot / (norm_a * norm_b)
+
+
+class LocalVectorStore(VectorStore):
+    name = "local"
+
+    def __init__(self, directory: str | Path = ".tabella/vectors"):
+        self.directory = Path(directory)
+
+    def _path(self, collection: str) -> Path:
+        return self.directory / f"{collection}.json"
+
+    def replace_collection(
+        self, collection: str, chunks: list[dict], dimensions: int
+    ) -> None:
+        self.directory.mkdir(parents=True, exist_ok=True)
+        self._path(collection).write_text(
+            json.dumps({"dimensions": dimensions, "chunks": chunks}) + "\n"
+        )
+
+    def search(
+        self, collection: str, query_embedding: list[float], top_k: int = 5
+    ) -> list[dict]:
+        path = self._path(collection)
+        if not path.exists():
+            raise KeyError(f"No vector collection '{collection}' (run `tabella vectorize`)")
+        chunks = json.loads(path.read_text())["chunks"]
+        scored = sorted(
+            chunks, key=lambda c: cosine(c["embedding"], query_embedding), reverse=True
+        )[:top_k]
+        return [
+            {**{k: v for k, v in c.items() if k != "embedding"},
+             "score": round(cosine(c["embedding"], query_embedding), 6)}
+            for c in scored
+        ]
+
+
+class PgVectorStore(VectorStore):
+    """pgvector backend. Collection = one table `tabella_vec_<slug>`.
+
+    Requires the `vector` extension. Not yet validated against a live
+    database — exercised in the AWS test batch.
+    """
+
+    name = "pgvector"
+
+    def __init__(self, uri: str | None = None):
+        self.uri = uri or os.environ.get("TABELLA_VECTOR_PG_URI", "")
+        if not self.uri:
+            raise ValueError("PgVectorStore requires TABELLA_VECTOR_PG_URI")
+
+    def _connect(self):
+        import psycopg  # lazy
+
+        return psycopg.connect(self.uri)
+
+    @staticmethod
+    def _table(collection: str) -> str:
+        safe = "".join(c if c.isalnum() else "_" for c in collection)
+        return f"tabella_vec_{safe}"
+
+    def replace_collection(
+        self, collection: str, chunks: list[dict], dimensions: int
+    ) -> None:
+        table = self._table(collection)
+        with self._connect() as conn:
+            conn.execute("CREATE EXTENSION IF NOT EXISTS vector")
+            conn.execute(f'DROP TABLE IF EXISTS "{table}"')
+            conn.execute(
+                f'CREATE TABLE "{table}" (id text PRIMARY KEY, record_ref text,'
+                f" content text, metadata jsonb, embedding vector({dimensions}))"
+            )
+            with conn.cursor() as cur:
+                cur.executemany(
+                    f'INSERT INTO "{table}" VALUES (%s, %s, %s, %s, %s)',  # noqa: S608
+                    [
+                        (
+                            c["id"],
+                            c["record_ref"],
+                            c["content"],
+                            json.dumps(c["metadata"]),
+                            str(c["embedding"]),
+                        )
+                        for c in chunks
+                    ],
+                )
+
+    def search(
+        self, collection: str, query_embedding: list[float], top_k: int = 5
+    ) -> list[dict]:
+        table = self._table(collection)
+        with self._connect() as conn:
+            rows = conn.execute(
+                f'SELECT id, record_ref, content, metadata,'  # noqa: S608
+                f" 1 - (embedding <=> %s::vector) AS score"
+                f' FROM "{table}" ORDER BY embedding <=> %s::vector LIMIT %s',
+                (str(query_embedding), str(query_embedding), top_k),
+            ).fetchall()
+        return [
+            {
+                "id": r[0],
+                "record_ref": r[1],
+                "content": r[2],
+                "metadata": r[3],
+                "score": round(float(r[4]), 6),
+            }
+            for r in rows
+        ]
+
+
+def vector_store_from_env() -> VectorStore:
+    backend = os.environ.get("TABELLA_VECTOR_BACKEND", "local")
+    if backend == "local":
+        return LocalVectorStore(os.environ.get("TABELLA_VECTOR_DIR", ".tabella/vectors"))
+    if backend == "pgvector":
+        return PgVectorStore()
+    raise ValueError(f"Unknown TABELLA_VECTOR_BACKEND: {backend!r} (local|pgvector)")

tabella_enable/rest.py

@@ -0,0 +1,118 @@
+"""Generated REST access layer (spec/access-layer-contract.md).
+
+`build_app(catalog)` returns a FastAPI app serving every asset in the catalog
+with `enablement.api: true` through the standard Tabella endpoints.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from tabella_core.connectors import get_connector
+from tabella_core.models import AssetDescriptor, FieldType
+
+_RESERVED_PARAMS = {"limit", "offset"}
+_UNFILTERABLE = {FieldType.binary, FieldType.unknown}
+
+
+class _ApiError(Exception):
+    def __init__(self, status: int, code: str, message: str):
+        self.status, self.code, self.message = status, code, message
+
+
+def _coerce(value: str, ftype: FieldType) -> Any:
+    try:
+        if ftype == FieldType.integer:
+            return int(value)
+        if ftype == FieldType.number:
+            return float(value)
+        if ftype == FieldType.boolean:
+            if value.lower() in ("true", "1"):
+                return 1
+            if value.lower() in ("false", "0"):
+                return 0
+            raise ValueError(value)
+    except ValueError:
+        raise _ApiError(400, "invalid_value", f"Invalid {ftype.value} value: {value!r}") from None
+    return value
+
+
+def build_app(catalog: list[AssetDescriptor], *, search=None) -> FastAPI:
+    """`search` is an optional tabella_enable.rag.SearchService for the
+    POST /assets/{id}/search endpoint on vectorized assets."""
+    served = [d for d in catalog if d.enablement.api]
+    by_id = {d.id: d for d in served}
+    app = FastAPI(title="Tabella Access Layer", version="0.1.0")
+
+    @app.exception_handler(_ApiError)
+    async def _handle(request: Request, exc: _ApiError) -> JSONResponse:
+        return JSONResponse(
+            status_code=exc.status,
+            content={"error": {"code": exc.code, "message": exc.message}},
+        )
+
+    def _get(asset_id: str) -> AssetDescriptor:
+        if asset_id not in by_id:
+            raise _ApiError(404, "asset_not_found", f"No asset '{asset_id}'")
+        return by_id[asset_id]
+
+    @app.get("/health")
+    def health() -> dict[str, str]:
+        return {"status": "ok"}
+
+    @app.get("/assets")
+    def list_assets() -> dict[str, Any]:
+        return {"data": [d.summary() for d in served]}
+
+    @app.get("/assets/{asset_id}")
+    def get_asset(asset_id: str) -> dict[str, Any]:
+        return _get(asset_id).to_json_dict()
+
+    @app.get("/assets/{asset_id}/records")
+    def query_records(
+        asset_id: str, request: Request, limit: int = 100, offset: int = 0
+    ) -> dict[str, Any]:
+        descriptor = _get(asset_id)
+        limit = max(1, min(limit, descriptor.access.row_limit))
+        offset = max(0, offset)
+
+        filters: dict[str, Any] = {}
+        for name, value in request.query_params.items():
+            if name in _RESERVED_PARAMS:
+                continue
+            field = descriptor.asset_schema.field(name)
+            if field is None:
+                raise _ApiError(400, "unknown_field", f"No field '{name}' in asset '{asset_id}'")
+            if field.type in _UNFILTERABLE:
+                raise _ApiError(400, "invalid_value", f"Field '{name}' is not filterable")
+            filters[name] = _coerce(value, field.type)
+
+        connector = get_connector(descriptor.source.connector)
+        records, total = connector.fetch(descriptor, filters=filters, limit=limit, offset=offset)
+        return {
+            "data": records,
+            "pagination": {"limit": limit, "offset": offset, "total": total},
+            "asset": asset_id,
+        }
+
+    @app.post("/assets/{asset_id}/search")
+    async def semantic_search(asset_id: str, request: Request) -> dict[str, Any]:
+        descriptor = _get(asset_id)
+        if not descriptor.enablement.vectorization.enabled:
+            raise _ApiError(400, "not_vectorized", f"Asset '{asset_id}' is not vectorized")
+        if search is None:
+            raise _ApiError(503, "search_unavailable", "Semantic search is not configured")
+        body = await request.json()
+        query = body.get("query")
+        if not isinstance(query, str) or not query.strip():
+            raise _ApiError(400, "invalid_value", "Body must include a non-empty 'query'")
+        top_k = min(int(body.get("top_k", 5)), 50)
+        try:
+            results = search.search(descriptor, query, top_k)
+        except KeyError as exc:
+            raise _ApiError(409, "not_indexed", str(exc)) from None
+        return {"data": results, "asset": asset_id, "query": query}
+
+    return app

tabella_enable/tools.py

@@ -0,0 +1,96 @@
+"""AI tool manifest generator (spec/ai-artifact-manifest.md, part 1)."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from tabella_core.models import TABELLA_SPEC_VERSION, AssetDescriptor, Classification, FieldType
+
+_JSON_TYPES = {
+    FieldType.string: "string",
+    FieldType.integer: "integer",
+    FieldType.number: "number",
+    FieldType.boolean: "boolean",
+    FieldType.date: "string",
+    FieldType.datetime: "string",
+    FieldType.json: "string",
+}
+
+
+def _tool_name(asset_id: str) -> str:
+    return "query_" + re.sub(r"[^a-zA-Z0-9_-]", "_", asset_id)
+
+
+def build_tool(descriptor: AssetDescriptor, *, include_pii_filters: bool = False) -> dict[str, Any]:
+    filterable = [
+        f
+        for f in descriptor.asset_schema.fields
+        if f.type in _JSON_TYPES and (include_pii_filters or not f.pii)
+    ]
+    properties: dict[str, Any] = {
+        f.name: {
+            "type": _JSON_TYPES[f.type],
+            **({"description": f.description} if f.description else {}),
+        }
+        for f in filterable
+    }
+    properties["limit"] = {"type": "integer", "default": 100}
+    properties["offset"] = {"type": "integer", "default": 0}
+
+    about = f" ({descriptor.description})" if descriptor.description else ""
+    return {
+        "name": _tool_name(descriptor.id),
+        "description": (
+            f"Query the '{descriptor.name}' asset{about}. "
+            f"Equality filters on: {', '.join(f.name for f in filterable) or 'none'}. "
+            "Returns records as JSON objects."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": properties,
+            "additionalProperties": False,
+        },
+        "asset": descriptor.id,
+        "endpoint": {"method": "GET", "path": f"/assets/{descriptor.id}/records"},
+    }
+
+
+def build_manifest(
+    catalog: list[AssetDescriptor],
+    *,
+    include_restricted: bool = False,
+    include_pii_filters: bool = False,
+) -> dict[str, Any]:
+    included = [
+        d
+        for d in catalog
+        if d.enablement.mcp
+        and (include_restricted or d.classification != Classification.restricted)
+    ]
+    tools = [build_tool(d, include_pii_filters=include_pii_filters) for d in included]
+    tools += [build_search_tool(d) for d in included if d.enablement.vectorization.enabled]
+    return {"tabella_version": TABELLA_SPEC_VERSION, "tools": tools}
+
+
+def build_search_tool(descriptor: AssetDescriptor) -> dict[str, Any]:
+    about = f" ({descriptor.description})" if descriptor.description else ""
+    return {
+        "name": "search_" + re.sub(r"[^a-zA-Z0-9_-]", "_", descriptor.id),
+        "description": (
+            f"Semantic search over the '{descriptor.name}' asset{about}. "
+            "Pass a natural-language query; returns the most relevant text "
+            "chunks with citation metadata and similarity scores."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Natural-language search query"},
+                "top_k": {"type": "integer", "default": 5},
+            },
+            "required": ["query"],
+            "additionalProperties": False,
+        },
+        "asset": descriptor.id,
+        "endpoint": {"method": "POST", "path": f"/assets/{descriptor.id}/search"},
+    }

tabella_enable-0.1.0.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.5
+Name: tabella-enable
+Version: 0.1.0
+Summary: Tabella AI-enablement: generated REST access layers, MCP tools + live MCP server, RAG vectorization and semantic search
+Project-URL: Homepage, https://github.com/Inceptium-ai/tabella
+Project-URL: Repository, https://github.com/Inceptium-ai/tabella
+Project-URL: Issues, https://github.com/Inceptium-ai/tabella/issues
+Author: Yazdan Ahmed
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.111
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp>=1.2
+Requires-Dist: tabella-core
+Description-Content-Type: text/markdown
+
+# tabella-enable
+
+AI-enablement generators: the standardized REST access layer
+(`spec/access-layer-contract.md`) and the MCP-aligned tool manifest
+(`spec/ai-artifact-manifest.md`). M2 adds the live MCP server and RAG
+vectorization (chunking, embeddings, pgvector).

tabella_enable-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+tabella_enable/__init__.py,sha256=SoyGKT-fhkyzgu04vtumMq2-5YVX2Tp2KLcwTlEMQwo,220
+tabella_enable/mcp_server.py,sha256=2OtRloIfqX-lIOc0T0UCS4Qn3xb8iPClzvDp_q_txPM,3252
+tabella_enable/rest.py,sha256=LmaJjTI5GAISpF5isf15QYUc1t53DfsryUx33_wMxG0,4573
+tabella_enable/tools.py,sha256=IBSMK2F8eh1nNtSf_7GBc7z3ekcvQDjz812CpVdJ__k,3348
+tabella_enable/rag/__init__.py,sha256=ttNKqDsp4IilULXvT5KhF6pPVoWWvmTYKhMEUWx5In8,445
+tabella_enable/rag/chunking.py,sha256=8fvXR2lPze1iAeQ5_ppuVQ59UNlQbQVOVMTfsQtXZ6I,1495
+tabella_enable/rag/embeddings.py,sha256=nse6A9qcB1tvnx8VjEXC5jjUD0maMEALP26OPaqEv4c,3024
+tabella_enable/rag/pipeline.py,sha256=cuqxNYiZgMRLBSwAIM2FrD8oQUV14SNqmJX77qWf1B4,3485
+tabella_enable/rag/search.py,sha256=Bh1cUBuL_aeah2S1IUdr1-nWbXe8OIKm8CRyne2oLps,730
+tabella_enable/rag/store.py,sha256=1jJCmBZm-kfkAdg3vCzhQO9MvuWxcUGFUZm7ghcQ8yo,4930
+tabella_enable-0.1.0.dist-info/METADATA,sha256=hKj0VrAJ7TG9HrkPVAu6wIq1Ufjm2siBvZqQdGIOzdk,1285
+tabella_enable-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+tabella_enable-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+tabella_enable-0.1.0.dist-info/RECORD,,

tabella_enable-0.1.0.dist-info/WHEEL

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

tabella_enable-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.