iatoolkit 2.29.1__tar.gz → 2.31.0__tar.gz

{iatoolkit-2.29.1/src/iatoolkit.egg-info → iatoolkit-2.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.29.1
+Version: 2.31.0
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT

{iatoolkit-2.29.1 → iatoolkit-2.31.0}/src/iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "2.29.1"
+__version__ = "2.31.0"
 
 # Expose main classes and functions at the top level of the package
 

{iatoolkit-2.29.1 → iatoolkit-2.31.0}/src/iatoolkit/core.py

@@ -115,6 +115,7 @@ class IAToolkit:
         self._setup_request_globals()
         self._setup_context_processors()
         self._sync_system_tools_on_boot()
+        self._run_configured_startup_warmup()
 
         # register data sources
         if start:
@@ -149,6 +150,19 @@ class IAToolkit:
         except Exception as exc:
             logging.warning("⚠️ Unable to sync system tools on boot: %s", exc)
 
+    def _run_configured_startup_warmup(self):
+        from iatoolkit.services.warmup_service import WarmupService
+
+        try:
+            warmup_service = self._injector.get(WarmupService)
+            warmed_companies = warmup_service.warmup_startup_configured_companies(trigger="core_startup")
+            if warmed_companies:
+                logging.info("🔥 Startup warm-up completed for companies=%s", warmed_companies)
+            else:
+                logging.info("🔥 Startup warm-up skipped: no embedding provider enabled warmup_on_startup.")
+        except Exception:
+            logging.exception("⚠️ Startup warm-up failed.")
+
     def _get_config_value(self, key: str, default=None):
         # get a value from the config dict or the environment variable
         return self.config.get(key, os.getenv(key, default))

{iatoolkit-2.29.1 → iatoolkit-2.31.0}/src/iatoolkit/repositories/vs_repo.py

@@ -7,6 +7,7 @@ import ast
 import json
 import logging
 import re
+from time import perf_counter
 from typing import Dict, List
 
 from sqlalchemy import text
@@ -86,6 +87,7 @@ class VSRepo:
               n_results=5,
               metadata_filter=None,
               collection_ids: List[int] | None = None,
+              include_urls: bool = True,
               ) -> list[Dict]:
         """
         search documents similar to the query for a company
@@ -95,40 +97,75 @@ class VSRepo:
             query_text: query text
             n_results: max number of results to return
             metadata_filter:  (e.g., {"document_type": "certificate"})
+            include_urls: Generate storage URLs for returned chunks when true.
 
         Returns:
             list of documents matching the query and filters
         """
+        query_started_at = perf_counter()
+        embedding_started_at = perf_counter()
         # Generate the embedding with the query text for the specific company
         try:
             query_embedding = self.embedding_service.embed_text(company_short_name, query_text)
         except Exception as e:
-            logging.error(f"error while creating text embedding: {str(e)}")
+            logging.error(
+                "RAG vector query embedding failed: company=%s duration_ms=%s error=%s",
+                company_short_name,
+                round((perf_counter() - embedding_started_at) * 1000),
+                str(e),
+            )
             raise IAToolkitException(IAToolkitException.ErrorType.EMBEDDING_ERROR,
                                f"embedding error: {str(e)}")
+        embedding_duration_ms = round((perf_counter() - embedding_started_at) * 1000)
+        try:
+            embedding_dimensions = len(query_embedding)
+        except TypeError as exc:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.EMBEDDING_ERROR,
+                "embedding error: query embedding has no dimensions",
+            ) from exc
+        if embedding_dimensions < 1 or embedding_dimensions > 2000:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.EMBEDDING_ERROR,
+                f"embedding error: unsupported query embedding dimensions ({embedding_dimensions})",
+            )
 
         sql_query, params = None, None
         try:
             # Get company ID from its short name for the SQL query
+            company_lookup_started_at = perf_counter()
             company = self.session.query(Company).filter(Company.short_name == company_short_name).one_or_none()
+            company_lookup_duration_ms = round((perf_counter() - company_lookup_started_at) * 1000)
             if not company:
                 raise IAToolkitException(IAToolkitException.ErrorType.VECTOR_STORE_ERROR,
                                    f"Company with short name '{company_short_name}' not found.")
 
+            distance_metric = "l2"
+            distance_expression = (
+                f"iat_vsdocs.embedding::vector({embedding_dimensions}) "
+                f"<-> CAST(:query_embedding AS vector({embedding_dimensions}))"
+            )
+
             # build the SQL query
-            sql_query_parts = ["""
+            sql_query_parts = [f"""
                                SELECT iat_vsdocs.id, \
                                       iat_documents.filename, \
                                       iat_vsdocs.text, \
                                       iat_documents.storage_key, \
                                       iat_documents.meta,
                                       iat_documents.id, \
-                                      iat_vsdocs.meta
+                                      iat_vsdocs.meta,
+                                      ({distance_expression}) AS distance
                                FROM iat_vsdocs, \
                                     iat_documents
                                WHERE iat_vsdocs.company_id = :company_id
                                  AND iat_vsdocs.document_id = iat_documents.id \
                                """]
+            # The literal dimension lets PostgreSQL prove that a matching partial
+            # pgvector expression index can satisfy the nearest-neighbor order.
+            sql_query_parts.append(
+                f" AND vector_dims(iat_vsdocs.embedding) = {embedding_dimensions}"
+            )
 
             # query parameters
             params = {
@@ -166,15 +203,18 @@ class VSRepo:
             sql_query = "".join(sql_query_parts)
 
             # add sorting and limit of results
-            sql_query += " ORDER BY embedding <-> CAST(:query_embedding AS VECTOR) LIMIT :n_results"
+            sql_query += " ORDER BY distance ASC LIMIT :n_results"
 
             logging.debug(f"Executing SQL query: {sql_query}")
             logging.debug(f"With parameters: {params}")
 
             # execute the query
+            vector_sql_started_at = perf_counter()
+            self.session.execute(text("SET LOCAL hnsw.iterative_scan = strict_order"))
+            self.session.execute(text("SET LOCAL hnsw.ef_search = 100"))
             result = self.session.execute(text(sql_query), params)
-
             rows = result.fetchall()
+            vector_sql_duration_ms = round((perf_counter() - vector_sql_started_at) * 1000)
             vs_documents = []
 
             for row in rows:
@@ -182,10 +222,12 @@ class VSRepo:
                 doc_meta = row[4] if len(row) > 4 and row[4] is not None else {}
                 chunk_meta = row[6] if len(row) > 6 and row[6] is not None else {}
 
+                distance = float(row[7]) if len(row) > 7 and row[7] is not None else None
+
                 # get the url of the document
                 storage_key = row[3] if len(row) > 3 and row[3] is not None else None
                 url = None
-                if storage_key:
+                if include_urls and storage_key:
                     url = self.storage_service.generate_presigned_url(company_short_name, storage_key)
 
                 vs_documents.append(
@@ -196,10 +238,26 @@ class VSRepo:
                         'text': row[2],
                         'meta': doc_meta,
                         'chunk_meta': chunk_meta,
-                        'url': url
+                        'url': url,
+                        'distance': distance,
+                        'distance_metric': distance_metric,
+                        'score': self._score_from_l2_distance(distance),
                     }
                 )
 
+            logging.info(
+                "RAG vector query completed: company=%s collection_ids=%s dimensions=%s n_results=%s rows=%s "
+                "embedding_ms=%s company_lookup_ms=%s vector_sql_ms=%s total_ms=%s",
+                company_short_name,
+                normalized_collection_ids,
+                embedding_dimensions,
+                n_results,
+                len(rows),
+                embedding_duration_ms,
+                company_lookup_duration_ms,
+                vector_sql_duration_ms,
+                round((perf_counter() - query_started_at) * 1000),
+            )
             return vs_documents
 
         except Exception as e:
@@ -386,6 +444,12 @@ class VSRepo:
 
         return sql_parts, params
 
+    @staticmethod
+    def _score_from_l2_distance(distance: float | None) -> float | None:
+        if distance is None:
+            return None
+        return 1 / (1 + distance)
+
     @staticmethod
     def _normalize_metadata_filter_input(metadata_filter):
         if metadata_filter is None:

{iatoolkit-2.29.1 → iatoolkit-2.31.0}/src/iatoolkit/services/configuration_service.py

@@ -717,6 +717,23 @@ class ConfigurationService:
                 add_error("embedding_provider", "Missing required key: 'provider'")
             if not config.get("embedding_provider", {}).get("model"):
                 add_error("embedding_provider", "Missing required key: 'model'")
+            if (
+                    "warmup_on_startup" in config.get("embedding_provider", {})
+                    and not isinstance(config.get("embedding_provider", {}).get("warmup_on_startup"), bool)
+            ):
+                add_error("embedding_provider.warmup_on_startup", "Must be a boolean.")
+
+        embedding_providers_cfg = config.get("embedding_providers")
+        if embedding_providers_cfg is not None:
+            if not isinstance(embedding_providers_cfg, dict):
+                add_error("embedding_providers", "Section must be a dictionary.")
+            else:
+                for provider_key, provider_cfg in embedding_providers_cfg.items():
+                    if not isinstance(provider_cfg, dict):
+                        add_error(f"embedding_providers.{provider_key}", "Provider configuration must be a dictionary.")
+                        continue
+                    if "warmup_on_startup" in provider_cfg and not isinstance(provider_cfg.get("warmup_on_startup"), bool):
+                        add_error(f"embedding_providers.{provider_key}.warmup_on_startup", "Must be a boolean.")
 
         # 3b. Visual Embedding Provider (Optional)
         if config.get("visual_embedding_provider"):

{iatoolkit-2.29.1 → iatoolkit-2.31.0}/src/iatoolkit/services/inference_service.py

@@ -310,16 +310,47 @@ class InferenceService:
             attempt: int,
             delay_seconds: float,
             reason: str,
+            attempt_duration_seconds: float | None = None,
+            elapsed_seconds: float | None = None,
             suppress_error_logging: bool = False
     ) -> None:
         log_fn = logging.debug if suppress_error_logging else logging.warning
+        if attempt_duration_seconds is None or elapsed_seconds is None:
+            log_fn(
+                "Inference request retry %s scheduled in %.1fs: %s",
+                attempt,
+                delay_seconds,
+                reason,
+            )
+            return
+
         log_fn(
-            "Inference request retry %s scheduled in %.1fs: %s",
+            "Inference request retry %s scheduled in %.1fs after %.1fs attempt (elapsed %.1fs): %s",
             attempt,
             delay_seconds,
+            attempt_duration_seconds,
+            elapsed_seconds,
             reason,
         )
 
+    def _timeout_for_attempt(
+            self,
+            *,
+            timeout: tuple[float, float],
+            deadline: float | None,
+            attempt: int,
+    ) -> tuple[float, float] | None:
+        if deadline is None or attempt == 1:
+            return timeout
+
+        remaining_seconds = deadline - time.monotonic()
+        if remaining_seconds <= 0:
+            return None
+
+        connect_timeout, read_timeout = timeout
+        bounded_timeout = max(0.1, remaining_seconds)
+        return min(connect_timeout, bounded_timeout), min(read_timeout, bounded_timeout)
+
     def _call_endpoint(
             self,
             url: str,
@@ -334,28 +365,44 @@ class InferenceService:
             "Authorization": f"Bearer {api_key}",
             "Content-Type": "application/json",
         }
-        deadline = time.monotonic() + retry_budget_seconds if retry_budget_seconds > 0 else None
+        started_at = time.monotonic()
+        deadline = started_at + retry_budget_seconds if retry_budget_seconds > 0 else None
         attempt = 1
         delay_seconds = self.DEFAULT_RETRY_INITIAL_DELAY_SECONDS
 
         while True:
+            attempt_timeout = self._timeout_for_attempt(timeout=timeout, deadline=deadline, attempt=attempt)
+            if attempt_timeout is None:
+                error_msg = "Inference retry budget exhausted before next attempt."
+                if not suppress_error_logging:
+                    logging.error(error_msg)
+                raise ValueError(error_msg)
+
+            attempt_started_at = time.monotonic()
             try:
                 resp, status = self.call_service.post(
                     url,
                     json_dict=payload,
                     headers=headers,
-                    timeout=timeout
+                    timeout=attempt_timeout
                 )
             except Exception as exc:
+                attempt_duration = time.monotonic() - attempt_started_at
                 next_delay = self._next_retry_delay(delay_seconds=delay_seconds, deadline=deadline)
                 if self._is_retryable_request_exception(exc) and next_delay is not None:
                     self._log_retry_attempt(
                         attempt=attempt,
                         delay_seconds=next_delay,
                         reason=str(exc),
+                        attempt_duration_seconds=attempt_duration,
+                        elapsed_seconds=time.monotonic() - started_at,
                         suppress_error_logging=suppress_error_logging,
                     )
                     time.sleep(next_delay)
+                    if deadline is not None and time.monotonic() >= deadline:
+                        if not suppress_error_logging:
+                            logging.error(f"Failed to call inference endpoint: {exc}")
+                        raise
                     attempt += 1
                     delay_seconds = min(delay_seconds * 2, self.DEFAULT_RETRY_MAX_DELAY_SECONDS)
                     continue
@@ -367,6 +414,7 @@ class InferenceService:
             if status == 200:
                 return resp
 
+            attempt_duration = time.monotonic() - attempt_started_at
             error_msg = f"Inference Endpoint Error {status}"
             if isinstance(resp, dict) and 'error' in resp:
                 error_msg += f": {resp['error']}"
@@ -377,9 +425,16 @@ class InferenceService:
                     attempt=attempt,
                     delay_seconds=next_delay,
                     reason=error_msg,
+                    attempt_duration_seconds=attempt_duration,
+                    elapsed_seconds=time.monotonic() - started_at,
                     suppress_error_logging=suppress_error_logging,
                 )
                 time.sleep(next_delay)
+                if deadline is not None and time.monotonic() >= deadline:
+                    if not suppress_error_logging:
+                        logging.error(f"{error_msg} | Payload keys: {list(payload.keys())}")
+                        logging.error(f"Failed to call inference endpoint: {error_msg}")
+                    raise ValueError(error_msg)
                 attempt += 1
                 delay_seconds = min(delay_seconds * 2, self.DEFAULT_RETRY_MAX_DELAY_SECONDS)
                 continue

{iatoolkit-2.29.1 → iatoolkit-2.31.0}/src/iatoolkit/services/knowledge_base_service.py

@@ -488,7 +488,8 @@ class KnowledgeBaseService:
                query: str,
                n_results: int = 5,
                collection: str | list[str] | None = None,
-               metadata_filter: dict = None
+               metadata_filter: dict = None,
+               include_urls: bool = True,
                ):
         """
         Performs a semantic search and returns the list of Document objects (chunks).
@@ -500,6 +501,7 @@ class KnowledgeBaseService:
             n_results: Max number of chunks to retrieve.
             metadata_filter: Optional filter for document metadata.
             collection: Optional collection name or list of collection names.
+            include_urls: Generate storage URLs for returned chunks when true.
 
         Returns:
             List of Document objects found.
@@ -532,6 +534,7 @@ class KnowledgeBaseService:
             n_results=n_results,
             metadata_filter=metadata_filter,
             collection_ids=collection_ids,
+            include_urls=include_urls,
         )
 
         return chunk_list

{iatoolkit-2.29.1 → iatoolkit-2.31.0}/src/iatoolkit/services/tool_service.py

@@ -374,6 +374,9 @@ class ToolService:
                 "page": page,
                 "caption_text": caption,
                 "document_id": item.get("document_id"),
+                "distance": item.get("distance"),
+                "distance_metric": item.get("distance_metric"),
+                "score": item.get("score"),
             }
             lines.append(json.dumps(header, ensure_ascii=False))
             text_content = (item.get("text") or "").strip()

iatoolkit-2.31.0/src/iatoolkit/services/warmup_service.py

@@ -0,0 +1,234 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from __future__ import annotations
+
+import logging
+import time
+from injector import inject
+
+from iatoolkit.common.interfaces.secret_provider import SecretProvider
+from iatoolkit.common.secret_resolver import resolve_secret
+from iatoolkit.company_registry import get_registered_companies
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.embedding_service import EmbeddingService
+
+
+class WarmupService:
+    """
+    Lightweight warm-up orchestrator.
+    Keep it simple: no shared state, no locking, no dedup.
+    """
+
+    @inject
+    def __init__(self,
+                 config_service: ConfigurationService,
+                 embedding_service: EmbeddingService,
+                 secret_provider: SecretProvider):
+        self.config_service = config_service
+        self.embedding_service = embedding_service
+        self.secret_provider = secret_provider
+
+    def warmup_company(self, company_short_name: str, trigger: str = "manual"):
+        start = time.perf_counter()
+        try:
+            self._warmup_remote_text_embeddings(company_short_name)
+            elapsed_ms = (time.perf_counter() - start) * 1000
+            logging.info(
+                "🔥 Warm-up done for company='%s' trigger='%s' in %.2f ms",
+                company_short_name,
+                trigger,
+                elapsed_ms
+            )
+        except Exception as e:
+            elapsed_ms = (time.perf_counter() - start) * 1000
+            logging.debug(
+                "⚠️ Warm-up failed for company='%s' trigger='%s' in %.2f ms: %s",
+                company_short_name,
+                trigger,
+                elapsed_ms,
+                e
+            )
+
+    def warmup_registered_companies(self, trigger: str = "manual"):
+        for company_short_name in get_registered_companies().keys():
+            self.warmup_company(company_short_name, trigger=trigger)
+
+    def warmup_startup_configured_companies(self, trigger: str = "startup") -> list[str]:
+        warmed_companies: list[str] = []
+        for company_short_name in get_registered_companies().keys():
+            profiles = self._get_remote_text_embedding_profiles(company_short_name, startup_only=True)
+            if not profiles:
+                logging.info(
+                    "Startup warm-up skipped for company='%s': no embedding provider enabled warmup_on_startup.",
+                    company_short_name,
+                )
+                continue
+
+            logging.info(
+                "Startup warm-up starting for company='%s' profiles=%s trigger='%s'.",
+                company_short_name,
+                self._format_profile_labels(profiles),
+                trigger,
+            )
+            warmed_profiles = self._warmup_remote_text_embeddings(
+                company_short_name,
+                startup_only=True,
+                profiles=profiles,
+            )
+            if not warmed_profiles:
+                logging.warning(
+                    "Startup warm-up attempted but no embedding profiles warmed for company='%s' profiles=%s.",
+                    company_short_name,
+                    self._format_profile_labels(profiles),
+                )
+                continue
+
+            logging.info(
+                "Startup warm-up warmed company='%s' profiles=%s.",
+                company_short_name,
+                self._format_profile_labels(warmed_profiles),
+            )
+            warmed_companies.append(company_short_name)
+
+        return warmed_companies
+
+    def is_startup_warmup_enabled(self, company_short_name: str) -> bool:
+        return bool(self._get_remote_text_embedding_profiles(company_short_name, startup_only=True))
+
+    def _warmup_remote_text_embeddings(
+            self,
+            company_short_name: str,
+            startup_only: bool = False,
+            profiles: list[tuple[str, str, str]] | None = None,
+    ) -> list[tuple[str, str, str]]:
+        if profiles is None:
+            profiles = self._get_remote_text_embedding_profiles(company_short_name, startup_only=startup_only)
+        if not profiles:
+            logging.debug(
+                "Warm-up skipped for company='%s': no remote embedding inference configured.",
+                company_short_name
+            )
+            return []
+
+        warmed_profiles = []
+        for model_type, config_section, tool_name in profiles:
+            try:
+                # Prime the remote model/container and download/cache model weights.
+                self.embedding_service.embed_text(
+                    company_short_name,
+                    "hello",
+                    model_type=model_type,
+                    suppress_error_logging=True,
+                )
+                logging.debug(
+                    "Warm-up primed remote embedding profile company='%s' section='%s' model_type='%s' tool='%s'.",
+                    company_short_name,
+                    config_section,
+                    model_type,
+                    tool_name,
+                )
+                warmed_profiles.append((model_type, config_section, tool_name))
+            except Exception as e:
+                log_fn = logging.warning if startup_only else logging.debug
+                log_fn(
+                    "Warm-up failed for remote embedding profile company='%s' section='%s' model_type='%s' tool='%s': %s",
+                    company_short_name,
+                    config_section,
+                    model_type,
+                    tool_name,
+                    e,
+                )
+
+        return warmed_profiles
+
+    @staticmethod
+    def _format_profile_labels(profiles: list[tuple[str, str, str]]) -> list[str]:
+        return [
+            f"{config_section}:{model_type}:{tool_name}"
+            for model_type, config_section, tool_name in profiles
+        ]
+
+    def _uses_remote_text_inference(self, company_short_name: str) -> bool:
+        return bool(self._get_remote_text_embedding_profiles(company_short_name))
+
+    def _get_remote_text_embedding_profiles(
+            self,
+            company_short_name: str,
+            startup_only: bool = False,
+    ) -> list[tuple[str, str, str]]:
+        profiles: list[tuple[str, str, str, dict]] = []
+
+        embedding_cfg = self.config_service.get_configuration(company_short_name, "embedding_provider") or {}
+        if isinstance(embedding_cfg, dict):
+            profiles.append(("text", "embedding_provider", embedding_cfg.get("tool_name") or "text_embeddings", embedding_cfg))
+
+        embedding_providers = self.config_service.get_configuration(company_short_name, "embedding_providers") or {}
+        if isinstance(embedding_providers, dict):
+            for model_type, embedding_provider_cfg in embedding_providers.items():
+                if not isinstance(embedding_provider_cfg, dict):
+                    continue
+                normalized_model_type = str(model_type or "").strip()
+                if not normalized_model_type:
+                    continue
+                profiles.append((
+                    normalized_model_type,
+                    f"embedding_providers.{normalized_model_type}",
+                    embedding_provider_cfg.get("tool_name") or normalized_model_type,
+                    embedding_provider_cfg,
+                ))
+
+        inference_tools = self.config_service.get_configuration(company_short_name, "inference_tools") or {}
+        if not isinstance(inference_tools, dict):
+            return []
+
+        remote_profiles = [
+            (model_type, config_section, str(tool_name or "").strip())
+            for model_type, config_section, tool_name, embedding_cfg in profiles
+            if self._is_remote_embedding_profile(company_short_name, embedding_cfg, inference_tools, str(tool_name or "").strip())
+            and (not startup_only or bool(embedding_cfg.get("warmup_on_startup")))
+        ]
+
+        # Leave the default text profile warm last. It is the profile used by rag_search.
+        return sorted(remote_profiles, key=lambda item: 1 if item[0] == "text" else 0)
+
+    def _is_remote_embedding_profile(
+            self,
+            company_short_name: str,
+            embedding_cfg: dict,
+            inference_tools: dict,
+            tool_name: str,
+    ) -> bool:
+        provider = (embedding_cfg.get("provider") or "").strip().lower()
+        if provider != "huggingface":
+            return False
+
+        if not tool_name:
+            return False
+
+        defaults = inference_tools.get("_defaults") or {}
+        if not isinstance(defaults, dict):
+            defaults = {}
+
+        tool_cfg = inference_tools.get(tool_name) or {}
+        if not isinstance(tool_cfg, dict):
+            return False
+
+        resolved_cfg = {**defaults, **tool_cfg}
+        endpoint_url = (resolved_cfg.get("endpoint_url") or "").strip()
+        if not endpoint_url:
+            endpoint_url_secret_ref = (resolved_cfg.get("endpoint_url_secret_ref") or "").strip()
+            if endpoint_url_secret_ref:
+                endpoint_url = (
+                    resolve_secret(self.secret_provider, company_short_name, endpoint_url_secret_ref, default="") or ""
+                ).strip()
+        if not endpoint_url:
+            endpoint_url_env = (resolved_cfg.get("endpoint_url_env") or "").strip()
+            if endpoint_url_env:
+                endpoint_url = (
+                    resolve_secret(self.secret_provider, company_short_name, endpoint_url_env, default="") or ""
+                ).strip()
+
+        return bool(endpoint_url)

{iatoolkit-2.29.1 → iatoolkit-2.31.0}/src/iatoolkit/views/rag_api_view.py

@@ -499,6 +499,9 @@ class RagApiView(MethodView):
                 "text": item.get("text"),
                 "chunk_meta": item.get("chunk_meta") or {},
                 "document_meta": item.get("meta") or {},
+                "distance": item.get("distance"),
+                "distance_metric": item.get("distance_metric"),
+                "score": item.get("score"),
             })
         return normalized
 
@@ -537,6 +540,9 @@ class RagApiView(MethodView):
                 "chunk_id": item.get("chunk_id"),
                 "source_type": (item.get("chunk_meta") or {}).get("source_type"),
                 "page": (item.get("chunk_meta") or {}).get("page") or (item.get("chunk_meta") or {}).get("page_start"),
+                "distance": item.get("distance"),
+                "distance_metric": item.get("distance_metric"),
+                "score": item.get("score"),
             }
             lines.append(json.dumps(header, ensure_ascii=False))
             if item.get("text"):

{iatoolkit-2.29.1 → iatoolkit-2.31.0/src/iatoolkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.29.1
+Version: 2.31.0
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT