symbolicai 1.2.1__py3-none-any.whl → 1.4.0__py3-none-any.whl

symai/__init__.py

@@ -33,7 +33,7 @@ os.environ["TOKENIZERS_PARALLELISM"] = "false"
 # Create singleton instance
 config_manager = settings.SymAIConfig()
 
-SYMAI_VERSION = "1.2.1"
+SYMAI_VERSION = "1.4.0"
 __version__ = SYMAI_VERSION
 __root_dir__ = config_manager.config_dir
 

symai/backend/engines/index/engine_qdrant.py

@@ -4,8 +4,10 @@ import tempfile
 import urllib.request
 import uuid
 import warnings
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
+from urllib.parse import urlparse
 
 import numpy as np
 
@@ -148,6 +150,108 @@ Matches:
         return f"<ul>{doc_str}</ul>"
 
 
+@dataclass
+class Citation:
+    id: int
+    title: str
+    url: str
+    start: int
+    end: int
+
+    def __hash__(self):
+        return hash((self.url,))
+
+
+class SearchResult(Result):
+    def __init__(self, value: dict[str, Any] | Any, **kwargs) -> None:
+        super().__init__(value, **kwargs)
+        if isinstance(value, dict) and value.get("error"):
+            UserMessage(value["error"], raise_with=ValueError)
+        results = self._coerce_results(value)
+        text, citations = self._build_text_and_citations(results)
+        self._value = text
+        self._citations = citations
+
+    def _coerce_results(self, raw: Any) -> list[dict[str, Any]]:
+        if raw is None:
+            return []
+        results = raw.get("results", []) if isinstance(raw, dict) else getattr(raw, "results", None)
+        if not results:
+            return []
+        return [item for item in results if isinstance(item, dict)]
+
+    def _source_identifier(self, item: dict[str, Any], url: str) -> str:
+        for key in ("source_id", "sourceId", "sourceID", "id"):
+            raw = item.get(key)
+            if raw is None:
+                continue
+            text = str(raw).strip()
+            if text:
+                return text
+        path = Path(urlparse(url).path)
+        return path.name or path.as_posix() or url
+
+    def _build_text_and_citations(self, results: list[dict[str, Any]]):
+        pieces = []
+        citations = []
+        cursor = 0
+        cid = 1
+        separator = "\n\n---\n\n"
+
+        for item in results:
+            url = str(item.get("url") or "")
+            if not url:
+                continue
+
+            title = str(item.get("title") or "")
+            if not title:
+                path = Path(urlparse(url).path)
+                title = path.name or url
+
+            excerpts = item.get("excerpts") or []
+            excerpt_parts = [ex.strip() for ex in excerpts if isinstance(ex, str) and ex.strip()]
+            if not excerpt_parts:
+                continue
+
+            combined_excerpt = "\n\n".join(excerpt_parts)
+            source_id = self._source_identifier(item, url)
+            block_body = combined_excerpt if not source_id else f"{source_id}\n\n{combined_excerpt}"
+
+            if pieces:
+                pieces.append(separator)
+                cursor += len(separator)
+
+            opening_tag = "<source>\n"
+            pieces.append(opening_tag)
+            cursor += len(opening_tag)
+
+            pieces.append(block_body)
+            cursor += len(block_body)
+
+            closing_tag = "\n</source>"
+            pieces.append(closing_tag)
+            cursor += len(closing_tag)
+
+            marker = f"[{cid}]"
+            start = cursor
+            pieces.append(marker)
+            cursor += len(marker)
+
+            citations.append(Citation(id=cid, title=title or url, url=url, start=start, end=cursor))
+            cid += 1
+
+        return "".join(pieces), citations
+
+    def __str__(self) -> str:
+        return str(self._value or "")
+
+    def _repr_html_(self) -> str:
+        return f"<pre>{self._value or ''}</pre>"
+
+    def get_citations(self) -> list[Citation]:
+        return self._citations
+
+
 class QdrantIndexEngine(Engine):
     _default_url = "http://localhost:6333"
     _default_api_key = SYMAI_CONFIG.get("INDEXING_ENGINE_API_KEY", None)
@@ -421,15 +525,18 @@ class QdrantIndexEngine(Engine):
             kwargs["index_get"] = True
             self._configure_collection(**kwargs)
 
+        treat_as_search_engine = False
         if operation == "search":
             # Ensure collection exists - fail fast if it doesn't
             self._ensure_collection_exists(collection_name)
-            index_top_k = kwargs.get("index_top_k", self.index_top_k)
+            search_kwargs = dict(kwargs)
+            index_top_k = search_kwargs.pop("index_top_k", self.index_top_k)
             # Optional search parameters
-            score_threshold = kwargs.get("score_threshold")
+            score_threshold = search_kwargs.pop("score_threshold", None)
             # Accept both `query_filter` and `filter` for convenience
-            raw_filter = kwargs.get("query_filter", kwargs.get("filter"))
+            raw_filter = search_kwargs.pop("query_filter", search_kwargs.pop("filter", None))
             query_filter = self._build_query_filter(raw_filter)
+            treat_as_search_engine = bool(search_kwargs.pop("treat_as_search_engine", False))
 
             # Use shared search helper that already handles retries and normalization
             rsp = self._search_sync(
@@ -438,6 +545,7 @@ class QdrantIndexEngine(Engine):
                 limit=index_top_k,
                 score_threshold=score_threshold,
                 query_filter=query_filter,
+                **search_kwargs,
             )
         elif operation == "add":
             # Create collection if it doesn't exist (only for write operations)
@@ -462,7 +570,10 @@ class QdrantIndexEngine(Engine):
 
         metadata = {}
 
-        rsp = QdrantResult(rsp, query, embedding)
+        if operation == "search" and treat_as_search_engine:
+            rsp = self._format_search_results(rsp, collection_name)
+        else:
+            rsp = QdrantResult(rsp, query, embedding)
         return [rsp], metadata
 
     def prepare(self, argument):
@@ -513,7 +624,33 @@ class QdrantIndexEngine(Engine):
             jitter=self.jitter,
         )
         def _func():
+            qdrant_kwargs = dict(kwargs)
             query_vector_normalized = self._normalize_vector(query_vector)
+            with_payload = qdrant_kwargs.pop("with_payload", True)
+            with_vectors = qdrant_kwargs.pop("with_vectors", self.index_values)
+            # qdrant-client `query_points` is strict about extra kwargs and will assert if any
+            # unknown arguments are provided. Because our engine `forward()` passes decorator
+            # kwargs through the stack, we must drop engine-internal fields here.
+            #
+            # Keep only kwargs that `qdrant_client.QdrantClient.query_points` accepts (besides
+            # those we pass explicitly).
+            if "filter" in qdrant_kwargs and "query_filter" not in qdrant_kwargs:
+                # Convenience alias supported by our public API
+                qdrant_kwargs["query_filter"] = qdrant_kwargs.pop("filter")
+
+            allowed_qdrant_kwargs = {
+                "using",
+                "prefetch",
+                "query_filter",
+                "search_params",
+                "offset",
+                "score_threshold",
+                "lookup_from",
+                "consistency",
+                "shard_key_selector",
+                "timeout",
+            }
+            qdrant_kwargs = {k: v for k, v in qdrant_kwargs.items() if k in allowed_qdrant_kwargs}
             # For single vector collections, pass vector directly to query parameter
             # For named vector collections, use Query(near_vector=NamedVector(name="vector_name", vector=...))
             # query_points API uses query_filter (not filter) for filtering
@@ -521,9 +658,9 @@ class QdrantIndexEngine(Engine):
                 collection_name=collection_name,
                 query=query_vector_normalized,
                 limit=top_k,
-                with_payload=True,
-                with_vectors=self.index_values,
-                **kwargs,
+                with_payload=with_payload,
+                with_vectors=with_vectors,
+                **qdrant_kwargs,
             )
             # query_points returns QueryResponse with .points attribute, extract it
             return response.points
@@ -860,6 +997,82 @@ class QdrantIndexEngine(Engine):
         # Use _query which handles retry logic and vector normalization
         return self._query(collection_name, query_vector, limit, **search_kwargs)
 
+    def _resolve_payload_url(
+        self, payload: dict[str, Any], collection_name: str, point_id: Any
+    ) -> str:
+        source = (
+            payload.get("source")
+            or payload.get("url")
+            or payload.get("file_path")
+            or payload.get("path")
+        )
+        if isinstance(source, str) and source:
+            if source.startswith(("http://", "https://", "file://")):
+                return source
+
+            source_path = Path(source).expanduser()
+            try:
+                resolved = source_path.resolve()
+                if resolved.exists() or source_path.is_absolute():
+                    return resolved.as_uri()
+            except Exception:
+                return str(source_path)
+            return str(source_path)
+
+        return f"qdrant://{collection_name}/{point_id}"
+
+    def _resolve_payload_title(self, payload: dict[str, Any], url: str, page: Any) -> str:
+        raw_title = payload.get("title")
+        if isinstance(raw_title, str) and raw_title.strip():
+            base = raw_title.strip()
+        else:
+            parsed = urlparse(url)
+            path_part = parsed.path or url
+            base = Path(path_part).stem or url
+
+        try:
+            page_int = int(page) if page is not None else None
+        except (TypeError, ValueError):
+            page_int = None
+
+        if Path(urlparse(url).path).suffix.lower() == ".pdf" and page_int is not None:
+            base = f"{base}#p{page_int}"
+
+        return base
+
+    def _format_search_results(self, points: list[ScoredPoint] | None, collection_name: str):
+        results: list[dict[str, Any]] = []
+
+        for point in points or []:
+            payload = getattr(point, "payload", {}) or {}
+            text = payload.get("text") or payload.get("content")
+            if isinstance(text, list):
+                text = " ".join([t for t in text if isinstance(t, str)])
+            if not isinstance(text, str):
+                continue
+            excerpt = text.strip()
+            if not excerpt:
+                continue
+
+            page = payload.get("page") or payload.get("page_number") or payload.get("pageIndex")
+            url = self._resolve_payload_url(payload, collection_name, getattr(point, "id", ""))
+            title = self._resolve_payload_title(payload, url, page)
+
+            results.append(
+                {
+                    "url": url,
+                    "title": title,
+                    "excerpts": [excerpt],
+                    "source_id": payload.get("source_id")
+                    or payload.get("sourceId")
+                    or payload.get("chunk_id")
+                    or payload.get("chunkId")
+                    or getattr(point, "id", None),
+                }
+            )
+
+        return SearchResult({"results": results})
+
     async def search(
         self,
         collection_name: str,
@@ -923,7 +1136,7 @@ class QdrantIndexEngine(Engine):
             if tmp_path.exists():
                 tmp_path.unlink()
 
-    async def chunk_and_upsert(  # noqa: C901
+    async def chunk_and_upsert(
         self,
         collection_name: str,
         text: str | Symbol | None = None,
@@ -1001,8 +1214,7 @@ class QdrantIndexEngine(Engine):
             # Add source to metadata if not already present
             if metadata is None:
                 metadata = {}
-            if "source" not in metadata:
-                metadata["source"] = doc_path.name
+            metadata["source"] = str(doc_path.resolve())
 
         # Handle document_url: download and read file using FileReader
         elif document_url is not None:

symai/backend/engines/search/engine_parallel.py

@@ -74,7 +74,8 @@ class SearchResult(Result):
         self._citations: list[Citation] = []
         try:
             results = self._coerce_results(value)
-            text, citations = self._build_text_and_citations(results)
+            task_meta = self._extract_task_metadata(value)
+            text, citations = self._build_text_and_citations(results, task_meta=task_meta)
             self._value = text
             self._citations = citations
         except Exception as e:
@@ -87,13 +88,26 @@ class SearchResult(Result):
         results = raw.get("results", []) if isinstance(raw, dict) else getattr(raw, "results", None)
         if not results:
             return []
-        coerced: list[dict[str, Any]] = []
+        coerced = []
         for item in results:
             if item is None:
                 continue
             coerced.append(_item_to_mapping(item))
         return coerced
 
+    def _extract_task_metadata(self, raw: Any) -> dict[str, Any] | None:
+        if not isinstance(raw, dict):
+            return None
+        task_output = raw.get("task_output")
+        if task_output is None:
+            return None
+        output_value = task_output.get("output") if isinstance(task_output, dict) else None
+        return {
+            "reasoning": raw.get("task_reasoning"),
+            "answer": output_value,
+            "confidence": raw.get("task_confidence"),
+        }
+
     def _normalize_url(self, url: str) -> str:
         parts = urlsplit(url)
         scheme = parts.scheme.lower() if parts.scheme else "https"
@@ -139,11 +153,40 @@ class SearchResult(Result):
         cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
         return cleaned.strip()
 
-    def _build_text_and_citations(self, results: list[dict[str, Any]]):
-        pieces: list[str] = []
-        citations: list[Citation] = []
+    def _build_text_and_citations(
+        self, results: list[dict[str, Any]], *, task_meta: dict[str, Any] | None = None
+    ):
+        pieces = []
+        citations = []
         cursor = 0
-        seen_urls: set[str] = set()
+
+        if task_meta:
+            reasoning = task_meta.get("reasoning")
+            answer = task_meta.get("answer")
+            confidence = task_meta.get("confidence")
+
+            if reasoning:
+                block = f"<reasoning>\n{reasoning}\n</reasoning>"
+                pieces.append(block)
+                cursor += len(block)
+
+            if answer:
+                if pieces:
+                    pieces.append("\n\n")
+                    cursor += 2
+                block = f"<answer>\n{answer}\n</answer>"
+                pieces.append(block)
+                cursor += len(block)
+
+            if confidence:
+                if pieces:
+                    pieces.append("\n\n")
+                    cursor += 2
+                block = f"<answer_confidence>\n{confidence}\n</answer_confidence>"
+                pieces.append(block)
+                cursor += len(block)
+
+        seen_urls = set()
         cid = 1
         separator = "\n\n---\n\n"
 
@@ -158,13 +201,8 @@ class SearchResult(Result):
 
             title = str(item.get("title") or "") or urlsplit(normalized_url).netloc
             excerpts = item.get("excerpts") or []
-            excerpt_parts: list[str] = []
-            for ex in excerpts:
-                if not isinstance(ex, str):
-                    continue
-                sanitized = self._sanitize_excerpt(ex)
-                if sanitized:
-                    excerpt_parts.append(sanitized)
+            excerpt_parts = [self._sanitize_excerpt(ex) for ex in excerpts]
+            excerpt_parts = [p for p in excerpt_parts if p]
             if not excerpt_parts:
                 continue
 
@@ -255,16 +293,14 @@ class ExtractResult(Result):
         super().__init__(value, **kwargs)
         try:
             results = self._coerce_results(value)
-            content_parts: list[str] = []
+            content_parts = []
             for r in results:
-                excerpts = r.get("excerpts") or []
                 full = r.get("full_content")
-                if isinstance(full, str):
+                if full is not None:
                     content_parts.append(full)
-                elif full is not None:
-                    content_parts.append(str(full))
-                elif excerpts:
-                    content_parts.extend([s for s in excerpts if isinstance(s, str)])
+                else:
+                    excerpts = r.get("excerpts") or []
+                    content_parts.extend(excerpts)
             self._value = "\n\n".join(content_parts)
         except Exception as e:
             self._value = None
@@ -276,7 +312,7 @@ class ExtractResult(Result):
         results = raw.get("results", []) if isinstance(raw, dict) else getattr(raw, "results", None)
         if not results:
             return []
-        coerced: list[dict[str, Any]] = []
+        coerced = []
         for item in results:
             if item is None:
                 continue
@@ -344,8 +380,8 @@ class ParallelEngine(Engine):
     def _normalize_include_domains(self, domains: list[str] | None) -> list[str]:
         if not isinstance(domains, list):
             return []
-        seen: set[str] = set()
-        out: list[str] = []
+        seen = set()
+        out = []
         for d in domains:
             netloc = self._extract_netloc(d)
             if not netloc or netloc in seen:
@@ -361,8 +397,8 @@ class ParallelEngine(Engine):
     def _normalize_exclude_domains(self, domains: list[str] | None) -> list[str]:
         if not isinstance(domains, list):
             return []
-        seen: set[str] = set()
-        out: list[str] = []
+        seen = set()
+        out = []
         for d in domains:
             netloc = self._extract_netloc(d)
             if not netloc or netloc in seen:
@@ -382,7 +418,7 @@ class ParallelEngine(Engine):
             text = value.strip()
             return [text] if text else []
         if isinstance(value, list):
-            cleaned: list[str] = []
+            cleaned = []
             for item in value:
                 if item is None:
                     continue
@@ -429,7 +465,7 @@ class ParallelEngine(Engine):
         excerpts = {"max_chars_per_result": max_chars_per_result}
         include = self._normalize_include_domains(kwargs.get("allowed_domains"))
         exclude = self._normalize_exclude_domains(kwargs.get("excluded_domains"))
-        source_policy: dict[str, Any] | None = None
+        source_policy = None
         if include or exclude:
             source_policy = {}
             if include:
@@ -457,7 +493,7 @@ class ParallelEngine(Engine):
 
         include = self._normalize_include_domains(kwargs.get("allowed_domains"))
         exclude = self._normalize_exclude_domains(kwargs.get("excluded_domains"))
-        source_policy: dict[str, Any] | None = None
+        source_policy = None
         if include or exclude:
             source_policy = {}
             if include:
@@ -542,7 +578,7 @@ class ParallelEngine(Engine):
         source_policy: dict[str, Any] | None,
         task_spec: Any,
     ):
-        task_kwargs: dict[str, Any] = {
+        task_kwargs = {
             "input": task_input,
             "processor": processor,
         }
@@ -559,7 +595,7 @@ class ParallelEngine(Engine):
             UserMessage(f"Failed to create Parallel task: {e}", raise_with=ValueError)
 
     def _fetch_task_result(self, run_id: str, *, timeout: Any, api_timeout: int | None):
-        result_kwargs: dict[str, Any] = {}
+        result_kwargs = {}
         if api_timeout is not None:
             result_kwargs["api_timeout"] = api_timeout
         if timeout is not None:
@@ -570,36 +606,40 @@ class ParallelEngine(Engine):
             UserMessage(f"Failed to fetch Parallel task result: {e}", raise_with=ValueError)
 
     def _task_result_to_search_payload(self, task_result: Any) -> dict[str, Any]:
-        payload: dict[str, Any] = {"results": []}
-        output = getattr(task_result, "output", None)
+        payload = {"results": []}
+        output = task_result.output
         if output is None:
             return payload
 
-        basis_items = getattr(output, "basis", None) or []
+        basis_items = output.basis or []
         for idx, basis in enumerate(basis_items):
             payload["results"].extend(self._basis_to_results(basis, basis_index=idx))
 
         if not payload["results"]:
             payload["results"].append(self._task_fallback_result(output, basis_items))
 
-        payload["task_output"] = getattr(output, "content", None)
-        payload["task_output_type"] = getattr(output, "type", None)
+        payload["task_output"] = output.content
+        payload["task_output_type"] = output.type
+
+        if basis_items:
+            first_basis = basis_items[0]
+            payload["task_reasoning"] = first_basis.reasoning
+            payload["task_confidence"] = first_basis.confidence
+
         return payload
 
     def _basis_to_results(self, basis: Any, *, basis_index: int) -> list[dict[str, Any]]:
-        raw_reasoning = getattr(basis, "reasoning", "") or ""
-        reasoning = raw_reasoning if isinstance(raw_reasoning, str) else str(raw_reasoning)
-        raw_field = getattr(basis, "field", "") or ""
-        field_title = raw_field if isinstance(raw_field, str) else str(raw_field)
+        reasoning = basis.reasoning or ""
+        field_title = basis.field or ""
         if not field_title.strip():
             field_title = "Parallel Task Output"
-        citations = getattr(basis, "citations", None) or []
+        citations = basis.citations or []
         if not citations:
             if not reasoning:
                 return []
             citations = [None]
 
-        results: list[dict[str, Any]] = []
+        results = []
         # Convert field titles to lowercase slugs by swapping non-alphanumerics for hyphens.
         slug = re.sub(r"[^a-z0-9]+", "-", field_title.lower()).strip("-") or "field"
         basis_url = f"parallel://task-output/{basis_index:04d}-{slug}"
@@ -609,10 +649,9 @@ class ParallelEngine(Engine):
                 title = field_title
                 excerpts = [reasoning]
             else:
-                url = str(getattr(citation, "url", "") or "")
-                title = str(getattr(citation, "title", "") or field_title)
-                raw_excerpts = getattr(citation, "excerpts", None) or []
-                excerpts = [snippet for snippet in raw_excerpts if isinstance(snippet, str)]
+                url = str(citation.url or "")
+                title = str(citation.title or field_title)
+                excerpts = citation.excerpts or []
                 if not excerpts and reasoning:
                     excerpts = [reasoning]
             results.append(
@@ -625,7 +664,7 @@ class ParallelEngine(Engine):
         return results
 
     def _task_fallback_result(self, output: Any, basis_items: list[Any]) -> dict[str, Any]:
-        content = getattr(output, "content", None)
+        content = output.content
         if isinstance(content, str):
             snippet = content
         elif isinstance(content, (dict, list)):
@@ -633,9 +672,9 @@ class ParallelEngine(Engine):
         else:
             snippet = str(content or "")
         if not snippet:
-            extra_reasoning: list[str] = []
+            extra_reasoning = []
             for basis in basis_items:
-                raw_value = getattr(basis, "reasoning", "") or ""
+                raw_value = basis.reasoning or ""
                 if isinstance(raw_value, str):
                     extra_reasoning.append(raw_value)
                 else:
@@ -665,13 +704,13 @@ class ParallelEngine(Engine):
     def forward(self, argument):
         kwargs = argument.kwargs
         # Route based on presence of URL vs Query
-        url = getattr(argument.prop, "url", None) or kwargs.get("url")
+        url = argument.prop.url or kwargs.get("url")
         if url:
             return self._extract(str(url), kwargs)
 
-        raw_query = getattr(argument.prop, "prepared_input", None)
+        raw_query = argument.prop.prepared_input
         if raw_query is None:
-            raw_query = getattr(argument.prop, "query", None)
+            raw_query = argument.prop.query
         search_queries = self._coerce_search_queries(raw_query)
         if not search_queries:
             UserMessage(
@@ -685,11 +724,11 @@ class ParallelEngine(Engine):
 
     def prepare(self, argument):
         # For scraping: store URL directly. For search: pass through query string.
-        url = argument.kwargs.get("url") or getattr(argument.prop, "url", None)
+        url = argument.kwargs.get("url") or argument.prop.url
         if url:
             argument.prop.prepared_input = str(url)
             return
-        query = getattr(argument.prop, "query", None)
+        query = argument.prop.query
         if isinstance(query, list):
             argument.prop.prepared_input = self._coerce_search_queries(query)
             return

symai/extended/interfaces/__init__.py

@@ -0,0 +1 @@
+

symai/extended/interfaces/local_search.py

@@ -0,0 +1,57 @@
+from typing import TYPE_CHECKING
+
+from ...backend.engines.index.engine_qdrant import QdrantIndexEngine
+from ...symbol import Expression, Symbol
+
+if TYPE_CHECKING:
+    from ...backend.engines.index.engine_qdrant import SearchResult
+
+
+class local_search(Expression):
+    def __init__(self, index_name: str = QdrantIndexEngine._default_index_name, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.index_name = index_name
+        self.name = self.__class__.__name__
+
+    def search(self, query: Symbol, **kwargs) -> "SearchResult":
+        symbol = self._to_symbol(query)
+        options = dict(kwargs)
+
+        index_name = options.pop("collection_name", options.pop("index_name", self.index_name))
+
+        # Normalize limit/top_k/index_top_k
+        index_top_k = options.pop("index_top_k", None)
+        if index_top_k is None:
+            top_k = options.pop("top_k", None)
+            limit = options.pop("limit", None)
+            index_top_k = top_k if top_k is not None else limit
+        if index_top_k is not None:
+            options["index_top_k"] = index_top_k
+
+        # Bypass decorator/EngineRepository pipeline entirely (and thus `forward()`).
+        # We query Qdrant directly and then format results into the same SearchResult
+        # structure used by `parallel.search` (citations, inline markers, etc.).
+        engine = QdrantIndexEngine(index_name=index_name)
+        try:
+            score_threshold = options.pop("score_threshold", None)
+            raw_filter = options.pop("query_filter", options.pop("filter", None))
+            query_filter = engine._build_query_filter(raw_filter)
+
+            # Keep `with_payload` default aligned with engine behavior; let caller override.
+            with_payload = options.pop("with_payload", True)
+            with_vectors = options.pop("with_vectors", False)
+
+            points = engine._search_sync(
+                collection_name=index_name,
+                query_vector=symbol.embedding,
+                limit=options.pop("index_top_k", engine.index_top_k),
+                score_threshold=score_threshold,
+                query_filter=query_filter,
+                with_payload=with_payload,
+                with_vectors=with_vectors,
+                **options,
+            )
+            result = engine._format_search_results(points, index_name)
+        finally:
+            del engine
+        return result

{symbolicai-1.2.1.dist-info → symbolicai-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 1.2.1
+Version: 1.4.0
 Summary: A Neurosymbolic Perspective on Large Language Models
 Author-email: Marius-Constantin Dinu <marius@extensity.ai>, Leoveanu-Condrei Claudiu <leo@extensity.ai>
 License: BSD 3-Clause License
@@ -136,6 +136,8 @@ Requires-Dist: symbolicai[serpapi]; extra == "all"
 Requires-Dist: symbolicai[services]; extra == "all"
 Requires-Dist: symbolicai[solver]; extra == "all"
 Requires-Dist: symbolicai[qdrant]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=1.3.0; extra == "dev"
 Dynamic: license-file
 
 # **SymbolicAI: A neuro-symbolic perspective on LLMs**

{symbolicai-1.2.1.dist-info → symbolicai-1.4.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 symai/TERMS_OF_SERVICE.md,sha256=HN42UXVI_wAVDHjMShzy_k7xAsbjXaATNeMKcIte_eg,91409
-symai/__init__.py,sha256=7dv4gZERByf3qd42_39-ETnt4FaKCgOcZV1I1rcnOX4,18530
+symai/__init__.py,sha256=s7UwW7LIsUjcCHapKxUsO0MhWH-98vO3gPUhsNxOZW8,18530
 symai/chat.py,sha256=DCEbmZ96wv-eitAVt6-oF6PT3JM3cT59Iy3r2Hucd_M,14100
 symai/components.py,sha256=s10kLvwAOjSBQQohoHGtAIKs0UHHCd_HhiRvMbNtIH0,64685
 symai/constraints.py,sha256=ljjB9p0qK4DrDl_u5G_Y-Y6WAH5ZHANIqLLxRtwcORs,1980
@@ -41,7 +41,7 @@ symai/backend/engines/files/engine_io.py,sha256=4eYBz44rQYWD7VO6Pn7hVF_cOnqNuolo
 symai/backend/engines/imagecaptioning/engine_blip2.py,sha256=8lTzc8sQpuNY4AUb_ZweRKr95v-sFtTykT5ennVf6g0,2915
 symai/backend/engines/imagecaptioning/engine_llavacpp_client.py,sha256=jBsLZv0Laa4tuPyX0VQ7uwyldyO3aYIbbj73WjTbceM,6793
 symai/backend/engines/index/engine_pinecone.py,sha256=fxCew1ldUdjd9UtqnMuWFDiVz5X5BUIKZtq1iSDhj28,9132
-symai/backend/engines/index/engine_qdrant.py,sha256=GtWVbgaqJuATfGus0A0h7EgM_8hKlbw3fnorNJmbC_Q,43300
+symai/backend/engines/index/engine_qdrant.py,sha256=U9p0kzYvHE4DjFgxnvnG_8xfEoP_W4dpaBGY5gTFMF4,50994
 symai/backend/engines/index/engine_vectordb.py,sha256=xXU8QaC2BX9O4dDjDCVYgWO4PxQMpmNlhtal6UVtV0o,8541
 symai/backend/engines/lean/engine_lean4.py,sha256=ln5nbQn5szq8nRulbREPLCPQ5bwjM_A5XAGMkfzPdT8,10102
 symai/backend/engines/neurosymbolic/__init__.py,sha256=o7HUmxcYSrIkutGYB-6_Qur3adHyrkVeWroDtqEK-YE,2279
@@ -61,7 +61,7 @@ symai/backend/engines/ocr/engine_apilayer.py,sha256=UpC3oHBdSM6wlPVqxwMkemBd-Y0R
 symai/backend/engines/output/engine_stdout.py,sha256=BWNXACl5U-WYIJnT1pZNwZsTRMzP1XzA0A7o693mmyQ,899
 symai/backend/engines/scrape/engine_requests.py,sha256=yyVFT9JrZ4S6v5U_cykef-tn5iWGl1MAdpqnDaQ70TA,13821
 symai/backend/engines/search/engine_openai.py,sha256=hAEu3vPZzLTvgmNc4BSZDTcNb4ek4xYeOf8xgti2zRs,14248
-symai/backend/engines/search/engine_parallel.py,sha256=PybgfkpJ_rA5FkVebZisfXwWIcki2AJPxqZfnWPl5To,26422
+symai/backend/engines/search/engine_parallel.py,sha256=vhRavd_LStk6grV1aDZiHWfW9v1uDnCLX0BT8smiV84,27008
 symai/backend/engines/search/engine_perplexity.py,sha256=rXnZjMCSiIRuJcNSchE58-f9zWJmYpkKMHONF_XwGnk,4100
 symai/backend/engines/search/engine_serpapi.py,sha256=ZJJBnEDoLjkpxWt_o4vFZanwqojH8ZFBWmWNnEaIbww,3618
 symai/backend/engines/speech_to_text/engine_local_whisper.py,sha256=EOUh2GCeEhZ2Av72i_AZ4NSj9e46Pl7Ft6sIErFy6FI,8387
@@ -100,7 +100,7 @@ symai/extended/solver.py,sha256=Men8FcGlUdUHJCw0lb1rKAwLOGp5-d5Rnuf2sx5Q6PM,1173
 symai/extended/summarizer.py,sha256=x7yKOU-tXmvHZxmyKrPoy5_Dy9-Zet1oAcDK8uvQSRI,1052
 symai/extended/taypan_interpreter.py,sha256=yPIcI-NcpNpfDb3r3KiclP9XwzvFo_enoZOgK1JM3NI,4832
 symai/extended/vectordb.py,sha256=npCR9WBfV6RN3OQZuJAELpwz1sM6q1btKqrVaW5jPvs,13546
-symai/extended/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+symai/extended/interfaces/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 symai/extended/interfaces/blip_2.py,sha256=wZYVzql6w_OJMUZc1c2BKx3LHrlapRprx-Q6p99_qxE,463
 symai/extended/interfaces/clip.py,sha256=l6vjEq3cF-wDX9cRPulyiKpDFQB8QI2609GcGtvqt7U,514
 symai/extended/interfaces/console.py,sha256=qeAnG80f95ArADjfpk57AaDA1cHUQSkaUrau2zGNSKs,637
@@ -110,6 +110,7 @@ symai/extended/interfaces/flux.py,sha256=LTY_I9UtIxnh3Nc4cBPQhQ6upB6CVZIhc1uOnFp
 symai/extended/interfaces/gpt_image.py,sha256=Jk5-9og440eZeRAhKmjdyhwP22wX58q0NcFuVhIFWZQ,718
 symai/extended/interfaces/input.py,sha256=CFMLf2j_a-rZ1ApaEwfgqZmWVS7_1yj_u6iiqtiOGPs,456
 symai/extended/interfaces/llava.py,sha256=yCItfGYSk35RazhEfHR4R324h-R6W5DjZYeJBonDkRU,433
+symai/extended/interfaces/local_search.py,sha256=AHHRsYCUm4VttGSl_HAk5kpH34e0x_uzvgy1OXSubSs,2408
 symai/extended/interfaces/naive_scrape.py,sha256=KPjTSBXSCr5zwHwIPgF-VwLSTD2OjVcL4xALNX4l9-4,682
 symai/extended/interfaces/naive_vectordb.py,sha256=fm7DBMYYnSx7Ma7eNnCmuOVyQwNGnkiDR31oV-qNrJA,1348
 symai/extended/interfaces/ocr.py,sha256=MMxgp8ZKoM44doJPZzzrBVh2VxChs6faFu2uFYnbzfU,563
@@ -162,9 +163,9 @@ symai/server/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 symai/server/huggingface_server.py,sha256=wSAVqFiKQsCu5UB2YYVpxJBhJ7GgQBBfePxNi265yP8,9039
 symai/server/llama_cpp_server.py,sha256=-WPTNB2cbnwtnpES4AtPM__MCasDKl83jr94JGS9tmI,2144
 symai/server/qdrant_server.py,sha256=l4r4rz29c7cO1dapXO0LQ4sHW4WF44keuz7j8v5azMc,9854
-symbolicai-1.2.1.dist-info/licenses/LICENSE,sha256=9vRFudlJ1ghVfra5lcCUIYQCqnZSYcBLjLHbGRsrQCs,1505
-symbolicai-1.2.1.dist-info/METADATA,sha256=B1Jb04tBfVJ14P2PtmpTr_tsvyKzK1QGCnGCk6bJVkU,23603
-symbolicai-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-symbolicai-1.2.1.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
-symbolicai-1.2.1.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
-symbolicai-1.2.1.dist-info/RECORD,,
+symbolicai-1.4.0.dist-info/licenses/LICENSE,sha256=9vRFudlJ1ghVfra5lcCUIYQCqnZSYcBLjLHbGRsrQCs,1505
+symbolicai-1.4.0.dist-info/METADATA,sha256=dlAY-AhPA52x_fmXU-i7h6rA-M1Mf0qJ00OeOUyplGs,23676
+symbolicai-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+symbolicai-1.4.0.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
+symbolicai-1.4.0.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
+symbolicai-1.4.0.dist-info/RECORD,,