ws-bom-robot-app 0.0.85__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/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/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/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-0.0.85.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.85
+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.85.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/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=jaxRnMCVMlxQzHyhNrt6duH4ov1zblf3-Sv8cwmesyI,24039
+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
@@ -35,7 +36,7 @@ ws_bom_robot_app/llm/utils/agent.py,sha256=_CY5Dji3UeAIi2iuU7ttz4fml1q8aCFgVWOv9
 ws_bom_robot_app/llm/utils/chunker.py,sha256=zVXjRMloc3KbNEqiDcycYzy4N0Ey1g8XYeq6ftyvkyg,857
 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
@@ -68,7 +69,7 @@ ws_bom_robot_app/llm/vector_store/loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 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.85.dist-info/METADATA,sha256=md1udg5NIma6BagHw38GcOjmQp2tOq5fqHvToFAqvFw,9971
-ws_bom_robot_app-0.0.85.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ws_bom_robot_app-0.0.85.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
-ws_bom_robot_app-0.0.85.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,,