@dataif/cli 0.1.0

package/templates/dataif/services/vanna/app/runtime_config.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from sqlalchemy import Engine, text
+from sqlalchemy.exc import SQLAlchemyError
+
+
+VANNA_LLM_SETTING_KEY = "vanna.llm_config"
+
+
+@dataclass(frozen=True)
+class RuntimeVannaConfig:
+    provider: str
+    ollama_base_url: str
+    ollama_model: str
+    maritaca_api_url: str
+    maritaca_api_key: str
+    maritaca_model: str
+    maritaca_timeout_seconds: int
+    allowed_schema: str
+    vectorstore_path: str
+    auto_train: bool
+    max_rows: int
+
+    def signature(self) -> tuple[object, ...]:
+        return (
+            self.provider,
+            self.ollama_base_url,
+            self.ollama_model,
+            self.maritaca_api_url,
+            self.maritaca_api_key,
+            self.maritaca_model,
+            self.maritaca_timeout_seconds,
+            self.allowed_schema,
+            self.vectorstore_path,
+            self.auto_train,
+            self.max_rows,
+        )
+
+    def model_name(self) -> str:
+        if self.provider == "maritaca":
+            return self.maritaca_model
+        return self.ollama_model
+
+
+def load_runtime_vanna_config(base_settings: Any, engine: Engine) -> RuntimeVannaConfig:
+    defaults = {
+        "provider": str(base_settings.vanna_llm_provider).strip().lower() or "ollama",
+        "ollama_base_url": str(base_settings.vanna_ollama_base_url).strip() or "http://ollama:11434",
+        "ollama_model": str(base_settings.vanna_ollama_model).strip() or "sabia-7b",
+        "maritaca_api_url": str(base_settings.vanna_maritaca_api_url).strip(),
+        "maritaca_api_key": str(base_settings.vanna_maritaca_api_key),
+        "maritaca_model": str(base_settings.vanna_maritaca_model).strip() or "sabia-4",
+        "maritaca_timeout_seconds": int(base_settings.vanna_maritaca_timeout_seconds),
+        "allowed_schema": str(base_settings.effective_allowed_schema()).strip().lower() or "curated",
+        "vectorstore_path": str(base_settings.vanna_vectorstore_path).strip() or "/data/vanna/chroma",
+        "auto_train": bool(base_settings.vanna_auto_train),
+        "max_rows": int(base_settings.vanna_max_rows),
+    }
+
+    persisted = _read_persisted_llm_settings(engine)
+    if isinstance(persisted, dict):
+        provider = str(persisted.get("provider") or defaults["provider"]).strip().lower() or "ollama"
+        ollama = persisted.get("ollama") if isinstance(persisted.get("ollama"), dict) else {}
+        maritaca = persisted.get("maritaca") if isinstance(persisted.get("maritaca"), dict) else {}
+        defaults.update(
+            {
+                "provider": provider,
+                "ollama_base_url": str(ollama.get("base_url") or defaults["ollama_base_url"]).strip()
+                or defaults["ollama_base_url"],
+                "ollama_model": str(ollama.get("model") or defaults["ollama_model"]).strip() or defaults["ollama_model"],
+                "maritaca_api_url": str(maritaca.get("api_url") or defaults["maritaca_api_url"]).strip()
+                or defaults["maritaca_api_url"],
+                "maritaca_api_key": str(maritaca.get("api_key") or defaults["maritaca_api_key"]),
+                "maritaca_model": str(maritaca.get("model") or defaults["maritaca_model"]).strip()
+                or defaults["maritaca_model"],
+                "maritaca_timeout_seconds": _coerce_positive_int(
+                    maritaca.get("timeout_seconds"), defaults["maritaca_timeout_seconds"]
+                ),
+            }
+        )
+
+    return RuntimeVannaConfig(**defaults)
+
+
+def _read_persisted_llm_settings(engine: Engine) -> dict[str, Any] | None:
+    try:
+        with engine.begin() as conn:
+            row = conn.execute(
+                text("SELECT setting_value FROM config.app_settings WHERE setting_key = :setting_key"),
+                {"setting_key": VANNA_LLM_SETTING_KEY},
+            ).mappings().first()
+    except SQLAlchemyError:
+        return None
+
+    if not row:
+        return None
+    value = row.get("setting_value")
+    return value if isinstance(value, dict) else None
+
+
+def _coerce_positive_int(value: object, default: int) -> int:
+    if isinstance(value, bool):
+        return int(value) or default
+    if isinstance(value, int):
+        return value if value > 0 else default
+    if isinstance(value, str):
+        normalized = value.strip()
+        if normalized.isdigit():
+            parsed = int(normalized)
+            return parsed if parsed > 0 else default
+    return default

package/templates/dataif/services/vanna/app/sql_guard.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import re
+
+
+class SQLGuard:
+    FORBIDDEN_SCHEMAS = {
+        "audit",
+        "config",
+        "information_schema",
+        "mart",
+        "pg_catalog",
+        "public",
+        "raw",
+        "staging",
+    }
+
+    RELATION_PATTERN = re.compile(
+        r"\b(?:from|join)\s+("
+        r"(?:\"[^\"]+\"|[a-zA-Z_][a-zA-Z0-9_]*)"
+        r"(?:\s*\.\s*(?:\"[^\"]+\"|[a-zA-Z_][a-zA-Z0-9_]*))?"
+        r")",
+        flags=re.IGNORECASE,
+    )
+    FROM_CLAUSE_PATTERN = re.compile(
+        r"\bfrom\b\s+(.*?)(?="
+        r"\bwhere\b|\bgroup\s+by\b|\border\s+by\b|\blimit\b|\boffset\b|"
+        r"\bunion\b|\bexcept\b|\bintersect\b|\bhaving\b|$"
+        r")",
+        flags=re.IGNORECASE,
+    )
+    COMMA_RELATION_PATTERN = re.compile(
+        r",\s*("
+        r"(?:\"[^\"]+\"|[a-zA-Z_][a-zA-Z0-9_]*)"
+        r"(?:\s*\.\s*(?:\"[^\"]+\"|[a-zA-Z_][a-zA-Z0-9_]*))?"
+        r")",
+        flags=re.IGNORECASE,
+    )
+    QUALIFIED_SCHEMA_PATTERN = re.compile(
+        r"\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\.\s*[a-zA-Z_][a-zA-Z0-9_]*\s*\.",
+        flags=re.IGNORECASE,
+    )
+
+    def __init__(self, allowed_schemas: set[str] | list[str] | tuple[str, ...] | None = None) -> None:
+        schemas = allowed_schemas or {"curated"}
+        self.allowed_schemas = {schema.lower().strip() for schema in schemas if schema.strip()}
+
+    def validate(self, sql: str) -> None:
+        stripped = self._normalize(sql)
+        if not stripped.startswith("select"):
+            raise ValueError("Only SELECT statements are allowed")
+        if ";" in stripped.rstrip(";"):
+            raise ValueError("Only one SQL statement is allowed")
+
+        forbidden_patterns = [
+            r"\binsert\b",
+            r"\bupdate\b",
+            r"\bdelete\b",
+            r"\bdrop\b",
+            r"\balter\b",
+            r"\btruncate\b",
+            r"\bcreate\b",
+            r"\bgrant\b",
+            r"\brevoke\b",
+        ]
+        for pattern in forbidden_patterns:
+            if re.search(pattern, stripped):
+                raise ValueError("Forbidden SQL keyword")
+
+        sql_without_literals = self._strip_string_literals(stripped)
+        schema_refs = set(re.findall(r"\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\.", sql_without_literals))
+        blocked_schemas = schema_refs.intersection(self.FORBIDDEN_SCHEMAS)
+        if blocked_schemas:
+            raise ValueError(f"Schema not allowed: {sorted(blocked_schemas)[0]}")
+
+        for schema in self.QUALIFIED_SCHEMA_PATTERN.findall(sql_without_literals):
+            if schema.lower() not in self.allowed_schemas:
+                raise ValueError(f"Schema not allowed: {schema.lower()}")
+
+        matched_relations = self._relation_references(sql_without_literals)
+        if not matched_relations:
+            raise ValueError("SQL must reference at least one allowed relation")
+
+        for relation in matched_relations:
+            relation_clean = self._clean_identifier(relation)
+            parts = [part for part in relation_clean.split(".") if part]
+            if len(parts) != 2:
+                raise ValueError(f"Relation must be schema-qualified: {relation_clean}")
+            schema = parts[0]
+            if schema not in self.allowed_schemas:
+                raise ValueError(f"Schema not allowed: {schema}")
+
+    def enforce_limit(self, sql: str, max_rows: int) -> str:
+        self.validate(sql)
+        stripped = self._compact_original(sql).rstrip(";")
+        if re.search(r"\blimit\s+\d+\b", stripped, flags=re.IGNORECASE):
+            return stripped
+        return f"{stripped} LIMIT {max_rows}"
+
+    @staticmethod
+    def _normalize(sql: str) -> str:
+        return SQLGuard._compact_original(sql).lower()
+
+    @staticmethod
+    def _compact_original(sql: str) -> str:
+        without_block_comments = re.sub(r"/\*.*?\*/", " ", sql, flags=re.DOTALL)
+        without_line_comments = re.sub(r"--.*?$", " ", without_block_comments, flags=re.MULTILINE)
+        return re.sub(r"\s+", " ", without_line_comments).strip()
+
+    @classmethod
+    def _relation_references(cls, sql: str) -> list[str]:
+        relations = [match.group(1) for match in cls.RELATION_PATTERN.finditer(sql)]
+        for clause_match in cls.FROM_CLAUSE_PATTERN.finditer(sql):
+            relations.extend(match.group(1) for match in cls.COMMA_RELATION_PATTERN.finditer(clause_match.group(1)))
+        return relations
+
+    @staticmethod
+    def _clean_identifier(identifier: str) -> str:
+        return re.sub(r'\s+', "", identifier.strip().rstrip(";")).replace('"', "").lower()
+
+    @staticmethod
+    def _strip_string_literals(sql: str) -> str:
+        return re.sub(r"'(?:''|[^'])*'", "''", sql)

package/templates/dataif/services/vanna/app/vanna_engine.py

@@ -0,0 +1,382 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, replace
+from pathlib import Path
+from threading import Lock
+from typing import TYPE_CHECKING, Any
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+if TYPE_CHECKING:
+    from .config import Settings
+    from sqlalchemy import Engine
+
+from .runtime_config import RuntimeVannaConfig, load_runtime_vanna_config
+
+
+@dataclass(frozen=True)
+class CuratedRelation:
+    schema_name: str
+    relation_name: str
+    relation_type: str
+    columns: tuple[tuple[str, str], ...]
+
+    @property
+    def full_name(self) -> str:
+        return f"{self.schema_name}.{self.relation_name}"
+
+
+class MaritacaChat:
+    def __init__(self, config: dict[str, Any] | None = None):
+        self.config = config or {}
+
+    def system_message(self, message: str) -> dict[str, str]:
+        return {"role": "system", "content": message}
+
+    def user_message(self, message: str) -> dict[str, str]:
+        return {"role": "user", "content": message}
+
+    def assistant_message(self, message: str) -> dict[str, str]:
+        return {"role": "assistant", "content": message}
+
+    def submit_prompt(self, prompt: Any, **_: Any) -> str:
+        api_key = str(self.config.get("maritaca_api_key") or "").strip()
+        if not api_key:
+            raise RuntimeError("VANNA_MARITACA_API_KEY is required for VANNA_LLM_PROVIDER=maritaca")
+
+        api_url = str(
+            self.config.get("maritaca_api_url") or "https://chat.maritaca.ai/api/chat/completions"
+        ).strip()
+        model = str(self.config.get("model") or "sabia-4").strip()
+        timeout = int(self.config.get("maritaca_timeout_seconds") or 60)
+        payload = json.dumps({"model": model, "messages": self._messages(prompt)}).encode("utf-8")
+        request = Request(
+            api_url,
+            data=payload,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            },
+            method="POST",
+        )
+
+        try:
+            with urlopen(request, timeout=timeout) as response:
+                raw = response.read()
+        except HTTPError as exc:
+            detail = exc.read().decode("utf-8", errors="replace")
+            raise RuntimeError(f"Maritaca API returned HTTP {exc.code}: {detail}") from exc
+        except (OSError, TimeoutError, URLError) as exc:
+            raise RuntimeError(f"Maritaca API request failed: {exc}") from exc
+
+        try:
+            data = json.loads(raw.decode("utf-8"))
+            return data["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, TypeError, json.JSONDecodeError) as exc:
+            raise RuntimeError("Maritaca API returned an invalid response") from exc
+
+    @staticmethod
+    def _messages(prompt: Any) -> list[dict[str, str]]:
+        if isinstance(prompt, list):
+            messages: list[dict[str, str]] = []
+            for item in prompt:
+                if isinstance(item, dict) and "role" in item and "content" in item:
+                    messages.append({"role": str(item["role"]), "content": str(item["content"])})
+                else:
+                    messages.append({"role": "user", "content": str(item)})
+            return messages or [{"role": "user", "content": ""}]
+        return [{"role": "user", "content": str(prompt)}]
+
+
+class DataifVannaEngine:
+    def __init__(self, settings: Settings, engine: Engine, allowed_schema: str) -> None:
+        self.settings = settings
+        self.engine = engine
+        self.allowed_schema = allowed_schema.strip().lower()
+        self._lock = Lock()
+        self._trained = False
+        self.vn: Any | None = None
+        self._vanna_class: type | None = None
+        self._runtime_config: RuntimeVannaConfig | None = None
+        self._config_signature: tuple[object, ...] | None = None
+        Path(settings.vanna_vectorstore_path).mkdir(parents=True, exist_ok=True)
+        self._ensure_runtime_config()
+
+    def _client(self) -> Any:
+        self._ensure_runtime_config()
+        if self.vn is not None:
+            return self.vn
+        if self._vanna_class is None or self._runtime_config is None:
+            raise RuntimeError("Vanna runtime configuration is unavailable")
+        self.vn = self._vanna_class(config=self._provider_config(self._runtime_config))
+        self.vn.run_sql = self._run_sql_dataframe
+        self.vn.run_sql_is_set = True
+        return self.vn
+
+    def generate_sql(self, question: str, runtime_override: dict[str, Any] | None = None) -> str:
+        runtime = self._runtime_from_override(runtime_override)
+        if not self._is_runtime_available(runtime):
+            raise RuntimeError(self._unavailable_message(runtime))
+        if runtime.auto_train:
+            self.train_once()
+        client = self._client() if runtime.signature() == self.runtime_config().signature() else self._client_for_runtime(runtime)
+        return client.generate_sql(question=question, allow_llm_to_see_data=False)
+
+    def is_llm_available(self) -> bool:
+        return bool(self.provider_status()["available"])
+
+    def provider_status(self) -> dict[str, object]:
+        runtime = self.runtime_config()
+        return self._provider_status(runtime)
+
+    def _provider_status(self, runtime: RuntimeVannaConfig) -> dict[str, object]:
+        provider = runtime.provider
+        if provider == "maritaca":
+            if runtime.maritaca_api_key.strip():
+                return {"available": True, "detail": "Maritaca API key configured"}
+            return {"available": False, "detail": "Maritaca API key is not configured"}
+
+        try:
+            with urlopen(f"{runtime.ollama_base_url.rstrip('/')}/api/tags", timeout=2) as response:
+                available = 200 <= response.status < 500
+                return {
+                    "available": available,
+                    "detail": f"Ollama responded at {runtime.ollama_base_url}" if available else "Ollama returned an error",
+                }
+        except (OSError, TimeoutError, URLError) as exc:
+            return {"available": False, "detail": f"Ollama is not reachable at {runtime.ollama_base_url}: {exc}"}
+
+    def _is_runtime_available(self, runtime: RuntimeVannaConfig) -> bool:
+        return bool(self._provider_status(runtime)["available"])
+
+    def train_once(self, force: bool = False) -> None:
+        with self._lock:
+            self._ensure_runtime_config()
+            if self._trained and not force:
+                return
+            vn = self._client()
+            for relation in self._load_allowed_relations():
+                vn.train(ddl=self._build_ddl(relation))
+            for item in self._load_catalog_documentation():
+                vn.train(documentation=item)
+            for query in self._approved_examples():
+                vn.train(sql=query)
+            self._trained = True
+
+    def _run_sql_dataframe(self, sql: str) -> Any:
+        import pandas as pd
+        from sqlalchemy import text
+
+        with self.engine.begin() as conn:
+            return pd.read_sql_query(sql=text(sql), con=conn)
+
+    def _load_allowed_relations(self) -> list[CuratedRelation]:
+        from sqlalchemy import text
+
+        with self.engine.begin() as conn:
+            rows = conn.execute(
+                text(
+                    """
+                    SELECT
+                        c.table_schema,
+                        c.table_name,
+                        c.column_name,
+                        c.data_type,
+                        COALESCE(
+                            t.table_type,
+                            CASE WHEN mv.matviewname IS NOT NULL THEN 'MATERIALIZED VIEW' ELSE 'RELATION' END
+                        ) AS relation_type
+                    FROM information_schema.columns c
+                    LEFT JOIN information_schema.tables t
+                      ON t.table_schema = c.table_schema
+                     AND t.table_name = c.table_name
+                    LEFT JOIN pg_catalog.pg_matviews mv
+                      ON mv.schemaname = c.table_schema
+                     AND mv.matviewname = c.table_name
+                    WHERE c.table_schema = :allowed_schema
+                    ORDER BY table_schema, table_name, ordinal_position
+                    """
+                ),
+                {"allowed_schema": self.allowed_schema},
+            ).mappings()
+            grouped: dict[tuple[str, str, str], list[tuple[str, str]]] = {}
+            for row in rows:
+                key = (row["table_schema"], row["table_name"], row["relation_type"])
+                grouped.setdefault(key, []).append((row["column_name"], row["data_type"]))
+
+        return [
+            CuratedRelation(
+                schema_name=schema,
+                relation_name=name,
+                relation_type=relation_type,
+                columns=tuple(columns),
+            )
+            for (schema, name, relation_type), columns in grouped.items()
+        ]
+
+    def _load_catalog_documentation(self) -> list[str]:
+        from sqlalchemy import text
+
+        catalog_name = f"{self.allowed_schema}.vw_pnp_vanna_catalogo"
+        schema_sql = self._quote_identifier(self.allowed_schema)
+        with self.engine.begin() as conn:
+            exists = conn.execute(
+                text("SELECT to_regclass(:catalog_name)"),
+                {"catalog_name": catalog_name},
+            ).scalar()
+            if not exists:
+                return []
+
+            rows = conn.execute(
+                text(
+                    f"""
+                    SELECT relation_group, relation_name, relation_description
+                    FROM {schema_sql}.vw_pnp_vanna_catalogo
+                    ORDER BY relation_group, relation_name
+                    """
+                )
+            ).mappings()
+            return [
+                (
+                    f"Relacao {self.allowed_schema}.{row['relation_name']} pertence ao dominio "
+                    f"{row['relation_group']}: {row['relation_description']}"
+                )
+                for row in rows
+            ]
+
+    def _build_vanna_class(self, provider: str | None = None) -> type:
+        from vanna.chromadb import ChromaDB_VectorStore
+
+        provider = provider or self.runtime_config().provider
+        if provider == "ollama":
+            from vanna.ollama import Ollama
+
+            class OllamaVanna(ChromaDB_VectorStore, Ollama):
+                def __init__(self, config=None):
+                    ChromaDB_VectorStore.__init__(self, config=config)
+                    Ollama.__init__(self, config=config)
+
+            return OllamaVanna
+
+        if provider == "maritaca":
+            class MaritacaVanna(MaritacaChat, ChromaDB_VectorStore):
+                def __init__(self, config=None):
+                    ChromaDB_VectorStore.__init__(self, config=config)
+                    MaritacaChat.__init__(self, config=config)
+
+            return MaritacaVanna
+
+        raise RuntimeError(f"Unsupported VANNA_LLM_PROVIDER: {self.settings.vanna_llm_provider}")
+
+    def _provider_config(self, runtime: RuntimeVannaConfig | None = None) -> dict[str, Any]:
+        runtime = runtime or self.runtime_config()
+        config: dict[str, Any] = {
+            "model": runtime.model_name(),
+            "path": runtime.vectorstore_path,
+        }
+        provider = runtime.provider
+        if provider == "ollama":
+            config["ollama_host"] = runtime.ollama_base_url
+        elif provider == "maritaca":
+            config["maritaca_api_url"] = runtime.maritaca_api_url
+            config["maritaca_api_key"] = runtime.maritaca_api_key
+            config["maritaca_timeout_seconds"] = runtime.maritaca_timeout_seconds
+        return config
+
+    def _client_for_runtime(self, runtime: RuntimeVannaConfig) -> Any:
+        client_class = self._build_vanna_class(runtime.provider)
+        client = client_class(config=self._provider_config(runtime))
+        client.run_sql = self._run_sql_dataframe
+        client.run_sql_is_set = True
+        return client
+
+    def _runtime_from_override(self, override: dict[str, Any] | None) -> RuntimeVannaConfig:
+        runtime = self.runtime_config()
+        if not override:
+            return runtime
+
+        provider = str(override.get("provider") or runtime.provider).strip().lower() or runtime.provider
+        ollama = override.get("ollama") if isinstance(override.get("ollama"), dict) else {}
+        maritaca = override.get("maritaca") if isinstance(override.get("maritaca"), dict) else {}
+        return replace(
+            runtime,
+            provider=provider,
+            ollama_base_url=str(ollama.get("base_url") or runtime.ollama_base_url).strip() or runtime.ollama_base_url,
+            ollama_model=str(ollama.get("model") or runtime.ollama_model).strip() or runtime.ollama_model,
+            maritaca_api_url=str(maritaca.get("api_url") or runtime.maritaca_api_url).strip() or runtime.maritaca_api_url,
+            maritaca_api_key=str(maritaca.get("api_key") or runtime.maritaca_api_key),
+            maritaca_model=str(maritaca.get("model") or runtime.maritaca_model).strip() or runtime.maritaca_model,
+            maritaca_timeout_seconds=_coerce_positive_int(
+                maritaca.get("timeout_seconds"),
+                runtime.maritaca_timeout_seconds,
+            ),
+        )
+
+    def _unavailable_message(self, runtime: RuntimeVannaConfig | None = None) -> str:
+        runtime = runtime or self.runtime_config()
+        provider = runtime.provider
+        if provider == "maritaca":
+            return "Maritaca API key is not configured"
+        return f"Ollama is not reachable at {runtime.ollama_base_url}"
+
+    def runtime_config(self) -> RuntimeVannaConfig:
+        self._ensure_runtime_config()
+        if self._runtime_config is None:
+            raise RuntimeError("Vanna runtime configuration is unavailable")
+        return self._runtime_config
+
+    def _ensure_runtime_config(self) -> None:
+        runtime = load_runtime_vanna_config(self.settings, self.engine)
+        signature = runtime.signature()
+        if self._config_signature == signature:
+            return
+
+        Path(runtime.vectorstore_path).mkdir(parents=True, exist_ok=True)
+        self._runtime_config = runtime
+        self._config_signature = signature
+        self._vanna_class = self._build_vanna_class(runtime.provider)
+        self.vn = None
+        self._trained = False
+
+    @staticmethod
+    def _quote_identifier(identifier: str) -> str:
+        if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", identifier):
+            raise ValueError(f"Invalid SQL identifier: {identifier}")
+        return f'"{identifier}"'
+
+    @staticmethod
+    def _build_ddl(relation: CuratedRelation) -> str:
+        columns = ",\n  ".join(f"{name} {data_type}" for name, data_type in relation.columns)
+        return f"-- RELATION TYPE: {relation.relation_type}\nCREATE TABLE {relation.full_name} (\n  {columns}\n);"
+
+    def _approved_examples(self) -> list[str]:
+        if self.allowed_schema != "curated":
+            return []
+        return [
+            (
+                "SELECT dominio, indicador, ano, SUM(valor) AS total "
+                "FROM curated.vw_pnp_vanna_resumo "
+                "GROUP BY dominio, indicador, ano "
+                "ORDER BY ano DESC, dominio, indicador LIMIT 50"
+            ),
+            (
+                "SELECT relation_group, relation_name, relation_description "
+                "FROM curated.vw_pnp_vanna_catalogo "
+                "ORDER BY relation_group, relation_name LIMIT 50"
+            ),
+            (
+                "SELECT instituicao, ano, SUM(valor) AS total_matriculas "
+                "FROM curated.vw_pnp_vanna_resumo "
+                "WHERE dominio = 'matriculas' "
+                "GROUP BY instituicao, ano "
+                "ORDER BY ano DESC, total_matriculas DESC LIMIT 50"
+            ),
+            (
+                "SELECT ano, SUM(matriculas) AS total_matriculas "
+                "FROM curated.mv_pnp_dashboard_matriculas "
+                "GROUP BY ano ORDER BY ano DESC LIMIT 50"
+            ),
+        ]

package/templates/dataif/services/vanna/requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.115.6
+uvicorn[standard]==0.32.1
+SQLAlchemy==2.0.36
+psycopg2-binary==2.9.9
+pydantic==2.10.4
+pydantic-settings==2.7.0
+pandas==2.2.3
+vanna[chromadb,ollama]==0.7.9

package/templates/dataif/services/web/.dockerignore

@@ -0,0 +1,13 @@
+.env
+node_modules/
+dist/
+coverage/
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+*.log
+
+.DS_Store
+tmp/
+temp/

package/templates/dataif/services/web/Dockerfile

@@ -0,0 +1,16 @@
+FROM node:20-alpine AS builder
+
+ARG VITE_API_BASE_URL=
+ENV VITE_API_BASE_URL=$VITE_API_BASE_URL
+
+WORKDIR /app
+COPY package.json package-lock.json* ./
+RUN npm install
+COPY . .
+RUN npm run build
+
+FROM nginx:1.27-alpine
+COPY nginx.conf /etc/nginx/nginx.conf
+COPY --from=builder /app/dist /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]

package/templates/dataif/services/web/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="pt-BR">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>dataif</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>