ws-bom-robot-app 0.0.84__py3-none-any.whl → 0.0.86__py3-none-any.whl

ws_bom_robot_app/config.py

@@ -36,11 +36,12 @@ class Settings(BaseSettings):
     OLLAMA_API_URL: str = 'http://localhost:11434'
     GROQ_API_KEY: str = ''
     GOOGLE_API_KEY: str = ''
+    GOOGLE_APPLICATION_CREDENTIALS: str = '' # path to google credentials iam file, e.d. ./.secrets/google-credentials.json
     WATSONX_URL: str = ''
     WATSONX_APIKEY: str = ''
     WATSONX_PROJECTID: str = ''
     NEBULY_API_URL: str ='https://backend.nebuly.com/'
-    GOOGLE_APPLICATION_CREDENTIALS: str = '' # path to google credentials iam file, e.d. ./.secrets/google-credentials.json
+    LANGSMITH_API_KEY: str = '' # app-wide api key to run evaluation
     model_config = ConfigDict(
         env_file='./.env',
         extra='ignore',
@@ -61,6 +62,7 @@ class Settings(BaseSettings):
         os.environ["WATSONX_APIKEY"] = self.WATSONX_APIKEY
         os.environ["WATSONX_PROJECTID"] = self.WATSONX_PROJECTID
         os.environ["NEBULY_API_URL"] = self.NEBULY_API_URL
+        os.environ["LANGSMITH_API_KEY"] = self.LANGSMITH_API_KEY
         # dir
         os.makedirs(self.robot_data_folder, exist_ok=True)
         for subfolder in [self.robot_data_db_folder, self.robot_data_attachment_folder, 'db']:

ws_bom_robot_app/cron_manager.py

@@ -56,9 +56,9 @@ class Job:
 
 class CronManager:
     _list_default = [
-            Job('cleanup-task-history',task_cleanup_history, interval=5 * 60),
-            Job('cleanup-kb-data',kb_cleanup_data_file, interval=180 * 60),
-            Job('cleanup-chat-attachment',chat_cleanup_attachment, interval=120 * 60),
+            Job('cleanup-task-history',task_cleanup_history, interval=4 * 60 * 60),
+            Job('cleanup-kb-data',kb_cleanup_data_file, interval=8 * 60 * 60),
+            Job('cleanup-chat-attachment',chat_cleanup_attachment, interval=6 * 60 * 60),
         ]
     def __get_jobstore_strategy(self) -> JobstoreStrategy:
         if config.robot_cron_strategy == 'memory':

ws_bom_robot_app/llm/api.py

@@ -1,7 +1,8 @@
-from typing import Annotated, Any, Mapping
+from typing import Annotated, Any, Mapping, Union
 from fastapi import APIRouter, HTTPException, Request, Header, Body
 from fastapi.responses import StreamingResponse
 from ws_bom_robot_app.llm.agent_description import AgentDescriptor
+from ws_bom_robot_app.llm.evaluator import EvaluatorRunRequest
 from ws_bom_robot_app.llm.models.api import InvokeRequest, StreamRequest, RulesRequest, KbRequest, VectorDbResponse
 from ws_bom_robot_app.llm.main import invoke, stream
 from ws_bom_robot_app.llm.models.base import IdentifiableEntity
@@ -52,7 +53,7 @@ async def _kb(rq: KbRequest) -> VectorDbResponse:
 
 @router.post("/kb/task")
 async def _kb_task(rq: KbRequest, headers: Annotated[TaskHeader, Header()]) -> IdentifiableEntity:
-    return task_manager.create_task(lambda: kb(rq),headers)
+    return task_manager.create_task(lambda: kb(rq),headers, queue="slow")
 
 @router.post("/rules")
 async def _rules(rq: RulesRequest) -> VectorDbResponse:
@@ -60,7 +61,7 @@ async def _rules(rq: RulesRequest) -> VectorDbResponse:
 
 @router.post("/rules/task")
 async def _rules_task(rq: RulesRequest, headers: Annotated[TaskHeader, Header()]) -> IdentifiableEntity:
-    return task_manager.create_task(lambda: rules(rq), headers)
+    return task_manager.create_task(lambda: rules(rq), headers, queue="fast")
 
 @router.get("/kb/file/{filename}")
 async def _kb_get_file(filename: str) -> StreamingResponse:
@@ -115,3 +116,64 @@ async def _send_feedback(feedback: FeedbackConfig):
     strategy: FeedbackInterface = strategy_cls(feedback)
     result = strategy.send_feedback()
     return {"result": result}
+
+#region evaluate
+@router.get("/evaluation/datasets", tags=["evaluation"])
+async def _evaluation_datasets():
+    from ws_bom_robot_app.llm.evaluator import EvaluatorDataSets
+    return [ds for ds in EvaluatorDataSets.all()]
+
+@router.post("/evaluation/datasets/find", tags=["evaluation"])
+async def _evaluation_find_datasets(project: str):
+    from ws_bom_robot_app.llm.evaluator import EvaluatorDataSets
+    return [ds for ds in EvaluatorDataSets.find(project)]
+
+@router.get("/evaluation/datasets/{id}", tags=["evaluation"])
+async def _evaluation_datasets_by_id(id: str):
+    from ws_bom_robot_app.llm.evaluator import EvaluatorDataSets
+    return EvaluatorDataSets.example(id)
+
+@router.get("/evaluation/evaluators", tags=["evaluation"])
+async def _evaluation_evaluators() -> list:
+    from ws_bom_robot_app.llm.evaluator import EvaluatorType
+    return EvaluatorType.all()
+
+@router.post("/evaluation/run", tags=["evaluation"])
+async def _evaluate(rq: EvaluatorRunRequest):
+    from ws_bom_robot_app.llm.evaluator import Evaluator, EvaluatorType
+    from langsmith.schemas import Dataset, Example
+
+    _data: Union[Dataset, list[Example]] = None
+    if rq.example and any(rq.example):
+        _examples: list[Example] = filter(lambda ex: str(ex.id) in [str(e.get("id")) for e in rq.example],
+                   await _evaluation_datasets_by_id(rq.example[0].get("dataset_id"))
+                   )
+
+        _data = list(_examples)
+    else:
+        _data = Dataset(**rq.dataset)
+    evaluator = Evaluator(
+        rq=rq.rq,
+        data=_data,
+        judge_model=rq.judge
+    )
+
+    if not rq.evaluators is None and any(rq.evaluators):
+        def __convert_evaluator_type(evaluator: str) -> EvaluatorType:
+            try:
+                return EvaluatorType[evaluator.upper()]
+            except KeyError:
+                pass
+        _evaluators = []
+        _evaluators.extend(__convert_evaluator_type(evaluator) for evaluator in rq.evaluators)
+        if not any(_evaluators):
+            _evaluators = None
+    else:
+        _evaluators = None
+    result = await evaluator.run(evaluators=_evaluators)
+    return result
+
+@router.post("/evaluation/run/task", tags=["evaluation"])
+async def _evaluate_task(rq: EvaluatorRunRequest, headers: Annotated[TaskHeader, Header()]) -> IdentifiableEntity:
+    return task_manager.create_task(lambda: _evaluate(rq), headers, queue="fast")
+#endregion evaluate

ws_bom_robot_app/llm/evaluator.py

@@ -0,0 +1,319 @@
+from uuid import UUID
+import requests, base64
+from typing import Iterator, Optional, List, Union
+from enum import Enum
+from ws_bom_robot_app.config import config
+from ws_bom_robot_app.llm.models.api import LlmMessage, StreamRequest
+from langsmith import Client, traceable
+from langsmith.schemas import Dataset, Example, Feedback, Run
+from openevals.llm import create_llm_as_judge
+from openevals.prompts import CORRECTNESS_PROMPT, RAG_HELPFULNESS_PROMPT, CONCISENESS_PROMPT, RAG_GROUNDEDNESS_PROMPT, HALLUCINATION_PROMPT
+from pydantic import BaseModel
+
+ls_client = Client()
+
+class EvaluatorType(Enum):
+    """Available evaluator types"""
+    CORRECTNESS = "correctness"
+    HELPFULNESS = "helpfulness"
+    CONCISENESS = "conciseness"
+    RAG_GROUNDEDNESS = "rag_groundedness"
+    RAG_HALLUCINATION = "rag_hallucination"
+
+    @classmethod
+    def all(cls) -> List['EvaluatorType']:
+        """Get all available evaluator types"""
+        return list(cls)
+
+    @classmethod
+    def default(cls) -> List['EvaluatorType']:
+        """Get default evaluator types"""
+        return [cls.CORRECTNESS]
+
+class EvaluatorDataSets:
+
+    @classmethod
+    def all(cls) -> List[Dataset]:
+        return list(ls_client.list_datasets())
+    @classmethod
+    def find(cls, name: str) -> List[Dataset]:
+        return [d for d in cls.all() if d.name.lower().__contains__(name.lower())]
+    @classmethod
+    def get(cls, id: Union[str, UUID]) -> Optional[Dataset]:
+        return next((d for d in cls.all() if str(d.id) == str(id)), None)
+    @classmethod
+    def create(cls, name: str) -> Dataset:
+        return ls_client.create_dataset(name=name)
+    @classmethod
+    def delete(cls, id: str) -> None:
+        ls_client.delete_dataset(id=id)
+    @classmethod
+    def example(cls, id: str) -> List[Example]:
+        return list(ls_client.list_examples(dataset_id=id, include_attachments=True))
+    @classmethod
+    def add_example(cls, dataset_id: str, inputs: dict, outputs: dict) -> Example:
+        """Add an example to the dataset.
+        Args:
+            inputs (dict): The input data for the example.
+            outputs (dict): The output data for the example.
+        Sample:
+            - inputs: {"question": "What is the capital of France?"}
+              outputs: {"answer": "Paris"}
+        """
+        return ls_client.create_example(dataset_id=dataset_id, inputs=inputs, outputs=outputs)
+    @classmethod
+    def feedback(cls, experiment_name: str) -> Iterator[Feedback]:
+        return ls_client.list_feedback(
+            run_ids=[r.id for r in ls_client.list_runs(project_name=experiment_name)]
+        )
+
+class Evaluator:
+    def __init__(self, rq: StreamRequest, data: Union[Dataset,List[Example]], judge_model: Optional[str] = None):
+        """Evaluator class for assessing model performance.
+
+        Args:
+            rq (StreamRequest): The request object containing input data.
+            data (Union[Dataset, List[Example]]): The dataset to use for evaluation or a list of examples.
+            judge_model (Optional[str], optional): The model to use for evaluation, defaults to "openai:o4-mini".
+              For a list of available models, see the LangChain documentation:
+              https://python.langchain.com/api_reference/langchain/chat_models/langchain.chat_models.base.init_chat_model.html
+        """
+        self.judge_model: str = judge_model or "openai:o4-mini"
+        self.data = data
+        self.rq: StreamRequest = rq
+
+    #region evaluators
+
+    def _get_evaluator_function(self, evaluator_type: EvaluatorType):
+        """Get the evaluator function for a given type"""
+        evaluator_map = {
+            EvaluatorType.CORRECTNESS: self.correctness_evaluator,
+            EvaluatorType.HELPFULNESS: self.helpfulness_evaluator,
+            EvaluatorType.CONCISENESS: self.conciseness_evaluator,
+            EvaluatorType.RAG_GROUNDEDNESS: self.rag_groundedness_evaluator,
+            EvaluatorType.RAG_HALLUCINATION: self.rag_hallucination_evaluator,
+        }
+        return evaluator_map.get(evaluator_type)
+
+    def correctness_evaluator(self, inputs: dict, outputs: dict, reference_outputs: dict):
+        evaluator = create_llm_as_judge(
+          prompt=CORRECTNESS_PROMPT,
+          feedback_key="correctness",
+          model=self.judge_model,
+          continuous=True,
+          choices=[i/10 for i in range(11)]
+        )
+        return evaluator(
+            inputs=inputs,
+            outputs=outputs,
+            reference_outputs=reference_outputs
+        )
+
+    def helpfulness_evaluator(self, inputs: dict, outputs: dict):
+        evaluator = create_llm_as_judge(
+            prompt=RAG_HELPFULNESS_PROMPT,
+            feedback_key="helpfulness",
+            model=self.judge_model,
+            continuous=True,
+            choices=[i/10 for i in range(11)]
+        )
+        return evaluator(
+            inputs=inputs,
+            outputs=outputs,
+        )
+
+    def conciseness_evaluator(self, inputs: dict, outputs: dict, reference_outputs: dict):
+        evaluator = create_llm_as_judge(
+            prompt=CONCISENESS_PROMPT,
+            feedback_key="conciseness",
+            model=self.judge_model,
+            continuous=True,
+            choices=[i/10 for i in range(11)]
+        )
+        return evaluator(
+            inputs=inputs,
+            outputs=outputs,
+            reference_outputs=reference_outputs
+        )
+
+    def _find_retrievers(self, run: Run) -> List[Run]:
+      retrievers = []
+      for child in getattr(run, "child_runs", []):
+        if child.run_type == "retriever":
+          retrievers.append(child)
+        retrievers.extend(self._find_retrievers(child))
+      return retrievers
+
+    def _retriever_documents(self, retrievers_run: List[Run]) -> str:
+      unique_contents = set()
+      for r in retrievers_run:
+        for doc in r.outputs.get("documents", []):
+          unique_contents.add(doc.page_content)
+      return "\n\n".join(unique_contents)
+
+    def rag_groundedness_evaluator(self, run: Run):
+        evaluator = create_llm_as_judge(
+            prompt=RAG_GROUNDEDNESS_PROMPT,
+            feedback_key="rag_groundedness",
+            model=self.judge_model,
+            continuous=True,
+            choices=[i/10 for i in range(11)]
+        )
+        retrievers_run = self._find_retrievers(run)
+        if retrievers_run:
+            try:
+                return evaluator(
+                    outputs=run.outputs["answer"],
+                    context=self._retriever_documents(retrievers_run)
+                )
+            except Exception as e:
+                return 0.0
+        else:
+            return 0.0
+
+    def rag_hallucination_evaluator(self, inputs: dict, outputs: dict, reference_outputs: dict, run: Run):
+        evaluator = create_llm_as_judge(
+            prompt=HALLUCINATION_PROMPT,
+            feedback_key="rag_hallucination",
+            model=self.judge_model,
+            continuous=True,
+            choices=[i/10 for i in range(11)]
+        )
+        retrievers_run = self._find_retrievers(run)
+        if retrievers_run:
+            try:
+                return evaluator(
+                    inputs=inputs['question'],
+                    outputs=outputs['answer'],
+                    reference_outputs=reference_outputs['answer'],
+                    context=self._retriever_documents(retrievers_run)
+                )
+            except Exception as e:
+                return 0.0
+        else:
+            return 0.0
+
+    #endregion evaluators
+
+    #region target
+    def _parse_rq(self, inputs: dict, attachments: dict) -> StreamRequest:
+        _rq = self.rq.__deepcopy__()
+        if not attachments is None and len(attachments) > 0:
+            _content = []
+            _content.append({"type": "text", "text": inputs["question"]})
+            for k,v in attachments.items():
+                if isinstance(v, dict):
+                    _content.append({"type": ("image" if "image" in v.get("mime_type","") else "file"), "url": v.get("presigned_url","")})
+            _rq.messages = [LlmMessage(role="user", content=_content)]
+        else:
+            _rq.messages = [LlmMessage(role="user", content=inputs["question"])]
+        return _rq
+
+    @traceable(run_type="chain",name="stream_internal")
+    async def target_internal(self,inputs: dict, attachments: dict) -> dict:
+      from ws_bom_robot_app.llm.main import stream
+      from unittest.mock import Mock
+      from fastapi import Request
+      _ctx = Mock(spec=Request)
+      _ctx.base_url.return_value = "http://evaluator"
+      _rq = self._parse_rq(inputs, attachments)
+      _chunks = []
+      async for chunk in stream(rq=_rq, ctx=_ctx, formatted=False):
+          _chunks.append(chunk)
+      _content = ''.join(_chunks) if _chunks else ""
+      del _rq, _chunks
+      return { "answer": _content.strip() }
+
+    @traceable(run_type="chain",name="stream_http")
+    async def target_http(self,inputs: dict, attachments: dict) -> dict:
+      _rq = self._parse_rq(inputs, attachments)
+      _host= "http://localhost:6001"
+      _endpoint = f"{_host}/api/llm/stream/raw"
+      _robot_auth =f"Basic {base64.b64encode((config.robot_user + ':' + config.robot_password).encode('utf-8')).decode('utf-8')}"
+      _rs = requests.post(_endpoint, data=_rq.model_dump_json(), stream=True, headers={"Authorization": _robot_auth}, verify=True)
+      _content = ''.join([chunk.decode('utf-8') for chunk in _rs.iter_content(chunk_size=1024, decode_unicode=False)])
+      del _rq, _rs
+      return { "answer": _content.strip() }
+    #endregion target
+
+    async def run(self,
+                  evaluators: Optional[List[EvaluatorType]] = None,
+                  target_method: str = "target_internal") -> dict:
+        """Run evaluation with specified evaluators
+
+        Args:
+            evaluators: List of evaluator types to use. If None, uses default (correctness only)
+            target_method: Method to use for target evaluation ("target_internal" or "target")
+
+        Returns:
+            dict: Evaluation results with scores
+
+        Usage:
+          ```
+          await evaluator.run()  # Uses default (correctness only)
+          await evaluator.run([EvaluatorType.CORRECTNESS, EvaluatorType.HELPFULNESS])
+          await evaluator.run(EvaluatorType.all())  # Uses all available evaluators
+          ```
+        """
+        try:
+          # evaluator functions
+          evaluator_functions = []
+          if evaluators is None:
+              evaluators = EvaluatorType.default()
+          for eval_type in evaluators:
+              func = self._get_evaluator_function(eval_type)
+              if func:
+                  evaluator_functions.append(func)
+              else:
+                  print(f"Warning: Unknown evaluator type: {eval_type}")
+          if not evaluator_functions:
+              print("No valid evaluators provided, using default (correctness)")
+              evaluator_functions = [self.correctness_evaluator]
+
+          # target method
+          target_func = getattr(self, target_method, self.target_internal)
+
+          # run
+          _dataset: Dataset = self.data if isinstance(self.data, Dataset) else EvaluatorDataSets.get(self.data[0].dataset_id)
+          experiment = await ls_client.aevaluate(
+              target_func,
+              data=_dataset.name if isinstance(self.data, Dataset) else self.data,
+              evaluators=evaluator_functions,
+              experiment_prefix=_dataset.name,
+              upload_results=True,
+              max_concurrency=4,
+              metadata={
+                  "app": _dataset.name,
+                  "model": f"{self.rq.provider}:{self.rq.model}",
+                  "judge": self.judge_model,
+                  "evaluators": [e.value for e in evaluators]
+              }
+          )
+          feedback = list(EvaluatorDataSets.feedback(experiment.experiment_name))
+          scores = [f.score for f in feedback]
+          url = f"{ls_client._host_url}/o/{ls_client._tenant_id}/datasets/{_dataset.id}/compare?selectedSessions={feedback[0].session_id}"
+
+          # group scores by evaluator type
+          evaluator_scores = {}
+          for i, eval_type in enumerate(evaluators):
+              eval_scores = [f.score for f in feedback if f.key.lower() == eval_type.value.lower()]
+              if eval_scores:
+                  evaluator_scores[eval_type.value] = sum(eval_scores) / len(eval_scores)
+
+          return {
+              "experiment": {"name": experiment.experiment_name, "url": url},
+              "overall_score": sum(scores) / len(scores) if scores else 0,
+              "evaluator_scores": evaluator_scores
+          }
+        except Exception as e:
+            from traceback import print_exc
+            print(f"Error occurred during evaluation: {e}")
+            print_exc()
+            return {"error": str(e)}
+
+class EvaluatorRunRequest(BaseModel):
+    dataset: dict
+    rq: StreamRequest
+    example: Optional[List[dict]] = None
+    evaluators: Optional[List[str]] = None
+    judge: Optional[str] = None

ws_bom_robot_app/llm/models/api.py

@@ -163,7 +163,7 @@ class LlmApp(BaseModel):
       return list(set(
           os.path.basename(db) for db in [self.vector_db] +
           ([self.rules.vector_db] if self.rules and self.rules.vector_db else []) +
-          [db for tool in (self.app_tools or []) for db in [tool.vector_db]]
+          [db for tool in (self.app_tools or []) for db in [tool.vector_db] if tool.is_active]
           if db is not None
       ))
   def __decompress_zip(self,zip_file_path, extract_to):

ws_bom_robot_app/llm/providers/llm_manager.py

@@ -1,4 +1,5 @@
 from typing import Optional
+from urllib.parse import urlparse
 from langchain_core.embeddings import Embeddings
 from langchain_core.language_models import BaseChatModel
 from pydantic import BaseModel, ConfigDict, Field
@@ -69,7 +70,8 @@ class Anthropic(LlmInterface):
             model=self.config.model,
             temperature=self.config.temperature,
             max_tokens=8192,
-            streaming=True
+            streaming=True,
+            #betas=["files-api-2025-04-14"] #https://docs.anthropic.com/en/docs/build-with-claude/files
         )
 
     """
@@ -86,15 +88,24 @@ class Anthropic(LlmInterface):
         response = client.models.list()
         return response.data
 
+    """
     async def _format_multimodal_image_message(self, message: dict) -> dict:
         file = await Base64File.from_url(message.get("url"))
         return { "type": "image_url", "image_url": { "url": file.base64_url }}
+    """
+
+    #https://python.langchain.com/docs/integrations/chat/anthropic/
+    #https://python.langchain.com/docs/how_to/multimodal_inputs/
     async def _format_multimodal_file_message(self, message: dict, file: Base64File = None) -> dict:
-        _file = file or await Base64File.from_url(message.get("url"))
-        if _file.extension in ["pdf"]:
-            return {"type": "document", "source": {"type": "base64", "media_type": _file.mime_type, "data": _file.base64_content}}
+        _url = str(message.get("url", "")).lower()
+        if _url.startswith("http") and any(urlparse(_url).path.endswith(ext) for ext in [".pdf"]):
+            return {"type": "file", "source_type": "url", "url": _url}
         else:
-          return await super()._format_multimodal_file_message(message, _file)
+          _file = file or await Base64File.from_url(_url)
+          if _file.extension in ["pdf"]:
+            return {"type": "document", "source": {"type": "base64", "media_type": _file.mime_type, "data": _file.base64_content}}
+          else:
+            return await super()._format_multimodal_file_message(message, _file)
 
 class OpenAI(LlmInterface):
     def __init__(self, config: LlmConfig):
@@ -188,7 +199,7 @@ class Google(LlmInterface):
         else:
           return await super()._format_multimodal_file_message(message, _file)
 
-class Gvertex(LlmInterface):
+class GoogleVertex(LlmInterface):
     def get_llm(self):
         from langchain_google_vertexai  import ChatVertexAI
         return ChatVertexAI(
@@ -332,7 +343,7 @@ class Ollama(LlmInterface):
         from langchain_ollama.embeddings import OllamaEmbeddings
         return OllamaEmbeddings(
             base_url=self.__base_url,
-            model="nomic-embed-text" #mxbai-embed-large
+            model="mxbai-embed-large" #nomic-embed-text
         )
     def get_models(self):
         import requests
@@ -354,13 +365,20 @@ class Ollama(LlmInterface):
         return { "type": "image_url", "image_url": { "url": file.base64_url }}
 
 class LlmManager:
+    """
+    Expose the available LLM providers.
+    Names are aligned with the LangChain documentation:
+    https://python.langchain.com/api_reference/langchain/chat_models/langchain.chat_models.base.init_chat_model.html
+    """
 
     #class variables (static)
     _list: dict[str,LlmInterface] = {
         "anthropic": Anthropic,
         "deepseek": DeepSeek,
-        "google": Google,
-        "gvertex": Gvertex,
+        "google": Google, #deprecated
+        "google_genai": Google,
+        "gvertex": GoogleVertex,#deprecated
+        "google_vertexai": GoogleVertex,
         "groq": Groq,
         "ibm": IBM,
         "openai": OpenAI,

ws_bom_robot_app/llm/utils/cleanup.py

@@ -1,7 +1,6 @@
 import os, logging
 from ws_bom_robot_app.config import config
 from datetime import datetime, timedelta
-from ws_bom_robot_app.task_manager import task_manager
 
 def _cleanup_data_file(folders: list[str], retention: float) -> dict:
     """
@@ -78,4 +77,5 @@ def task_cleanup_history() -> None:
     """
     clean up task queue
     """
+    from ws_bom_robot_app.task_manager import task_manager
     task_manager.cleanup_task()

ws_bom_robot_app/llm/utils/download.py

@@ -1,3 +1,4 @@
+import httpx
 from typing import List,Optional
 import os, logging, aiohttp, asyncio, hashlib, json
 import uuid
@@ -34,14 +35,13 @@ async def download_file(url: str, destination: str, chunk_size: int = 8192, auth
       # Ensure the destination directory exists
       os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
 
-      async with aiohttp.ClientSession() as session:
+      async with httpx.AsyncClient(timeout=30.0) as client:
           if authorization:
             headers = {'Authorization': authorization}
-            session.headers.update(headers)
-          async with session.get(url) as response:
+          async with client.stream("GET", url, headers=headers) as response:
               # Check if the request was successful
-              if response.status != 200:
-                  logging.error(f"Failed to download file. Status code: {response.status}")
+              if response.status_code != 200:
+                  logging.error(f"Failed to download file. Status code: {response.status_code}")
                   return None
 
               # Get the total file size if available
@@ -55,7 +55,7 @@ async def download_file(url: str, destination: str, chunk_size: int = 8192, auth
                       unit_scale=True,
                       unit_divisor=1024
                   ) as pbar:
-                      async for chunk in response.content.iter_chunked(chunk_size):
+                      async for chunk in response.aiter_bytes(chunk_size):
                           if chunk:
                               f.write(chunk)
                               pbar.update(len(chunk))
@@ -63,7 +63,7 @@ async def download_file(url: str, destination: str, chunk_size: int = 8192, auth
               logging.info(f"File downloaded successfully to {destination}")
               return destination
 
-  except aiohttp.ClientError as e:
+  except httpx.RequestError as e:
       logging.error(f"Network error occurred: {str(e)}")
       return None
   except asyncio.TimeoutError:
@@ -147,21 +147,21 @@ class Base64File(BaseModel):
       try:
           if _content := await from_cache(url):
               return _content
-          async with aiohttp.ClientSession() as session:
-            async with session.get(url, timeout=aiohttp.ClientTimeout(total=30), headers={"User-Agent": "Mozilla/5.0"}) as response:
-              print(f"Downloading {url} - Status: {response.status}")
-              response.raise_for_status()
-              content = await response.read()
-          # mime type detection
-          mime_type = response.headers.get('content-type', '').split(';')[0]
-          if not mime_type:
-              mime_type, _ = mimetypes.guess_type(urlparse(url).path)
-          if not mime_type:
-              mime_type = 'application/octet-stream'
-          # to base64
-          base64_content = base64.b64encode(content).decode('utf-8')
-          name = url.split('/')[-1]
-          extension = name.split('.')[-1]
+          async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(url, headers={"User-Agent": "Mozilla/5.0"})
+            logging.info(f"Downloading {url} - Status: {response.status_code}")
+            response.raise_for_status()
+            content = response.read()
+            # mime type detection
+            mime_type = response.headers.get('content-type', '').split(';')[0]
+            if not mime_type:
+                mime_type, _ = mimetypes.guess_type(urlparse(url).path)
+            if not mime_type:
+                mime_type = 'application/octet-stream'
+            # to base64
+            base64_content = base64.b64encode(content).decode('utf-8')
+            name = url.split('/')[-1]
+            extension = name.split('.')[-1]
       except Exception as e:
           _error = f"Failed to download file from {url}: {e}"
           logging.error(_error)

ws_bom_robot_app/llm/vector_store/loader/base.py

@@ -113,6 +113,38 @@ class Loader():
 
   #@timer
   async def load(self) -> list[Document]:
+    #region log
+    import warnings
+    warnings.filterwarnings("ignore", message=".*pin_memory.*no accelerator is found.*")
+    log_msg_to_ignore = [
+        "Going to convert document batch...",
+        "Initializing pipeline for",
+        "Accelerator device:",
+        "detected formats:",
+    ]
+    class MessageFilter(logging.Filter):
+        def __init__(self, patterns):
+            super().__init__()
+            self.log_msg_to_ignore = patterns
+
+        def filter(self, record):
+            for pattern in self.log_msg_to_ignore:
+                if pattern in record.getMessage():
+                    return False
+            return True
+    message_filter = MessageFilter(log_msg_to_ignore)
+    loggers_to_filter = [
+        'docling',
+        'docling.document_converter',
+        'docling.datamodel',
+        'docling.datamodel.document',
+        'docling.utils.accelerator_utils',
+        'unstructured'
+    ]
+    for logger_name in loggers_to_filter:
+        logging.getLogger(logger_name).addFilter(message_filter)
+    #endregion log
+
     MAX_RETRIES = 3
     loaders: MergedDataLoader = MergedDataLoader(self.__directory_loader())
     try:
@@ -132,5 +164,8 @@ class Loader():
         finally:
            del _documents
     finally:
+      # Remove logging filters
+      for logger_name in loggers_to_filter:
+          logging.getLogger(logger_name).removeFilter(message_filter)
       del loaders
       gc.collect()

ws_bom_robot_app/main.py

@@ -1,157 +1,156 @@
 import datetime
-import platform
-from fastapi.responses import FileResponse
-import uvicorn, os, sys
-from fastapi import FastAPI, Depends
-from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
-from fastapi.openapi.utils import get_openapi
-from ws_bom_robot_app.auth import authenticate
-from ws_bom_robot_app.config import config
-from ws_bom_robot_app.llm.api import router as llm
-from ws_bom_robot_app.task_manager import router as task
-from ws_bom_robot_app.cron_manager import (
-    router as cron,
-    cron_manager)
-from ws_bom_robot_app.util import _log
-
+from fastapi import FastAPI
+from ws_bom_robot_app.util import is_app_subprocess
 _uptime = datetime.datetime.now()
-cron_manager.start()
 app = FastAPI(redoc_url=None,docs_url=None,openapi_url=None)
-app.include_router(llm,dependencies=[Depends(authenticate)])
-app.include_router(task,dependencies=[Depends(authenticate)])
-app.include_router(cron,dependencies=[Depends(authenticate)])
 
-@app.get("/")
-async def root():
-    return health()
-@app.get("/favicon.ico")
-async def favicon():
-    return FileResponse("./favicon.ico")
+if not is_app_subprocess():
+  import platform
+  from fastapi.responses import FileResponse
+  import os, sys
+  from fastapi import Depends
+  from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
+  from fastapi.openapi.utils import get_openapi
+  from ws_bom_robot_app.auth import authenticate
+  from ws_bom_robot_app.config import config
+  from ws_bom_robot_app.util import _log
+  from ws_bom_robot_app.llm.api import router as llm
+  from ws_bom_robot_app.task_manager import router as task
+  from ws_bom_robot_app.cron_manager import (
+      router as cron,
+      cron_manager)
+  cron_manager.start()
+  app.include_router(llm,dependencies=[Depends(authenticate)])
+  app.include_router(task,dependencies=[Depends(authenticate)])
+  app.include_router(cron,dependencies=[Depends(authenticate)])
 
-@app.get("/docs", include_in_schema=False)
-async def get_swagger_documentation(authenticate: bool = Depends(authenticate)):
-    return get_swagger_ui_html(openapi_url="/openapi.json", title="docs")
-@app.get("/redoc", include_in_schema=False)
-async def get_redoc_documentation(authenticate: bool = Depends(authenticate)):
-    return get_redoc_html(openapi_url="/openapi.json", title="docs")
-@app.get("/openapi.json", include_in_schema=False)
-async def openapi(authenticate: bool = Depends(authenticate)):
-    return get_openapi(title=app.title, version=app.version, routes=app.routes)
+  @app.get("/")
+  async def root():
+      return health()
+  @app.get("/favicon.ico")
+  async def favicon():
+      return FileResponse("./favicon.ico")
 
-@app.get("/api/health",tags=["diag"])
-def health():
-    return {"status": "ok"}
-def __get_size(bytes, suffix="B"):
-    """
-    Scale bytes to its proper format
-    e.g:
-        1253656 => '1.20MB'
-        1253656678 => '1.17GB'
-    """
-    factor = 1024
-    for unit in ["", "K", "M", "G", "T", "P"]:
-        if bytes < factor:
-            return f"{bytes:.2f}{unit}{suffix}"
-        bytes /= factor
-def __get_disk_info():
-    import psutil
-    partitions = psutil.disk_partitions()
-    _disks:list = []
-    for partition in partitions:
-        device = partition.device
-        mountpoint = partition.mountpoint
-        fstype = partition.fstype
-        try:
-            usage = psutil.disk_usage(mountpoint)
-        except PermissionError:
-            continue
-        total = __get_size(usage.total)
-        used = __get_size(usage.used)
-        free = __get_size(usage.free)
-        percent = f"{usage.percent}%"
-        _disks.append({"device": device, "mountpoint": mountpoint, "fstype": fstype, "total": total, "used": used, "free": free, "percent": percent})
-    return _disks
-@app.get("/api/diag",tags=["diag"])
-def diag(authenticate: bool = Depends(authenticate)):
-    import importlib,psutil
-    from ws_bom_robot_app.llm.providers.llm_manager import LlmManager as wsllm
-    from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager as wsdb
-    from ws_bom_robot_app.llm.vector_store.loader.base import Loader as wsldr
-    from ws_bom_robot_app.llm.vector_store.integration.manager import IntegrationManager as wsim
-    from ws_bom_robot_app.llm.tools.tool_manager import ToolManager as wstm
-    from ws_bom_robot_app.llm.agent_description import AgentDescriptor as wsad
+  @app.get("/docs", include_in_schema=False)
+  async def get_swagger_documentation(authenticate: bool = Depends(authenticate)):
+      return get_swagger_ui_html(openapi_url="/openapi.json", title="docs")
+  @app.get("/redoc", include_in_schema=False)
+  async def get_redoc_documentation(authenticate: bool = Depends(authenticate)):
+      return get_redoc_html(openapi_url="/openapi.json", title="docs")
+  @app.get("/openapi.json", include_in_schema=False)
+  async def openapi(authenticate: bool = Depends(authenticate)):
+      return get_openapi(title=app.title, version=app.version, routes=app.routes)
 
-    svmem = psutil.virtual_memory()
-    swap = psutil.swap_memory()
-    try:
-      ws_bom_robot_app_version = importlib.metadata.version("ws_bom_robot_app")
-    except:
-      ws_bom_robot_app_version = "unknown"
-    peer_process_ids = [c.pid for c in psutil.Process(os.getppid()).children()] if config.runtime_options().is_multi_process else None
-    return {
-        "status":"ok",
-        "uptime": {'from':_uptime,'elapsed':str(datetime.datetime.now()-_uptime)},
-        "system": {
-            "platform": {
-                "node": platform.node(),
-                "system": platform.system(),
-                "platform": platform.platform(),
-                "version": platform.version(),
-                "type": platform.machine(),
-                "processor": platform.processor(),
-                "architecture": platform.architecture()
-            },
-            "cpu": {
-                "physical_core": psutil.cpu_count(logical=False),
-                "total_core": psutil.cpu_count(logical=True),
-                "load": f"{psutil.cpu_percent(interval=1)}%"
-            },
-            "memory": {
-                "total": f"{__get_size(svmem.total)}",
-                "available": f"{__get_size(svmem.available)}",
-                "used": f"{__get_size(svmem.used)}",
-                "free": f"{__get_size(svmem.free)}",
-                "percent": f"{svmem.percent}%"
-            },
-            "swap": {
-                "total": f"{__get_size(swap.total)}",
-                "used": f"{__get_size(swap.used)}",
-                "free": f"{__get_size(swap.free)}",
-                "percent": f"{swap.percent}%"
-            },
-            "disk": __get_disk_info(),
-            "sys": {
-                "version": sys.version,
-                "platform": sys.platform,
-                "executable": sys.executable,
-                "args": {k: arg for k, arg in enumerate(sys.argv)}
-            },
-            "os": {
-                "ppid": os.getppid(),
-                "pid": os.getpid(),
-                "pids": peer_process_ids,
-                "cwd": os.getcwd(),
-                "ws_bom_robot_app": ws_bom_robot_app_version,
-                "env": os.environ,
-            },
-        },
-        "config":config,
-        "runtime":config.runtime_options(),
-        "extension": {
-            "provider":({item[0]: type(item[1]).__name__} for item in wsllm._list.items()),
-            "db":({item[0]: type(item[1]).__name__} for item in wsdb._list.items()),
-            "loader": ({item[0]: item[1].loader.__name__ if item[1] else None} for item in sorted(wsldr._list.items(), key=lambda x: x[0]) if item[1]),
-            "integration":({item[0]: type(item[1]).__name__} for item in wsim._list.items()),
-            "tool": ({item[0]: item[1].function.__name__} for item in wstm._list.items()),
-            "agent":({item[0]: type(item[1]).__name__} for item in wsad._list.items())
-            }
-        }
-@app.post("/diag/reload",tags=["diag"])
-def reset(authenticate: bool = Depends(authenticate)):
-    _log.info("restart server")
-    with open(".reloadfile","w") as f:
-        f.write("")
+  @app.get("/api/health",tags=["diag"])
+  def health():
+      return {"status": "ok"}
+  def __get_size(bytes, suffix="B"):
+      """
+      Scale bytes to its proper format
+      e.g:
+          1253656 => '1.20MB'
+          1253656678 => '1.17GB'
+      """
+      factor = 1024
+      for unit in ["", "K", "M", "G", "T", "P"]:
+          if bytes < factor:
+              return f"{bytes:.2f}{unit}{suffix}"
+          bytes /= factor
+  def __get_disk_info():
+      import psutil
+      partitions = psutil.disk_partitions()
+      _disks:list = []
+      for partition in partitions:
+          device = partition.device
+          mountpoint = partition.mountpoint
+          fstype = partition.fstype
+          try:
+              usage = psutil.disk_usage(mountpoint)
+          except PermissionError:
+              continue
+          total = __get_size(usage.total)
+          used = __get_size(usage.used)
+          free = __get_size(usage.free)
+          percent = f"{usage.percent}%"
+          _disks.append({"device": device, "mountpoint": mountpoint, "fstype": fstype, "total": total, "used": used, "free": free, "percent": percent})
+      return _disks
+  @app.get("/api/diag",tags=["diag"])
+  def diag(authenticate: bool = Depends(authenticate)):
+      import importlib,psutil
+      from ws_bom_robot_app.llm.providers.llm_manager import LlmManager as wsllm
+      from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager as wsdb
+      from ws_bom_robot_app.llm.vector_store.loader.base import Loader as wsldr
+      from ws_bom_robot_app.llm.vector_store.integration.manager import IntegrationManager as wsim
+      from ws_bom_robot_app.llm.tools.tool_manager import ToolManager as wstm
+      from ws_bom_robot_app.llm.agent_description import AgentDescriptor as wsad
 
-# Start the FastAPI server
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=6001, env_file="../.env", reload=True, log_level="debug")
+      svmem = psutil.virtual_memory()
+      swap = psutil.swap_memory()
+      try:
+        ws_bom_robot_app_version = importlib.metadata.version("ws_bom_robot_app")
+      except:
+        ws_bom_robot_app_version = "unknown"
+      peer_process_ids = [c.pid for c in psutil.Process(os.getppid()).children()] if config.runtime_options().is_multi_process else None
+      return {
+          "status":"ok",
+          "uptime": {'from':_uptime,'elapsed':str(datetime.datetime.now()-_uptime)},
+          "system": {
+              "platform": {
+                  "node": platform.node(),
+                  "system": platform.system(),
+                  "platform": platform.platform(),
+                  "version": platform.version(),
+                  "type": platform.machine(),
+                  "processor": platform.processor(),
+                  "architecture": platform.architecture()
+              },
+              "cpu": {
+                  "physical_core": psutil.cpu_count(logical=False),
+                  "total_core": psutil.cpu_count(logical=True),
+                  "load": f"{psutil.cpu_percent(interval=1)}%"
+              },
+              "memory": {
+                  "total": f"{__get_size(svmem.total)}",
+                  "available": f"{__get_size(svmem.available)}",
+                  "used": f"{__get_size(svmem.used)}",
+                  "free": f"{__get_size(svmem.free)}",
+                  "percent": f"{svmem.percent}%"
+              },
+              "swap": {
+                  "total": f"{__get_size(swap.total)}",
+                  "used": f"{__get_size(swap.used)}",
+                  "free": f"{__get_size(swap.free)}",
+                  "percent": f"{swap.percent}%"
+              },
+              "disk": __get_disk_info(),
+              "sys": {
+                  "version": sys.version,
+                  "platform": sys.platform,
+                  "executable": sys.executable,
+                  "args": {k: arg for k, arg in enumerate(sys.argv)}
+              },
+              "os": {
+                  "ppid": os.getppid(),
+                  "pid": os.getpid(),
+                  "pids": peer_process_ids,
+                  "cwd": os.getcwd(),
+                  "ws_bom_robot_app": ws_bom_robot_app_version,
+                  "env": os.environ,
+              },
+          },
+          "config":config,
+          "runtime":config.runtime_options(),
+          "extension": {
+              "provider":({item[0]: type(item[1]).__name__} for item in wsllm._list.items()),
+              "db":({item[0]: type(item[1]).__name__} for item in wsdb._list.items()),
+              "loader": ({item[0]: item[1].loader.__name__ if item[1] else None} for item in sorted(wsldr._list.items(), key=lambda x: x[0]) if item[1]),
+              "integration":({item[0]: type(item[1]).__name__} for item in wsim._list.items()),
+              "tool": ({item[0]: item[1].function.__name__} for item in wstm._list.items()),
+              "agent":({item[0]: type(item[1]).__name__} for item in wsad._list.items())
+              }
+          }
+  @app.post("/diag/reload",tags=["diag"])
+  def reset(authenticate: bool = Depends(authenticate)):
+      _log.info("restart server")
+      with open(".reloadfile","w") as f:
+          f.write("")

ws_bom_robot_app/subprocess_runner.py

@@ -12,6 +12,9 @@ def _worker_run_pickled(serialized_task: bytes, conn: Connection):
     capture return value or exception and send back via conn.send((ok_flag, payload_serialized)).
     This runs in a separate process and must be top-level for multiprocessing.
     """
+    import os
+    # mark as a subprocess
+    os.environ['IS_ROBOT_APP_SUBPROCESS'] = 'true'
     try:
         if _pickler is None:
             raise RuntimeError("No pickler available in worker process.")

ws_bom_robot_app/task_manager.py

@@ -79,6 +79,7 @@ class TaskEntry(IdentifiableEntity):
     coroutine: Any = None
     headers: TaskHeader | None = None
     status: Union[TaskStatus, None] = None
+    queue: Literal["slow", "fast"] | None = "slow"
     def _get_coroutine_name(self, func: Any) -> str:
         if inspect.iscoroutine(func):
             return func.cr_code.co_name
@@ -120,7 +121,7 @@ class TaskStatistics(BaseModel):
     class TaskStatisticExecutionInfo(BaseModel):
         retention_days: float = config.robot_task_retention_days
         max_parallelism: int
-        slot_available: int
+        slot_available: dict[str,int]
         pid: int = os.getpid()
         running: list[TaskStatus]
         slowest: list
@@ -144,12 +145,12 @@ class TaskManagerStrategy(ABC):
             workers = config.runtime_options().number_of_workers
             max_concurrent_tasks = max(1, floor(config.robot_task_max_total_parallelism / max(1, workers)))
         self.max_parallelism = max_concurrent_tasks
-        self.semaphore = asyncio.Semaphore(max_concurrent_tasks)
+        self.semaphore = {"slow": asyncio.Semaphore(max_concurrent_tasks), "fast": asyncio.Semaphore(max_concurrent_tasks*2)}
         self.running_tasks = dict[str, TaskEntry]()
         self.loop = asyncio.get_event_loop()
 
     @abstractmethod
-    def create_task(self, coroutine, headers: TaskHeader | None = None) -> IdentifiableEntity:
+    def create_task(self, coroutine, headers: TaskHeader | None = None, queue: Literal["slow", "fast"] | None = "slow") -> IdentifiableEntity:
         """Create a new task.
         Args:
             coroutine (_type_): coroutine or callable to be executed.
@@ -160,6 +161,7 @@ class TaskManagerStrategy(ABC):
             from ws_bom_robot_app.task_manager import task_manager
             task_manager.create_task(my_coroutine, headers=my_headers) -> coroutine executed in-process
             task_manager.create_task(lambda: my_coroutine, headers=my_headers) -> callable using subprocess
+            task_manager.create_task(lambda: my_coroutine, headers=my_headers, queue="fast") -> callable using subprocess with "fast" queue
         """
         pass
 
@@ -227,7 +229,7 @@ class TaskManagerStrategy(ABC):
                 self._update_task_by_event(task_entry, "callback", None)
         return callback
 
-    def create_task_entry(self, coroutine_or_callable: Any, headers: TaskHeader | None = None) -> TaskEntry:
+    def create_task_entry(self, coroutine_or_callable: Any, headers: TaskHeader | None = None, queue: Literal["slow", "fast"] | None = "slow") -> TaskEntry:
         """Create a new task entry.
 
         Args:
@@ -251,7 +253,9 @@ class TaskManagerStrategy(ABC):
         task_entry = TaskEntry(
             id=_id,
             coroutine=coroutine_or_callable,
-            headers=headers)
+            headers=headers,
+            queue=queue
+        )
         # Store hint for subprocess capability
         task_entry.status.metadata.extra = task_entry.status.metadata.extra or {}
         task_entry.status.metadata.extra["can_use_subprocess"] = can_use_subprocess
@@ -263,7 +267,7 @@ class TaskManagerStrategy(ABC):
 
     async def _run_task_with_semaphore(self, task_entry: TaskEntry):
         """Run a task with semaphore control to limit concurrency."""
-        async with self.semaphore:
+        async with self.semaphore[task_entry.queue]:
           await self._execute_task(task_entry)
 
     async def _monitor_subprocess(self, task_entry: TaskEntry, proc, conn):
@@ -291,7 +295,7 @@ class TaskManagerStrategy(ABC):
                 _log.warning(f"Task {task_entry.id} failure, retrying {task_entry.status.retry}...")
                 async def delayed_retry():
                     _delay = config.robot_task_mp_retry_delay # help to backpressure when overloaded
-                    if self.semaphore._value > 0:  # free semaphore slots available
+                    if self.semaphore[task_entry.queue]._value > 0:  # free semaphore slots available
                         _delay = 5  # small/no delay if retry can run immediately
                     await asyncio.sleep(_delay)  # delay in seconds
                     await self._run_task_with_semaphore(task_entry)
@@ -392,7 +396,7 @@ class TaskManagerStrategy(ABC):
             exec_info=TaskStatistics.TaskStatisticExecutionInfo(
                 retention_days=config.robot_task_retention_days,
                 max_parallelism=self.max_parallelism,
-                slot_available=self.semaphore._value,
+                slot_available={queue: self.semaphore[queue]._value for queue in self.semaphore},
                 running=[task.status for task in self.running_task()],
                 slowest=_slowest
             )
@@ -406,8 +410,8 @@ class MemoryTaskManagerStrategy(TaskManagerStrategy):
         super().__init__(max_concurrent_tasks)
         self.tasks: Dict[str, TaskEntry] = {}
 
-    def create_task(self, coroutine: Any, headers: TaskHeader | None = None) -> IdentifiableEntity:
-        task = self.create_task_entry(coroutine, headers)
+    def create_task(self, coroutine: Any, headers: TaskHeader | None = None, queue: Literal["slow", "fast"] | None = "slow") -> IdentifiableEntity:
+        task = self.create_task_entry(coroutine, headers, queue)
         self.tasks[task.id] = task
         return IdentifiableEntity(id=task.id)
 

ws_bom_robot_app/util.py

@@ -22,6 +22,12 @@ def logger_instance(name: str) -> logging.Logger:
 _log: logging.Logger = locals().get("_loc", logger_instance(__name__))
 #endregion
 
+#region task
+def is_app_subprocess():
+    """Check if we're running a task in a subprocess."""
+    return os.environ.get('IS_ROBOT_APP_SUBPROCESS', '').lower() == 'true'
+#endregion
+
 #region cache
 _cache = {}
 _cache_timestamps = {}

{ws_bom_robot_app-0.0.84.dist-info → ws_bom_robot_app-0.0.86.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ws_bom_robot_app
-Version: 0.0.84
+Version: 0.0.86
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa
@@ -17,26 +17,26 @@ Requires-Dist: pydantic==2.11.7
 Requires-Dist: pydantic-settings==2.10.1
 Requires-Dist: fastapi[standard]==0.116.1
 Requires-Dist: chevron==0.14.0
-Requires-Dist: langchain==0.3.26
-Requires-Dist: langchain-community==0.3.26
-Requires-Dist: langchain-core==0.3.72
-Requires-Dist: langchain-openai==0.3.27
-Requires-Dist: langchain-anthropic==0.3.6
-Requires-Dist: langchain-ibm==0.3.14
-Requires-Dist: langchain-google-genai==2.0.7
-Requires-Dist: langchain-google-vertexai==2.0.27
-Requires-Dist: langchain-groq==0.3.6
-Requires-Dist: langchain-ollama==0.3.3
-Requires-Dist: faiss-cpu==1.11.0
-Requires-Dist: chromadb==1.0.15
-Requires-Dist: langchain_chroma==0.2.5
-Requires-Dist: fastembed==0.7.1
+Requires-Dist: langchain==0.3.27
+Requires-Dist: langchain-community==0.3.29
+Requires-Dist: langchain-core==0.3.75
+Requires-Dist: langchain-openai==0.3.32
+Requires-Dist: langchain-anthropic==0.3.19
+Requires-Dist: langchain-ibm==0.3.17
+Requires-Dist: langchain-google-genai==2.1.10
+Requires-Dist: langchain-google-vertexai==2.0.28
+Requires-Dist: langchain-groq==0.3.7
+Requires-Dist: langchain-ollama==0.3.7
+Requires-Dist: openevals==0.1.0
+Requires-Dist: faiss-cpu==1.12.0
+Requires-Dist: chromadb==1.0.20
+Requires-Dist: langchain-chroma==0.2.5
 Requires-Dist: langchain-qdrant==0.2.0
-Requires-Dist: qdrant-client==1.15.0
+Requires-Dist: qdrant-client[fastembed]==1.15.1
 Requires-Dist: lark==1.2.2
-Requires-Dist: unstructured==0.18.11
+Requires-Dist: unstructured==0.18.14
 Requires-Dist: unstructured[image]
-Requires-Dist: unstructured-ingest==1.2.6
+Requires-Dist: unstructured-ingest==1.2.11
 Requires-Dist: unstructured-ingest[azure]
 Requires-Dist: unstructured-ingest[confluence]
 Requires-Dist: unstructured-ingest[dropbox]
@@ -49,9 +49,9 @@ Requires-Dist: unstructured-ingest[sftp]
 Requires-Dist: unstructured-ingest[sharepoint]
 Requires-Dist: unstructured-ingest[slack]
 Requires-Dist: html5lib==1.1
-Requires-Dist: markdownify==1.1.0
+Requires-Dist: markdownify==1.2.0
 Requires-Dist: duckduckgo-search==8.0.4
-Requires-Dist: langchain_google_community==2.0.7
+Requires-Dist: langchain-google-community==2.0.7
 Requires-Dist: trafilatura==2.0.0
 Dynamic: author
 Dynamic: author-email

{ws_bom_robot_app-0.0.84.dist-info → ws_bom_robot_app-0.0.86.dist-info}/RECORD

@@ -1,29 +1,30 @@
 ws_bom_robot_app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/auth.py,sha256=84nIbmJsMrNs0sxIQGEHbjsjc2P6ZrZZGSn8dkiL6is,895
-ws_bom_robot_app/config.py,sha256=CASD6fCCBp9YODBdlJWGN0vw7__hwrbq8WjrrLVRbTg,5307
-ws_bom_robot_app/cron_manager.py,sha256=HU_0CGqR7YUyI9MJ5CMTLp-s-A6HgdZCIFeV7SoGKvo,9361
-ws_bom_robot_app/main.py,sha256=LZH4z9BmVlxpFJf8TrIo_JxH1YhpeZRrrOYgKky7S7w,6712
-ws_bom_robot_app/subprocess_runner.py,sha256=sq06r3sdHc_1FdPcpN9Frf2-xKu7dM76FK9x8J7I0kc,4100
-ws_bom_robot_app/task_manager.py,sha256=jaxRnMCVMlxQzHyhNrt6duH4ov1zblf3-Sv8cwmesyI,24039
-ws_bom_robot_app/util.py,sha256=RjVD6B9sHje788Lndqq5DHy6TJM0KLs9qx3JYt81Wyk,4834
+ws_bom_robot_app/config.py,sha256=TWnFPlPpzN-GWVNib2CXfzY8IYVHCypkxdDJ6rLOatk,5443
+ws_bom_robot_app/cron_manager.py,sha256=TOz7dsQhbGXzYMKW7GboKOSySg9aun4h0yLckj-5w4U,9372
+ws_bom_robot_app/main.py,sha256=5h4qwQ4Ghm6CCSjO5eWvMhWxDATzUayQfQ-__E1Mw1I,6936
+ws_bom_robot_app/subprocess_runner.py,sha256=N71HxPvgMP5TIRlO5w9UzHAEK-JKOA9i16QXM3anpjM,4195
+ws_bom_robot_app/task_manager.py,sha256=N2NzinjaxsRaLu78sREG9MCanMzygtKUU_yXo-aw2wA,24570
+ws_bom_robot_app/util.py,sha256=t1VS6JQNOZe6aenBmjPLxJ_A3ncm7WqTZE8_gR85sQo,5022
 ws_bom_robot_app/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/agent_context.py,sha256=uatHJ8wcRly6h0S762BgfzDMpmcwCHwNzwo37aWjeE0,1305
 ws_bom_robot_app/llm/agent_description.py,sha256=yK4aVU3RNk1oP4bEneV3QPAi-208JwWk4R6qHlzqYIg,4656
 ws_bom_robot_app/llm/agent_handler.py,sha256=TnpfChHLWVQ-gCEHNQPW3UXiuS8AmiP8JYwRz9pqbCg,7203
 ws_bom_robot_app/llm/agent_lcel.py,sha256=tVa1JJOuL1CG0tXS5AwOB4gli0E2rGqSBD5oEehHvOY,2480
-ws_bom_robot_app/llm/api.py,sha256=jWx_6TqaE_JJ_W1b8LYWQXatKJ4dpinbqyuTWKuFzfw,5071
+ws_bom_robot_app/llm/api.py,sha256=jMoiKiD5HNxGu6gTb5_qZ5UU8d2uJ7UVrdLseDStI6o,7634
 ws_bom_robot_app/llm/defaut_prompt.py,sha256=LlCd_nSMkMmHESfiiiQYfnJyB6Pp-LSs4CEKdYW4vFk,1106
+ws_bom_robot_app/llm/evaluator.py,sha256=tUyPX1oGZEjSiO4JixwNlgv6BI9cUHSmcAsTCpBnIn4,13322
 ws_bom_robot_app/llm/main.py,sha256=U_zUcL51VazXUyEicWFoNGkqwV-55s3tn52BlVPINes,5670
 ws_bom_robot_app/llm/nebuly_handler.py,sha256=Z4_GS-N4vQYPLnlXlwhJrwpUvf2uG53diYSOcteXGTc,7978
 ws_bom_robot_app/llm/feedbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/feedbacks/feedback_manager.py,sha256=WcKgzlOb8VFG7yqHoIOO_R6LAzdzE4YIRFCVOGBSgfM,2856
 ws_bom_robot_app/llm/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/models/api.py,sha256=3fnl9uZDk7SUR53vnoM-YsRdNy2-8M3m2vkQ_LwXiHs,12194
+ws_bom_robot_app/llm/models/api.py,sha256=bahqx9rdP6jM9Kk9VGkqT-bhASJeuAzO_5Ir6tBxDIU,12212
 ws_bom_robot_app/llm/models/base.py,sha256=1TqxuTK3rjJEALn7lvgoen_1ba3R2brAgGx6EDTtDZo,152
 ws_bom_robot_app/llm/models/feedback.py,sha256=zh1jLqPRLzNlxInkCMoiJbfSu0-tiOEYHM7FhC46PkM,1692
 ws_bom_robot_app/llm/models/kb.py,sha256=oVSw6_dmNxikAHrPqcfxDXz9M0ezLIYuxpgvzfs_Now,9514
 ws_bom_robot_app/llm/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/providers/llm_manager.py,sha256=OTA_K4jmSmGTwnqFavujF7qPY0_gw9guGQUMPmyH4VM,15828
+ws_bom_robot_app/llm/providers/llm_manager.py,sha256=5XqQNRx0My-bXptCzOlsMTnjLTx3bcX9HRT3_l5IQ_A,16699
 ws_bom_robot_app/llm/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/tools/tool_builder.py,sha256=QTRG1c-EnH4APP10IyfZxEkqK9KitUsutXUvDRKeAhU,3224
 ws_bom_robot_app/llm/tools/tool_manager.py,sha256=1IgRXxdB7DU3gbIlfT_aMUWZyWuanFTAFwu3VaYKxfE,14990
@@ -33,9 +34,9 @@ ws_bom_robot_app/llm/tools/models/main.py,sha256=1hICqHs-KS2heenkH7b2eH0N2GrPaaN
 ws_bom_robot_app/llm/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/utils/agent.py,sha256=_CY5Dji3UeAIi2iuU7ttz4fml1q8aCFgVWOv970x8Fw,1411
 ws_bom_robot_app/llm/utils/chunker.py,sha256=zVXjRMloc3KbNEqiDcycYzy4N0Ey1g8XYeq6ftyvkyg,857
-ws_bom_robot_app/llm/utils/cleanup.py,sha256=0V-4CNucOIDlw7wu8zd-0_M4Xu5AVkPokCyuoys49qM,3059
+ws_bom_robot_app/llm/utils/cleanup.py,sha256=ARLZTX4mLbkLCEnMdIWYDYEAPOjzfy1laLGkYnxZe30,3063
 ws_bom_robot_app/llm/utils/cms.py,sha256=XhrLQyHQ2JUOInDCCf_uvR4Jiud0YvH2FwwiiuCnnsg,6352
-ws_bom_robot_app/llm/utils/download.py,sha256=yBrw9n6lbz1QlWhApIlEwuQ8kMa3u11OFXx84X_NRvA,7130
+ws_bom_robot_app/llm/utils/download.py,sha256=CrPWoCwYY6TjpDR8uHI0Do-w7WQ0PtjMcbUaRoEDUbg,7110
 ws_bom_robot_app/llm/utils/print.py,sha256=IsPYEWRJqu-dqlJA3F9OnnIS4rOq_EYX1Ljp3BvDnww,774
 ws_bom_robot_app/llm/utils/secrets.py,sha256=-HtqLIDVIJrpvGC5YhPAVyLsq8P4ChVM5g3GOfdwqVk,878
 ws_bom_robot_app/llm/utils/webhooks.py,sha256=LAAZqyN6VhV13wu4X-X85TwdDgAV2rNvIwQFIIc0FJM,2114
@@ -65,10 +66,10 @@ ws_bom_robot_app/llm/vector_store/integration/sitemap.py,sha256=FJy2wQDvML_1fR4g
 ws_bom_robot_app/llm/vector_store/integration/slack.py,sha256=hiE1kkg7868mbP2wVWQLmC1fK2jIE1lT7f8hVN0NqeY,2636
 ws_bom_robot_app/llm/vector_store/integration/thron.py,sha256=PylagYLzhSY_wMu_hR4PzAwSm4Jp6zi2aymuF0XN4Hw,4271
 ws_bom_robot_app/llm/vector_store/loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/vector_store/loader/base.py,sha256=b__KxrYql5j6I6vqO43gnEocN43Ic3o1OpTfV2n8pko,5656
+ws_bom_robot_app/llm/vector_store/loader/base.py,sha256=GjUS2oaz0LHOSal5pipBkomZtrYUNcKPSd8bzhUU5Dc,6889
 ws_bom_robot_app/llm/vector_store/loader/docling.py,sha256=IOv1A0HSIWiHWQFzI4fdApfxrKgXOqwmC3mPXlKplqQ,4012
 ws_bom_robot_app/llm/vector_store/loader/json_loader.py,sha256=qo9ejRZyKv_k6jnGgXnu1W5uqsMMtgqK_uvPpZQ0p74,833
-ws_bom_robot_app-0.0.84.dist-info/METADATA,sha256=voKK2OL7tpgb8zEIHK8zUBFSJQE8-5aQYFFAWousmd0,9971
-ws_bom_robot_app-0.0.84.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ws_bom_robot_app-0.0.84.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
-ws_bom_robot_app-0.0.84.dist-info/RECORD,,
+ws_bom_robot_app-0.0.86.dist-info/METADATA,sha256=SbiF6TLzZjAfbRdKRh9_A2yBLsHQsOLIUFpVHE0nMV0,9985
+ws_bom_robot_app-0.0.86.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ws_bom_robot_app-0.0.86.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
+ws_bom_robot_app-0.0.86.dist-info/RECORD,,