ws-bom-robot-app 0.0.63__py3-none-any.whl → 0.0.103__py3-none-any.whl

ws_bom_robot_app/config.py

@@ -14,9 +14,18 @@ class Settings(BaseSettings):
     robot_data_db_folder_out: str = 'out'
     robot_data_db_folder_store: str = 'store'
     robot_data_db_retention_days: float = 60
+    robot_data_attachment_folder: str = 'attachment'
+    robot_data_attachment_retention_days: float = 1
+    robot_ingest_max_threads: int = 1 # safe choice to 1, avoid potential process-related issues with Docker
     robot_loader_max_threads: int = 1
     robot_task_max_total_parallelism: int = 2 * (os.cpu_count() or 1)
     robot_task_retention_days: float = 1
+    robot_task_strategy: str = 'memory' # memory / db
+    robot_task_mp_enable: bool = True
+    robot_task_mp_method: str = 'spawn' # spawn / fork
+    robot_task_mp_max_retries: int = 1
+    robot_task_mp_retry_delay: float = 60 # seconds
+    robot_cron_strategy: str = 'memory' # memory / db
     robot_cms_host: str = ''
     robot_cms_auth: str = ''
     robot_cms_db_folder: str = 'llmVectorDb'
@@ -27,8 +36,12 @@ class Settings(BaseSettings):
     OLLAMA_API_URL: str = 'http://localhost:11434'
     GROQ_API_KEY: str = ''
     GOOGLE_API_KEY: str = ''
-    NEBULY_API_URL: 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/'
+    LANGSMITH_API_KEY: str = '' # app-wide api key to run evaluation
     model_config = ConfigDict(
         env_file='./.env',
         extra='ignore',
@@ -36,6 +49,7 @@ class Settings(BaseSettings):
     )
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
+        # env
         os.environ["USER_AGENT"] = self.USER_AGENT
         os.environ["OPENAI_API_KEY"] = self.OPENAI_API_KEY
         os.environ["OLLAMA_API_URL"] = self.OLLAMA_API_URL
@@ -44,11 +58,19 @@ class Settings(BaseSettings):
         os.environ["GROQ_API_KEY"] = self.GROQ_API_KEY
         os.environ["GOOGLE_API_KEY"] = self.GOOGLE_API_KEY
         os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = self.GOOGLE_APPLICATION_CREDENTIALS
+        os.environ["WATSONX_URL"] = self.WATSONX_URL
+        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']:
+            os.makedirs(os.path.join(self.robot_data_folder, subfolder), exist_ok=True)
 
     class RuntimeOptions(BaseModel):
         @staticmethod
-        def _get_number_of_workers() -> int:
+        def _get_sys_arg(arg: str, default: int) -> int:
             """
             Returns the number of worker processes to use for the application.
 
@@ -66,18 +88,18 @@ class Settings(BaseSettings):
             """
             import sys
             try:
-                for i, arg in enumerate(sys.argv):
-                    if arg == "--workers" and i + 1 < len(sys.argv):
+                for i, argv in enumerate(sys.argv):
+                    if argv == f"--{arg}" and i + 1 < len(sys.argv):
                         return int(sys.argv[i + 1])
             except (ValueError, IndexError):
                 pass
-            return 1
+            return default
         debug: bool
+        tcp_port: int = _get_sys_arg("port", 6001)
         loader_show_progress: bool
         loader_silent_errors: bool
-        number_of_workers: int = _get_number_of_workers()
-        is_multi_process: bool = _get_number_of_workers() > 1
-
+        number_of_workers: int = _get_sys_arg("workers", 1)
+        is_multi_process: bool = _get_sys_arg("workers", 1) > 1
 
     def runtime_options(self) -> RuntimeOptions:
       """_summary_

ws_bom_robot_app/cron_manager.py

@@ -1,3 +1,4 @@
+import os
 from apscheduler.schedulers.background import BackgroundScheduler
 #from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from apscheduler.jobstores.memory import MemoryJobStore
@@ -7,8 +8,7 @@ from apscheduler.triggers.interval import IntervalTrigger
 from apscheduler.triggers.date import DateTrigger
 from fastapi import APIRouter
 from datetime import datetime
-from ws_bom_robot_app.task_manager import task_manager
-from ws_bom_robot_app.llm.utils.kb import kb_cleanup_data_file
+from ws_bom_robot_app.llm.utils.cleanup import kb_cleanup_data_file, chat_cleanup_attachment, task_cleanup_history
 from ws_bom_robot_app.util import _log
 from ws_bom_robot_app.config import config
 
@@ -22,8 +22,8 @@ class MemoryJobstoreStrategy(JobstoreStrategy):
         return {"default": MemoryJobStore()}
 
 class PersistentJobstoreStrategy(JobstoreStrategy):
-    def get_jobstore(self, db_url: str = "sqlite:///.data/db/jobs.sqlite"):
-        _log.info(f"Using persistent crob jobstore with database URL: {db_url}.")
+    def get_jobstore(self, db_url: str = f"sqlite:///{config.robot_data_folder}/db/jobs.sqlite"):
+        _log.info(f"Using persistent cron jobstore with database URL: {db_url}.")
         return {"default": SQLAlchemyJobStore(url=db_url)}
 
 class Job:
@@ -56,11 +56,12 @@ class Job:
 
 class CronManager:
     _list_default = [
-            Job('cleanup-task',task_manager.cleanup_task, interval=5 * 60),
-            Job('cleanup-data',kb_cleanup_data_file, interval=180 * 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 True or config.runtime_options().is_multi_process:
+        if config.robot_cron_strategy == 'memory':
             return MemoryJobstoreStrategy()
         return PersistentJobstoreStrategy()
     def __init__(self, strategy: JobstoreStrategy = None, enable_defaults: bool = True):
@@ -139,22 +140,22 @@ class CronManager:
 
     def execute_recurring_jobs(self):
         for job in self.scheduler.get_jobs():
-            if job.interval:
-                job.job_func()
+            if job.trigger.interval:
+                job.func()
 
     def pause_recurring_jobs(self):
         for job in self.scheduler.get_jobs():
-            if job.interval:
+            if job.trigger.interval:
                 self.pause_job(job.id)
 
     def resume_recurring_jobs(self):
         for job in self.scheduler.get_jobs():
-            if job.interval:
+            if job.trigger.interval:
                 self.resume_job(job.id)
 
     def remove_recurring_jobs(self):
         for job in self.scheduler.get_jobs():
-            if job.interval:
+            if job.trigger.interval:
                 self.remove_job(job.id)
 
     def clear(self):

ws_bom_robot_app/llm/agent_context.py

@@ -7,7 +7,7 @@ class AgentContext(BaseModel):
     class _i18n(BaseModel):
         lg: Optional[str] = "en"
         country: Optional[str] = "US"
-        timestamp: Optional[str] = Field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+        timestamp: Optional[str] = Field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S %A"))
         timezone: Optional[str] = "UTC"
         model_config = ConfigDict(extra='allow')
     class _user(BaseModel):

ws_bom_robot_app/llm/agent_handler.py

@@ -5,10 +5,9 @@ from langchain.callbacks.base import AsyncCallbackHandler
 from ws_bom_robot_app.llm.utils.print import print_json, print_string
 from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
-import ws_bom_robot_app.llm.settings as settings
 from langchain_core.callbacks.base import AsyncCallbackHandler
 from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
-from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
+from langchain_core.messages import BaseMessage, AIMessage
 import json, logging, re
 
 # Here is a custom handler that will print the tokens to stdout.
@@ -85,6 +84,8 @@ class AgentHandler(AsyncCallbackHandler):
                     # if the pending text is long, we output most of it except the last few characters.
                     if len(self.stream_buffer) > self.stream_cut_last_output_chunk_size:
                         safe_cut = self.stream_buffer[:-3]
+                        if safe_cut.startswith('`'):
+                          safe_cut = safe_cut[1:]
                         await self.queue.put(print_string(safe_cut))
                         self.stream_buffer = self.stream_buffer[-3:]
               else:
@@ -109,6 +110,10 @@ class AgentHandler(AsyncCallbackHandler):
                       self.json_buffer += self.stream_buffer
                       self.stream_buffer = ""
 
+    async def on_tool_end(self, output, *, run_id, parent_run_id = None, tags = None, **kwargs):
+        if "stream" in (tags or []):
+            await self.queue.put(print_json(output))
+
     async def on_agent_finish(
         self,
         finish: AgentFinish,
@@ -118,11 +123,6 @@ class AgentHandler(AsyncCallbackHandler):
         tags: List[str] = None,
         **kwargs: Any,
     ) -> None:
-        settings.chat_history.extend(
-            [
-                AIMessage(content=_parse_token(self.llm,finish.return_values["output"])),
-            ]
-        )
         # end-of-stream: flush any remaining text
         if self.in_json_block:
             try:
@@ -160,6 +160,10 @@ class RawAgentHandler(AsyncCallbackHandler):
         if token:  # only process non-empty tokens
             await self.queue.put(_parse_token(self.llm,token))
 
+    async def on_tool_end(self, output, *, run_id, parent_run_id = None, tags = None, **kwargs):
+        if "stream" in (tags or []):
+            await self.queue.put(print_json(output))
+
     async def on_agent_finish(
         self,
         finish: AgentFinish,
@@ -169,9 +173,4 @@ class RawAgentHandler(AsyncCallbackHandler):
         tags: List[str] = None,
         **kwargs: Any,
     ) -> None:
-        settings.chat_history.extend(
-            [
-                AIMessage(content=_parse_token(self.llm,finish.return_values["output"]))
-            ]
-        )
         await self.queue.put(None)

ws_bom_robot_app/llm/agent_lcel.py

@@ -3,6 +3,7 @@ from langchain.agents import AgentExecutor, create_tool_calling_agent
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 from langchain_core.runnables import RunnableLambda
 from langchain_core.tools import render_text_description
+from pydantic import create_model, BaseModel
 import chevron
 from ws_bom_robot_app.llm.agent_context import AgentContext
 from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
@@ -12,34 +13,95 @@ from ws_bom_robot_app.llm.defaut_prompt import default_prompt, tool_prompt
 
 class AgentLcel:
 
-    def __init__(self, llm: LlmInterface, sys_message: str, sys_context: AgentContext, tools: list, rules: LlmRules = None):
+    def __init__(self, llm: LlmInterface, sys_message: str, sys_context: AgentContext, tools: list, rules: LlmRules = None, json_schema: Optional[dict] = None):
         self.sys_message = chevron.render(template=sys_message,data=sys_context)
         self.__llm = llm
         self.__tools = tools
         self.rules = rules
+        self.json_schema = json_schema
         self.embeddings = llm.get_embeddings()
         self.memory_key: str = "chat_history"
         self.__llm_with_tools = llm.get_llm().bind_tools(self.__tools) if len(self.__tools) > 0 else llm.get_llm()
+        if self.json_schema:
+            self.__pydantic_schema = self.__create_pydantic_schema()
+        else:
+            self.__pydantic_schema = None
+
         self.executor = self.__create_agent()
 
+    def __create_pydantic_schema(self) -> type[BaseModel]:
+        """Crea un Pydantic model dinamico dallo schema JSON."""
+        if not self.json_schema:
+            return None
+
+        type_map = {
+            "string": str,
+            "text": str,
+            "number": float,
+            "float": float,
+            "int": int,
+            "integer": int,
+            "bool": bool,
+            "boolean": bool,
+            "list": list,
+            "array": list,
+            "dict": dict,
+            "object": dict,
+        }
+
+        fields: dict[str, tuple[Any, Any]] = {}
+        for k, v in self.json_schema.items():
+            if isinstance(v, str):
+                py_type = type_map.get(v.lower(), str)
+                fields[k] = (py_type, ...)
+            elif isinstance(v, dict):
+                fields[k] = (dict, ...)
+            elif isinstance(v, list):
+                fields[k] = (list, ...)
+            else:
+                fields[k] = (type(v), ...)
+
+        return create_model('JsonSchema', **fields)
+
+    def __get_output_parser(self):
+        return self.__llm.get_parser()
+
     async def __create_prompt(self, input: dict) -> ChatPromptTemplate:
+        from langchain_core.messages import SystemMessage
         message : LlmMessage = input[self.memory_key][-1]
         rules_prompt = await get_rules(self.embeddings, self.rules, message.content) if self.rules else ""
         system = default_prompt + (tool_prompt(render_text_description(self.__tools)) if len(self.__tools)>0 else "") + self.sys_message + rules_prompt
-        return ChatPromptTemplate([
-                ("system", system),
-                MessagesPlaceholder(variable_name=self.memory_key),
-                MessagesPlaceholder(variable_name="agent_scratchpad"),
-            ])
-
-    def __create_agent(self) -> AgentExecutor:
-      agent: Any = (
-          {
-            "agent_scratchpad": lambda x: self.__llm.get_formatter(x["intermediate_steps"]),
-             str(self.memory_key): lambda x: x[self.memory_key],
-          }
-          | RunnableLambda(self.__create_prompt)
-          | self.__llm_with_tools
-          | self.__llm.get_parser()
-      )
-      return AgentExecutor(agent=agent,tools=self.__tools,verbose=False)
+
+        # Aggiungi istruzioni per output JSON strutturato se necessario
+        if self.json_schema and self.__pydantic_schema:
+            json_instructions = f"\n\nIMPORTANT: You must format your final response as a JSON object with the following structure:\n"
+            for field_name, field_info in self.__pydantic_schema.model_fields.items():
+                field_type = field_info.annotation.__name__ if hasattr(field_info.annotation, '__name__') else str(field_info.annotation)
+                json_instructions += f"- {field_name}: {field_type}\n"
+            json_instructions += "\nProvide ONLY the JSON object in your response, no additional text."
+            system += json_instructions
+
+        messages = [
+            SystemMessage(content=system),
+            MessagesPlaceholder(variable_name=self.memory_key),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ]
+
+        prompt = ChatPromptTemplate.from_messages(
+            messages=messages,
+            template_format=None,
+        )
+        return prompt
+
+    def __create_agent(self):
+        # Un solo AgentExecutor per entrambe le modalità
+        agent = (
+            {
+                "agent_scratchpad": lambda x: self.__llm.get_formatter(x["intermediate_steps"]),
+                self.memory_key: lambda x: x[self.memory_key],
+            }
+            | RunnableLambda(self.__create_prompt)
+            | self.__llm_with_tools
+            | self.__get_output_parser()
+        )
+        return AgentExecutor(agent=agent, tools=self.__tools, verbose=False)

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
@@ -21,9 +22,9 @@ async def root():
 async def _invoke(rq: InvokeRequest):
     return await invoke(rq)
 
-def _stream_headers(rq: StreamRequest) -> Mapping[str, str]:
+def _rs_stream_headers(rq: StreamRequest) -> Mapping[str, str]:
     return {
-        "X-thread-id": rq.msg_id or str(uuid4()),
+        "X-thread-id": rq.thread_id or str(uuid4()),
         "X-msg-id": rq.msg_id or str(uuid4()),
         }
 
@@ -40,11 +41,11 @@ async def cms_app_by_id(id: str):
 
 @router.post("/stream")
 async def _stream(rq: StreamRequest, ctx: Request) -> StreamingResponse:
-    return StreamingResponse(stream(rq, ctx), media_type="application/json", headers=_stream_headers(rq))
+    return StreamingResponse(stream(rq, ctx), media_type="application/json", headers=_rs_stream_headers(rq))
 
 @router.post("/stream/raw")
 async def _stream_raw(rq: StreamRequest, ctx: Request) -> StreamingResponse:
-    return StreamingResponse(stream(rq, ctx, formatted=False), media_type="application/json", headers=_stream_headers(rq))
+    return StreamingResponse(stream(rq, ctx, formatted=False), media_type="application/json", headers=_rs_stream_headers(rq))
 
 @router.post("/kb")
 async def _kb(rq: KbRequest) -> VectorDbResponse:
@@ -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(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(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