alita-sdk 0.3.313__tar.gz → 0.3.315__tar.gz

{alita_sdk-0.3.313 → alita_sdk-0.3.315}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.313
+Version: 0.3.315
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.313 → alita_sdk-0.3.315}/alita_sdk/runtime/toolkits/tools.py

@@ -59,8 +59,6 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
                 llm=llm
             ))
         elif tool['type'] == 'memory':
-            if memory_store is None:
-                raise ToolException(f"Memory store is not provided for memory tool: {tool.get('name', tool.get('toolkit_name', 'unknown'))}")
             tools += MemoryToolkit.get_toolkit(
                 namespace=tool['settings'].get('namespace', str(tool['id'])),
                 pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),

{alita_sdk-0.3.313 → alita_sdk-0.3.315}/alita_sdk/tools/browser/__init__.py

@@ -12,6 +12,8 @@ from ..utils import get_max_toolkit_length, clean_string, TOOLKIT_SPLITTER
 from ...configurations.browser import BrowserConfiguration
 from logging import getLogger
 
+from ...configurations.pgvector import PgVectorConfiguration
+
 logger = getLogger(__name__)
 
 name = "browser"
@@ -21,6 +23,8 @@ def get_tools(tool):
     return BrowserToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
         browser_configuration=tool['settings']['browser_configuration'],
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
+        embedding_model=tool['settings'].get('embedding_model'),
         toolkit_name=tool.get('toolkit_name', '')
     ).get_tools()
 
@@ -51,8 +55,21 @@ class BrowserToolkit(BaseToolkit):
 
         return create_model(
             name,
-            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Browser", "icon_url": None, "categories": ["testing"], "extra_categories": ["web scraping", "search", "crawler"]}}),
-            browser_configuration=(BrowserConfiguration, Field(description="Browser Configuration", json_schema_extra={'configuration_types': ['browser']})),
+            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Browser", "icon_url": None,
+                                                                  "categories": ["testing"],
+                                                                  "extra_categories": [
+                                                                      "web scraping", "search", "crawler"
+                                                                  ]}}),
+            browser_configuration=(Optional[BrowserConfiguration],
+                                   Field(description="Browser Configuration (required for tools and `google`)",
+                                         default=None, json_schema_extra={'configuration_types': ['browser']})),
+            pgvector_configuration=(Optional[PgVectorConfiguration],
+                                    Field(description="PgVector configuration (required for tools `multi_url_crawler`)",
+                                          default=None, json_schema_extra={'configuration_types': ['pgvector']})),
+            embedding_model=(Optional[str],
+                             Field(default=None,
+                                   description="Embedding configuration (required for tools `multi_url_crawler`)",
+                                   json_schema_extra={'configuration_model': 'embedding'})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __validators__={
@@ -65,9 +82,15 @@ class BrowserToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
 
-        wrapper_payload = {
+        wrapper_payload_google = {
             **kwargs,
             **kwargs.get('browser_configuration', {}),
+            **kwargs.get('pgvector_configuration', {}),
+        }
+
+        wrapper_payload_rag_based = {
+            **kwargs,
+            **kwargs.get('pgvector_configuration', {}),
         }
 
         tools = []
@@ -85,7 +108,7 @@ class BrowserToolkit(BaseToolkit):
             if tool == 'single_url_crawler':
                 tool_entry = SingleURLCrawler()
             elif tool == 'multi_url_crawler':
-                tool_entry = MultiURLCrawler()
+                tool_entry = MultiURLCrawler(**wrapper_payload_rag_based)
             elif tool == 'get_html_content':
                 tool_entry = GetHTMLContent()
             elif tool == 'get_pdf_content':
@@ -93,7 +116,7 @@ class BrowserToolkit(BaseToolkit):
             elif tool == 'google':
                 try:
                     google_api_wrapper = GoogleSearchAPIWrapper(
-                        **wrapper_payload
+                        **wrapper_payload_google
                     )
                     tool_entry = GoogleSearchResults(api_wrapper=google_api_wrapper)
                     # rename the tool to avoid conflicts

{alita_sdk-0.3.313 → alita_sdk-0.3.315}/alita_sdk/tools/browser/crawler.py

@@ -27,13 +27,16 @@ class MultiURLCrawler(BaseTool):
     max_response_size: int = 3000
     name: str = "multi_url_crawler"
     description: str = "Crawls multiple URLs and returns the content related to query"
+    embedding_model: str = None
+    connection_string: str = None
     args_schema: Type[BaseModel] = create_model("MultiURLCrawlerModel",
                                                 query=(str, Field(description="Query text to search pages")),
                                                 urls=(list[str], Field(description="list of URLs to search like ['url1', 'url2']")))
 
     def _run(self, query: str, urls: list[str], run_manager=None):
         urls = [url.strip() for url in urls]
-        return webRag(urls, self.max_response_size, query)
+        return webRag(urls=urls, max_response_size=self.max_response_size, query=query,
+                      connection_string=self.connection_string, embedding_model=self.embedding_model)
 
 
 class GetHTMLContent(BaseTool):

{alita_sdk-0.3.313 → alita_sdk-0.3.315}/alita_sdk/tools/browser/utils.py

@@ -6,9 +6,9 @@ from langchain.text_splitter import CharacterTextSplitter
 import fitz
 
 try:
-    from langchain_chroma import Chroma
+    from langchain_postgres import PGVector
 except ImportError:
-    Chroma = None
+    PGVector = None
 
 from langchain_community.embeddings.sentence_transformer import (
     SentenceTransformerEmbeddings,
@@ -32,13 +32,22 @@ def get_page(urls, html_only=False):
     return docs_transformed
 
 
-def webRag(urls, max_response_size, query):
-    if Chroma is None:
-        return "Chroma is not initialized. Web rag is not available."
+def webRag(urls, max_response_size, query, connection_string=None, embedding_model=None):
+    if PGVector is None:
+        return "PGVector is not initialized. Web rag is not available."
+
+    if not connection_string or not embedding_model:
+        return "Connection string or embedding model is missing. Web rag is not available."
     text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
     docs = text_splitter.split_documents(get_page(urls))
-    embedding_function = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")
-    db = Chroma.from_documents(docs, embedding_function)
+    embedding_function = SentenceTransformerEmbeddings(model_name=embedding_model)
+    db = PGVector.from_documents(
+        documents=docs,
+        embedding=embedding_function,
+        collection_name="web_rag",
+        pre_delete_collection=True,
+        connection=connection_string
+    )
     docs = db.search(query, "mmr", k=10)
     text = ""
     for doc in docs:

{alita_sdk-0.3.313 → alita_sdk-0.3.315}/alita_sdk/tools/memory/__init__.py

@@ -1,6 +1,6 @@
-from typing import Optional, List, Literal
+from typing import List, Literal
 
-from langchain_core.tools import BaseToolkit, BaseTool
+from langchain_core.tools import BaseToolkit, BaseTool, ToolException
 
 from alita_sdk.configurations.pgvector import PgVectorConfiguration
 
@@ -101,6 +101,8 @@ class MemoryToolkit(BaseToolkit):
             # The store is not provided, attempt to create it from configuration
             from ...runtime.langchain.store_manager import get_manager
             conn_str = (kwargs.get('pgvector_configuration') or {}).get('connection_string', '')
+            if not conn_str:
+                raise ToolException("Connection string is required to create PostgresStore for memory toolkit.")
             store = get_manager().get_store(conn_str)
         
         # Validate store type

{alita_sdk-0.3.313 → alita_sdk-0.3.315}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.313
+Version: 0.3.315
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.313 → alita_sdk-0.3.315}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.313"
+version = "0.3.315"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"