symbolicai 1.3.0__py3-none-any.whl → 1.5.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.3.0"
+SYMAI_VERSION = "1.5.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/scrape/engine_requests.py

@@ -9,6 +9,7 @@ service disruption.
 
 import io
 import logging
+import random
 import re
 from typing import Any, ClassVar
 from urllib.parse import parse_qsl, urlencode, urljoin, urlparse, urlunparse
@@ -17,7 +18,9 @@ import requests
 import trafilatura
 from bs4 import BeautifulSoup
 from pdfminer.high_level import extract_text
+from requests.adapters import HTTPAdapter
 from requests.structures import CaseInsensitiveDict
+from urllib3.util.retry import Retry
 
 from ....symbol import Result
 from ....utils import UserMessage
@@ -80,24 +83,49 @@ class RequestsEngine(Engine):
         "none": "None",
     }
 
-    def __init__(self, timeout=15, verify_ssl=True, user_agent=None):
+    USER_AGENT_POOL: ClassVar[list[str]] = [
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0",
+        "Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0",
+    ]
+
+    def __init__(self, timeout=15, verify_ssl=True, user_agent=None, retries=3, backoff_factor=0.5, retry_status_codes=(500, 502, 503, 504)):
         """
         Args:
             timeout: Seconds to wait for network operations before aborting.
             verify_ssl: Toggle for TLS certificate verification.
-            user_agent: Optional override for the default desktop Chrome UA.
+            user_agent: Optional override for user agent rotation.
+            retries: Number of retries for failed requests (default: 3).
+            backoff_factor: Multiplier for exponential backoff (default: 0.5).
+            retry_status_codes: HTTP status codes to retry on (default: 500, 502, 503, 504).
         """
         super().__init__()
         self.timeout = timeout
         self.verify_ssl = verify_ssl
         self.name = self.__class__.__name__
-
-        headers = dict(self.DEFAULT_HEADERS)
-        if user_agent:
-            headers["User-Agent"] = user_agent
+        self._user_agent_override = user_agent
 
         self.session = requests.Session()
-        self.session.headers.update(headers)
+        self.session.headers.update({k: v for k, v in self.DEFAULT_HEADERS.items() if k != "User-Agent"})
+
+        retry_strategy = Retry(
+            total=retries,
+            backoff_factor=backoff_factor,
+            status_forcelist=retry_status_codes,
+            allowed_methods=["GET", "HEAD"],
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+
+    def _get_user_agent(self) -> str:
+        """Return user agent: override if set, otherwise random from pool."""
+        return self._user_agent_override or random.choice(self.USER_AGENT_POOL)
 
     def _maybe_set_bypass_cookies(self, url: str):
         netloc = urlparse(url).hostname
@@ -232,7 +260,7 @@ class RequestsEngine(Engine):
         # Avoid loops
         if target == resp.url:
             return resp
-        return self.session.get(target, timeout=timeout, allow_redirects=True)
+        return self.session.get(target, timeout=timeout, allow_redirects=True, headers={"User-Agent": self._get_user_agent()})
 
     def _fetch_with_playwright(
         self,
@@ -259,7 +287,7 @@ class RequestsEngine(Engine):
 
         timeout_seconds = timeout if timeout is not None else self.timeout
         timeout_ms = max(int(timeout_seconds * 1000), 0)
-        user_agent = self.session.headers.get("User-Agent")
+        user_agent = self._get_user_agent()
 
         parsed = urlparse(url)
         hostname = parsed.hostname or ""
@@ -348,7 +376,8 @@ class RequestsEngine(Engine):
             )
         else:
             resp = self.session.get(
-                clean_url, timeout=self.timeout, allow_redirects=True, verify=self.verify_ssl
+                clean_url, timeout=self.timeout, allow_redirects=True, verify=self.verify_ssl,
+                headers={"User-Agent": self._get_user_agent()}
             )
         resp.raise_for_status()
 

symai/backend/engines/search/__init__.py

@@ -0,0 +1,13 @@
+from .engine_firecrawl import FirecrawlEngine
+from .engine_parallel import ParallelEngine
+
+SEARCH_ENGINE_MAPPING = {
+    "firecrawl": FirecrawlEngine,
+    "parallel": ParallelEngine,
+}
+
+__all__ = [
+    "SEARCH_ENGINE_MAPPING",
+    "FirecrawlEngine",
+    "ParallelEngine",
+]

symai/backend/engines/search/engine_firecrawl.py

@@ -0,0 +1,333 @@
+import json
+import logging
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+from firecrawl import Firecrawl
+from firecrawl.v2.types import ScrapeOptions
+
+from ....symbol import Result
+from ....utils import UserMessage
+from ...base import Engine
+from ...settings import SYMAI_CONFIG
+
+logging.getLogger("requests").setLevel(logging.ERROR)
+logging.getLogger("urllib3").setLevel(logging.ERROR)
+logging.getLogger("httpx").setLevel(logging.ERROR)
+
+TRACKING_KEYS = {
+    "utm_source",
+    "utm_medium",
+    "utm_campaign",
+    "utm_term",
+    "utm_content",
+}
+
+
+@dataclass
+class Citation:
+    id: int
+    title: str
+    url: str
+    start: int
+    end: int
+
+    def __hash__(self):
+        return hash((self.url,))
+
+
+class FirecrawlSearchResult(Result):
+    def __init__(
+        self, value: dict[str, Any] | Any, max_chars_per_result: int | None = None, **kwargs
+    ) -> None:
+        raw_dict = value.model_dump() if hasattr(value, "model_dump") else value
+        super().__init__(raw_dict, **kwargs)
+        self._citations: list[Citation] = []
+        self._max_chars_per_result = max_chars_per_result
+        try:
+            text, citations = self._build_text_and_citations(raw_dict)
+            self._value = text
+            self._citations = citations
+        except Exception as e:
+            self._value = None
+            UserMessage(f"Failed to parse Firecrawl search response: {e}", raise_with=ValueError)
+
+    def _build_text_and_citations(self, data: dict[str, Any]) -> tuple[str, list[Citation]]:
+        results = []
+        for source in ["web", "news", "images"]:
+            source_data = data.get(source) or []
+            results.extend(source_data)
+
+        if not results:
+            return "", []
+
+        parts = []
+        citations = []
+        cursor = 0
+
+        for idx, item in enumerate(results, 1):
+            # Handle both SearchResultWeb (url/title at top level) and Document (url/title in metadata)
+            metadata = item.get("metadata") or {}
+            url = item.get("url") or metadata.get("url") or metadata.get("source_url") or ""
+            title = item.get("title") or metadata.get("title") or ""
+
+            if not url:
+                continue
+
+            # Check if this is a scraped result (has markdown content)
+            markdown = item.get("markdown", "")
+            if markdown:
+                content = markdown
+                if self._max_chars_per_result and len(content) > self._max_chars_per_result:
+                    content = content[: self._max_chars_per_result] + "..."
+                result_text = f"{title}\n{url}\n{content}"
+            else:
+                description = (
+                    item.get("description")
+                    or item.get("snippet")
+                    or metadata.get("description")
+                    or ""
+                )
+                result_text = f"{title}\n{url}"
+                if description:
+                    if self._max_chars_per_result and len(description) > self._max_chars_per_result:
+                        description = description[: self._max_chars_per_result] + "..."
+                    result_text += f"\n{description}"
+
+            if parts:
+                parts.append("\n\n")
+                cursor += 2
+
+            parts.append(result_text)
+            cursor += len(result_text)
+
+            marker = f"[{idx}]"
+            start = cursor
+            parts.append(marker)
+            cursor += len(marker)
+
+            citations.append(Citation(id=idx, title=title, url=url, start=start, end=cursor))
+
+        text = "".join(parts)
+        return text, citations
+
+    def __str__(self) -> str:
+        if isinstance(self._value, str) and self._value:
+            return self._value
+        try:
+            return json.dumps(self.raw, indent=2)
+        except TypeError:
+            return str(self.raw)
+
+    def _repr_html_(self) -> str:
+        if isinstance(self._value, str) and self._value:
+            return f"<pre>{self._value}</pre>"
+        try:
+            return f"<pre>{json.dumps(self.raw, indent=2)}</pre>"
+        except Exception:
+            return f"<pre>{self.raw!s}</pre>"
+
+    def get_citations(self) -> list[Citation]:
+        return self._citations
+
+
+class FirecrawlExtractResult(Result):
+    """Result wrapper for Firecrawl scrape API responses."""
+
+    def __init__(self, value: Any, **kwargs) -> None:
+        raw_dict = value.model_dump() if hasattr(value, "model_dump") else value
+        super().__init__(raw_dict, **kwargs)
+        try:
+            self._value = self._extract_content(raw_dict)
+        except Exception as e:
+            self._value = None
+            UserMessage(f"Failed to parse Firecrawl scrape response: {e}", raise_with=ValueError)
+
+    def _extract_content(self, data: dict[str, Any]) -> str:
+        content = data.get("markdown") or data.get("html") or data.get("raw_html")
+        if content:
+            return str(content)
+        json_data = data.get("json")
+        if json_data:
+            return json.dumps(json_data, indent=2)
+        return ""
+
+    def __str__(self) -> str:
+        try:
+            return str(self._value or "")
+        except Exception:
+            return ""
+
+    def _repr_html_(self) -> str:
+        try:
+            return f"<pre>{self._value or ''}</pre>"
+        except Exception:
+            return "<pre></pre>"
+
+
+class FirecrawlEngine(Engine):
+    def __init__(self, api_key: str | None = None):
+        super().__init__()
+        self.config = deepcopy(SYMAI_CONFIG)
+        self.api_key = api_key or self.config.get("SEARCH_ENGINE_API_KEY")
+        self.model = self.config.get("SEARCH_ENGINE_MODEL")
+        self.name = self.__class__.__name__
+
+        if not self.api_key:
+            UserMessage(
+                "Firecrawl API key not found. Set SEARCH_ENGINE_API_KEY in config or environment.",
+                raise_with=ValueError,
+            )
+
+        try:
+            self.client = Firecrawl(api_key=self.api_key)
+        except Exception as e:
+            UserMessage(f"Failed to initialize Firecrawl client: {e}", raise_with=ValueError)
+
+    def id(self) -> str:
+        if (
+            self.config.get("SEARCH_ENGINE_API_KEY")
+            and str(self.config.get("SEARCH_ENGINE_MODEL", "")).lower() == "firecrawl"
+        ):
+            return "search"
+        return super().id()
+
+    def command(self, *args, **kwargs):
+        super().command(*args, **kwargs)
+        if "SEARCH_ENGINE_API_KEY" in kwargs:
+            self.api_key = kwargs["SEARCH_ENGINE_API_KEY"]
+        if "SEARCH_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["SEARCH_ENGINE_MODEL"]
+
+    def _normalize_url(self, url: str) -> str:
+        parts = urlsplit(url)
+        filtered_query = [
+            (k, v)
+            for k, v in parse_qsl(parts.query, keep_blank_values=True)
+            if k not in TRACKING_KEYS and not k.lower().startswith("utm_")
+        ]
+        query = urlencode(filtered_query, doseq=True)
+        return urlunsplit((parts.scheme, parts.netloc, parts.path, query, parts.fragment))
+
+    def _search(self, query: str, kwargs: dict[str, Any]):
+        if not query:
+            UserMessage(
+                "FirecrawlEngine._search requires a non-empty query.", raise_with=ValueError
+            )
+
+        max_chars_per_result = kwargs.get("max_chars_per_result")
+
+        # Build search kwargs
+        search_kwargs = {}
+        if "limit" in kwargs:
+            search_kwargs["limit"] = kwargs["limit"]
+        if "location" in kwargs:
+            search_kwargs["location"] = kwargs["location"]
+        if "tbs" in kwargs:
+            search_kwargs["tbs"] = kwargs["tbs"]
+        if "sources" in kwargs:
+            search_kwargs["sources"] = kwargs["sources"]
+        if "categories" in kwargs:
+            search_kwargs["categories"] = kwargs["categories"]
+        if "timeout" in kwargs:
+            search_kwargs["timeout"] = kwargs["timeout"]
+
+        # Build scrape options for search results content
+        scrape_opts = {}
+        if "formats" in kwargs:
+            scrape_opts["formats"] = kwargs["formats"]
+        if "proxy" in kwargs:
+            scrape_opts["proxy"] = kwargs["proxy"]
+        if "only_main_content" in kwargs:
+            scrape_opts["only_main_content"] = kwargs["only_main_content"]
+        if "scrape_location" in kwargs:
+            scrape_opts["location"] = kwargs["scrape_location"]
+        if "include_tags" in kwargs:
+            scrape_opts["include_tags"] = kwargs["include_tags"]
+        if "exclude_tags" in kwargs:
+            scrape_opts["exclude_tags"] = kwargs["exclude_tags"]
+
+        if scrape_opts:
+            search_kwargs["scrape_options"] = ScrapeOptions(**scrape_opts)
+
+        try:
+            result = self.client.search(query, **search_kwargs)
+        except Exception as e:
+            UserMessage(f"Failed to call Firecrawl Search API: {e}", raise_with=ValueError)
+
+        raw = result.model_dump() if hasattr(result, "model_dump") else result
+        return [FirecrawlSearchResult(result, max_chars_per_result=max_chars_per_result)], {
+            "raw_output": raw
+        }
+
+    def _extract(self, url: str, kwargs: dict[str, Any]):
+        normalized_url = self._normalize_url(url)
+
+        # Build scrape kwargs
+        scrape_kwargs = {"formats": kwargs.get("formats", ["markdown"])}
+        if "only_main_content" in kwargs:
+            scrape_kwargs["only_main_content"] = kwargs["only_main_content"]
+        if "timeout" in kwargs:
+            scrape_kwargs["timeout"] = kwargs["timeout"]
+        if "proxy" in kwargs:
+            scrape_kwargs["proxy"] = kwargs["proxy"]
+        if "location" in kwargs:
+            scrape_kwargs["location"] = kwargs["location"]
+        if "max_age" in kwargs:
+            scrape_kwargs["max_age"] = kwargs["max_age"]
+        if "store_in_cache" in kwargs:
+            scrape_kwargs["store_in_cache"] = kwargs["store_in_cache"]
+        if "actions" in kwargs:
+            scrape_kwargs["actions"] = kwargs["actions"]
+        if "headers" in kwargs:
+            scrape_kwargs["headers"] = kwargs["headers"]
+        if "include_tags" in kwargs:
+            scrape_kwargs["include_tags"] = kwargs["include_tags"]
+        if "exclude_tags" in kwargs:
+            scrape_kwargs["exclude_tags"] = kwargs["exclude_tags"]
+        if "wait_for" in kwargs:
+            scrape_kwargs["wait_for"] = kwargs["wait_for"]
+        if "mobile" in kwargs:
+            scrape_kwargs["mobile"] = kwargs["mobile"]
+
+        try:
+            result = self.client.scrape(normalized_url, **scrape_kwargs)
+        except Exception as e:
+            UserMessage(f"Failed to call Firecrawl Scrape API: {e}", raise_with=ValueError)
+
+        raw = result.model_dump() if hasattr(result, "model_dump") else result
+        return [FirecrawlExtractResult(result)], {"raw_output": raw, "final_url": normalized_url}
+
+    def forward(self, argument):
+        kwargs = argument.kwargs
+        url = argument.prop.url or kwargs.get("url")
+        if url:
+            return self._extract(str(url), kwargs)
+
+        raw_query = argument.prop.prepared_input
+        if raw_query is None:
+            raw_query = argument.prop.query
+
+        query = str(raw_query or "").strip() if raw_query else ""
+        if not query:
+            UserMessage(
+                "FirecrawlEngine.forward requires at least one non-empty query or url.",
+                raise_with=ValueError,
+            )
+
+        return self._search(query, kwargs)
+
+    def prepare(self, argument):
+        url = argument.kwargs.get("url") or argument.prop.url
+        if url:
+            argument.prop.prepared_input = str(url)
+            return
+
+        query = argument.prop.query
+        if isinstance(query, list):
+            argument.prop.prepared_input = " ".join(str(q) for q in query if q)
+            return
+
+        argument.prop.prepared_input = str(query or "").strip()

symai/backend/engines/search/engine_parallel.py

@@ -66,7 +66,7 @@ class Citation:
         return hash((self.url,))
 
 
-class SearchResult(Result):
+class ParallelSearchResult(Result):
     def __init__(self, value: dict[str, Any] | Any, **kwargs) -> None:
         super().__init__(value, **kwargs)
         if isinstance(value, dict) and value.get("error"):
@@ -286,7 +286,7 @@ class SearchResult(Result):
         return self._citations
 
 
-class ExtractResult(Result):
+class ParallelExtractResult(Result):
     """Result wrapper for Parallel Extract API responses."""
 
     def __init__(self, value: dict[str, Any] | Any, **kwargs) -> None:
@@ -485,7 +485,7 @@ class ParallelEngine(Engine):
             )
         except Exception as e:
             UserMessage(f"Failed to call Parallel Search API: {e}", raise_with=ValueError)
-        return [SearchResult(result)], {"raw_output": result}
+        return [ParallelSearchResult(result)], {"raw_output": result}
 
     def _task(self, queries: list[str], kwargs: dict[str, Any]):
         processor_name = self._coerce_processor(kwargs.get("processor"))
@@ -521,7 +521,7 @@ class ParallelEngine(Engine):
         result = self._fetch_task_result(run.run_id, timeout=timeout, api_timeout=api_timeout)
 
         payload = self._task_result_to_search_payload(result)
-        return [SearchResult(payload)], {
+        return [ParallelSearchResult(payload)], {
             "raw_output": result,
             "task_output": payload.get("task_output"),
             "task_output_type": payload.get("task_output_type"),
@@ -699,7 +699,7 @@ class ParallelEngine(Engine):
             )
         except Exception as e:
             UserMessage(f"Failed to call Parallel Extract API: {e}", raise_with=ValueError)
-        return [ExtractResult(result)], {"raw_output": result, "final_url": url}
+        return [ParallelExtractResult(result)], {"raw_output": result, "final_url": url}
 
     def forward(self, argument):
         kwargs = argument.kwargs

symai/components.py

@@ -1508,12 +1508,18 @@ class DynamicEngine(Expression):
         """Create an engine instance based on the model name."""
         # Deferred to avoid components <-> neurosymbolic engine circular imports.
         from .backend.engines.neurosymbolic import ENGINE_MAPPING  # noqa
-        from .backend.engines.neurosymbolic.engine_cerebras import CerebrasEngine  # noqa
+        from .backend.engines.search import SEARCH_ENGINE_MAPPING  # noqa
 
         try:
+            # Check neurosymbolic engines first
             engine_class = ENGINE_MAPPING.get(self.model)
-            if engine_class is None and self.model.startswith("cerebras:"):
-                engine_class = CerebrasEngine
+
+            # Check search engines
+            if engine_class is None:
+                engine_class = SEARCH_ENGINE_MAPPING.get(self.model)
+                if engine_class is not None:
+                    return engine_class(api_key=self.api_key)
+
             if engine_class is None:
                 UserMessage(f"Unsupported model '{self.model}'", raise_with=ValueError)
             return engine_class(api_key=self.api_key, model=self.model)

symai/extended/interfaces/__init__.py

@@ -0,0 +1 @@
+

symai/extended/interfaces/firecrawl.py

@@ -0,0 +1,30 @@
+from ... import core
+from ...backend.engines.search.engine_firecrawl import FirecrawlExtractResult, FirecrawlSearchResult
+from ...symbol import Expression, Symbol
+
+
+class firecrawl(Expression):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.name = self.__class__.__name__
+
+    def search(self, query: Symbol, **kwargs) -> FirecrawlSearchResult:
+        query = self._to_symbol(query)
+
+        @core.search(query=query.value, **kwargs)
+        def _func(_) -> FirecrawlSearchResult:
+            pass
+
+        return _func(self)
+
+    def scrape(self, url: str, **kwargs) -> FirecrawlExtractResult:
+        symbol = self._to_symbol(url)
+        options = dict(kwargs)
+        options.pop("query", None)
+        options["url"] = symbol.value
+
+        @core.search(query="", **options)
+        def _func(_, *_args, **_inner_kwargs) -> FirecrawlExtractResult:
+            return None
+
+        return _func(self)

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

symai/extended/interfaces/parallel.py

@@ -1,5 +1,5 @@
 from ... import core
-from ...backend.engines.search.engine_parallel import ExtractResult, SearchResult
+from ...backend.engines.search.engine_parallel import ParallelExtractResult, ParallelSearchResult
 from ...symbol import Expression, Symbol
 
 
@@ -8,23 +8,23 @@ class parallel(Expression):
         super().__init__(*args, **kwargs)
         self.name = self.__class__.__name__
 
-    def search(self, query: Symbol, **kwargs) -> SearchResult:
+    def search(self, query: Symbol, **kwargs) -> ParallelSearchResult:
         query = self._to_symbol(query)
 
         @core.search(query=query.value, **kwargs)
-        def _func(_) -> SearchResult:
+        def _func(_) -> ParallelSearchResult:
             pass
 
         return _func(self)
 
-    def scrape(self, url: str, **kwargs) -> ExtractResult:
+    def scrape(self, url: str, **kwargs) -> ParallelExtractResult:
         symbol = self._to_symbol(url)
         options = dict(kwargs)
         options.pop("query", None)
         options["url"] = symbol.value
 
         @core.search(query="", **options)
-        def _func(_, *_args, **_inner_kwargs) -> ExtractResult:
+        def _func(_, *_args, **_inner_kwargs) -> ParallelExtractResult:
             return None
 
         return _func(self)

symai/functional.py

@@ -498,10 +498,9 @@ class EngineRepository:
     def get(engine_name: str, *_args, **_kwargs):
         self = EngineRepository()
         # First check if we're in the context manager that dynamically changes models
-        if engine_name == "neurosymbolic":
-            engine = self.get_dynamic_engine_instance()
-            if engine is not None:
-                return engine
+        dynamic_engine = self.get_dynamic_engine_instance()
+        if dynamic_engine is not None and engine_name in ("neurosymbolic", "search"):
+            return dynamic_engine
 
         # Otherwise, fallback to normal lookup:
         if engine_name not in self._engines:

{symbolicai-1.3.0.dist-info → symbolicai-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 1.3.0
+Version: 1.5.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
@@ -113,6 +113,7 @@ Requires-Dist: openai-whisper>=20240930; extra == "whisper"
 Requires-Dist: numba>=0.62.1; extra == "whisper"
 Requires-Dist: llvmlite>=0.45.1; extra == "whisper"
 Provides-Extra: search
+Requires-Dist: firecrawl-py>=4.12.0; extra == "search"
 Requires-Dist: parallel-web>=0.3.3; extra == "search"
 Provides-Extra: serpapi
 Requires-Dist: google_search_results>=2.4.2; extra == "serpapi"
@@ -136,6 +137,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.3.0.dist-info → symbolicai-1.5.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 symai/TERMS_OF_SERVICE.md,sha256=HN42UXVI_wAVDHjMShzy_k7xAsbjXaATNeMKcIte_eg,91409
-symai/__init__.py,sha256=Kdk86d3uR3kr-C7S_niPdsEbvbUu1z8pBTXb4dKe6Zs,18530
+symai/__init__.py,sha256=qlqkm2OjRqXtKhIBltfB9zx0kBf4V4ygckH1RHVPAVE,18530
 symai/chat.py,sha256=DCEbmZ96wv-eitAVt6-oF6PT3JM3cT59Iy3r2Hucd_M,14100
-symai/components.py,sha256=s10kLvwAOjSBQQohoHGtAIKs0UHHCd_HhiRvMbNtIH0,64685
+symai/components.py,sha256=XL1whwdZd6HCl0viUuXca_7d8no_xxfTGZsqE1hhwqI,64845
 symai/constraints.py,sha256=ljjB9p0qK4DrDl_u5G_Y-Y6WAH5ZHANIqLLxRtwcORs,1980
 symai/context.py,sha256=4M69MJOeWSdPTr2Y9teoNTs-nEvpzcAcr7900UgORXA,189
 symai/core.py,sha256=gI9qvTT0Skq2D0izdhAoN3RdwBtWei59KO52mKN1Sos,70420
 symai/core_ext.py,sha256=lS_BZNeUGmNhhXR-F3dFLF26_nZHq3NVaAwa4vAbkTQ,8937
 symai/exceptions.py,sha256=BxpxI8q3-7Uh_Kg9Xi2PhF6RR6CofxV1h8R07j4v47U,165
-symai/functional.py,sha256=C0UrpN0vJTTwS-yqLg91InjHWaQCHo6XPtxiN6wQb7c,21441
+symai/functional.py,sha256=GqBs5FZPVZ3iVJ-MlO0Zvkf7cNSDgVhkt3tsL82kFrM,21457
 symai/imports.py,sha256=P5WsamkfKxsK3fs8vlrFpC6CIv5WVpMIMNue9DKJGnE,16126
 symai/interfaces.py,sha256=Z8CDdarnOVa67GCLljKjxQojDH9MhhPKBQFb0pi2WfY,3458
 symai/memory.py,sha256=Cd60UyeJk7SHNBWEYOLrmUXQy54GzQsu3Mjh0lfNQOY,3716
@@ -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
@@ -59,9 +59,11 @@ symai/backend/engines/neurosymbolic/engine_openai_gptX_reasoning.py,sha256=yWiCT
 symai/backend/engines/neurosymbolic/engine_openai_responses.py,sha256=J3P7WcQhxWSPK99uZuLClpIDlLRqLJFWYwDJHrBKox4,17830
 symai/backend/engines/ocr/engine_apilayer.py,sha256=UpC3oHBdSM6wlPVqxwMkemBd-Y0ReVwc270O_EVbRD0,2267
 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/scrape/engine_requests.py,sha256=uXQ8PGeRN2OyM0_ioEI61rkv5PqSBE0wayAJNS7s8ZA,15819
+symai/backend/engines/search/__init__.py,sha256=iW6kEBOZ-gUiPYfcIWupNgewiqLrFOBGJ643kqwQFoM,274
+symai/backend/engines/search/engine_firecrawl.py,sha256=M_nxXBtvudNqRR4gTC5dXoJzf_9ofrMScYXzaGVTmaM,11990
 symai/backend/engines/search/engine_openai.py,sha256=hAEu3vPZzLTvgmNc4BSZDTcNb4ek4xYeOf8xgti2zRs,14248
-symai/backend/engines/search/engine_parallel.py,sha256=vhRavd_LStk6grV1aDZiHWfW9v1uDnCLX0BT8smiV84,27008
+symai/backend/engines/search/engine_parallel.py,sha256=voMmeJZ5bf1x3pt7uxMJu84z6VLLG0-ZfgFUWvhM-vI,27048
 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,21 +102,23 @@ 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
 symai/extended/interfaces/dall_e.py,sha256=SSF1K17SzA-lpdHVtsfHbwRCP6XJxWqsNdXoWwcBYjw,551
 symai/extended/interfaces/file.py,sha256=1_BXHKsHm78MmBeRolA_fFWFTLuA6on7Le-ZF4S_1ds,457
+symai/extended/interfaces/firecrawl.py,sha256=hGA5WxiW6EN5LNsfBSlsYzASgvz9e515TWrHGHcE21s,955
 symai/extended/interfaces/flux.py,sha256=LTY_I9UtIxnh3Nc4cBPQhQ6upB6CVZIhc1uOnFpxEIo,532
 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
 symai/extended/interfaces/openai_search.py,sha256=UvnSihdfIwybrLDz2A-yt92aklHEHIvh0pt0hp1Dpis,528
-symai/extended/interfaces/parallel.py,sha256=3QL3B-HJd1mCd1XsV8Ha_63TQZi-rlA0OJjUXB3p3UU,899
+symai/extended/interfaces/parallel.py,sha256=kWRcrs_vTPvZDDhKjl1Hp94ltZeiYH7K8l9zOy5jd-I,947
 symai/extended/interfaces/perplexity.py,sha256=vSUl8CfBsFhFrzxws9Lf8WgfhsoPatJf7eYRfihKRG4,529
 symai/extended/interfaces/pinecone.py,sha256=NA2t1pNQf-G-HSeewEO8jqGnitD3huBV5bucIM9vgi4,1075
 symai/extended/interfaces/python.py,sha256=EcxXQwrlhjGOS5SkRoa_cVt069vu_INDD9DIfbnUses,418
@@ -162,9 +166,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.3.0.dist-info/licenses/LICENSE,sha256=9vRFudlJ1ghVfra5lcCUIYQCqnZSYcBLjLHbGRsrQCs,1505
-symbolicai-1.3.0.dist-info/METADATA,sha256=7xQnG02ro-9f-haIsGjx5yMXdarGnRDFujSSaLg1gCU,23603
-symbolicai-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-symbolicai-1.3.0.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
-symbolicai-1.3.0.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
-symbolicai-1.3.0.dist-info/RECORD,,
+symbolicai-1.5.0.dist-info/licenses/LICENSE,sha256=9vRFudlJ1ghVfra5lcCUIYQCqnZSYcBLjLHbGRsrQCs,1505
+symbolicai-1.5.0.dist-info/METADATA,sha256=gQLPEUb1pW2VPNqCtgN-WcXeSQnfUJAWx0KTAN3vnJw,23731
+symbolicai-1.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+symbolicai-1.5.0.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
+symbolicai-1.5.0.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
+symbolicai-1.5.0.dist-info/RECORD,,