ws-bom-robot-app 0.0.67__tar.gz → 0.0.68__tar.gz

{ws_bom_robot_app-0.0.67/ws_bom_robot_app.egg-info → ws_bom_robot_app-0.0.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ws_bom_robot_app
-Version: 0.0.67
+Version: 0.0.68
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa
@@ -244,7 +244,7 @@ pytest --cov=ws_bom_robot_app --log-cli-level=info
 launch debugger
 
 ```pwsh
-streamlit run debugger.py --server.port 6011
+streamlit run debugger.py --server.port 8051
 ```
 
 dockerize base image

{ws_bom_robot_app-0.0.67 → ws_bom_robot_app-0.0.68}/README.md

@@ -179,7 +179,7 @@ pytest --cov=ws_bom_robot_app --log-cli-level=info
 launch debugger
 
 ```pwsh
-streamlit run debugger.py --server.port 6011
+streamlit run debugger.py --server.port 8051
 ```
 
 dockerize base image

{ws_bom_robot_app-0.0.67 → ws_bom_robot_app-0.0.68}/setup.py

@@ -4,7 +4,7 @@ _requirements = [line.split('#')[0].strip() for line in open("requirements.txt")
 
 setup(
     name="ws_bom_robot_app",
-    version="0.0.67",
+    version="0.0.68",
     description="A FastAPI application serving ws bom/robot/llm platform ai.",
     long_description=open("README.md", encoding='utf-8').read(),
     long_description_content_type="text/markdown",

{ws_bom_robot_app-0.0.67 → ws_bom_robot_app-0.0.68}/ws_bom_robot_app/config.py

@@ -54,7 +54,7 @@ class Settings(BaseSettings):
 
     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.
 
@@ -72,18 +72,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-0.0.67 → ws_bom_robot_app-0.0.68}/ws_bom_robot_app/llm/main.py

@@ -85,7 +85,7 @@ async def __stream(rq: StreamRequest, ctx: Request, queue: Queue,formatted: bool
     client = LangSmithClient(
       api_key= rq.secrets.get("langChainApiKey", "")
     )
-    trace = LangChainTracer(project_name=rq.lang_chain_project,client=client,tags=[str(ctx.base_url)])
+    trace = LangChainTracer(project_name=rq.lang_chain_project,client=client,tags=[str(ctx.base_url) if ctx else ''])
     callbacks.append(trace)
 
   __llm: LlmInterface =rq.get_llm()

{ws_bom_robot_app-0.0.67 → ws_bom_robot_app-0.0.68}/ws_bom_robot_app/llm/providers/llm_manager.py

@@ -183,9 +183,9 @@ class IBM(LlmInterface):
         from ibm_watsonx_ai import APIClient,Credentials
         super().__init__(config)
         self.__base_url = self.config.api_url or os.getenv("WATSONX_URL") or "https://us-south.ml.cloud.ibm.com"
-        self.__apy_key = self.config.api_key or os.getenv("WATSONX_APIKEY")
+        self.__api_key = self.config.api_key or os.getenv("WATSONX_APIKEY")
         self.__client = APIClient(
-            credentials=Credentials(url=self.__base_url,api_key=self.__apy_key),
+            credentials=Credentials(url=self.__base_url,api_key=self.__api_key),
             project_id=os.getenv("WATSONX_PROJECTID") or "default"
         )
     def get_llm(self):
@@ -202,7 +202,7 @@ class IBM(LlmInterface):
           today = date.today().strftime("%Y-%m-%d")
           url = f"{self.__base_url}/ml/v1/foundation_model_specs?version={today}&filters=task_generation,task_summarization:and"
           headers = {
-              "Authorization": f"Bearer {self.__apy_key}",
+              "Authorization": f"Bearer {self.__api_key}",
               "Content-Type": "application/json"
           }
           response = requests.get(url, headers=headers)

{ws_bom_robot_app-0.0.67 → ws_bom_robot_app-0.0.68}/ws_bom_robot_app/llm/tools/tool_builder.py

@@ -18,7 +18,7 @@ async def __process_proxy_tool(proxy_tool: LlmAppTool) -> LlmAppTool | None:
         if not app:
             raise ValueError(f"App with id {app_id} not found.")
         tool_id = secrets.get("toolId")
-        tool = next((t for t in app.app_tools if t.id == tool_id), None)
+        tool = next((t for t in app.rq.app_tools if app.rq.app_tools and t.id == tool_id), None)
         if not tool:
             raise ValueError(f"Tool with function_id {tool_id} not found in app {app.name}.")
         #override derived tool with proxy tool props

{ws_bom_robot_app-0.0.67 → ws_bom_robot_app-0.0.68}/ws_bom_robot_app/llm/tools/tool_manager.py

@@ -166,6 +166,7 @@ class ToolManager:
           return result
 
     async def proxy_app_chat(self, query: str) -> str | None:
+        from ws_bom_robot_app.llm.models.api import LlmMessage
         secrets = self.app_tool.secrets_to_dict()
         app_id = secrets.get("appId")
         if not app_id:
@@ -173,26 +174,38 @@ class ToolManager:
         app: CmsApp = await get_app_by_id(app_id)
         if not app:
             raise ValueError(f"App with id {app_id} not found.")
-        url = f"{config.robot_cms_host}/api/llm/message?locale=en&raw=true"
-        auth = config.robot_cms_auth
-        headers = {"Authorization": auth} if auth else {}
-        async with aiohttp.ClientSession() as session:
-            data = {
-              "appKey": app.credentials.app_key,
-              "apiKey": app.credentials.api_key,
-              "messages": [
-                {
-                  "role": "user",
-                  "content": query
-                }
-              ]
-            }
-            async with session.post(url, json=data, headers=headers) as response:
-                if response.status == 200:
-                  return await response.text()
-                else:
-                  raise ValueError(f"Error fetching chat response: {response.status}")
-        return None
+        # message
+        app.rq.messages.append(LlmMessage(role="user", content=query))
+        # tracing
+        if str(secrets.get("disable_tracing", False)).lower() in ['1','true','yes']:
+          app.rq.lang_chain_tracing = False
+          app.rq.lang_chain_project = ''
+          app.rq.secrets['nebulyApiKey'] = ''
+        # http: for debugging purposes
+        if str(secrets.get("use_http", False)).lower() in ['1','true','yes']:
+          import base64
+          url = f"http://localhost:{config.runtime_options().tcp_port}/api/llm/stream/raw"
+          auth = f"Basic {base64.b64encode((config.robot_user + ':' + config.robot_password).encode('utf-8')).decode('utf-8')}"
+          headers = {"Authorization": auth} if auth else {}
+          async with aiohttp.ClientSession() as session:
+              _data = app.rq.model_dump(mode='json',by_alias=True,exclude_unset=True,exclude_none=True, exclude_defaults=True)
+              async with session.post(url, json=_data, headers=headers) as response:
+                  if response.status == 200:
+                    return await response.text()
+                  else:
+                    raise ValueError(f"Error fetching chat response: {response.status}")
+          return None
+        else:  # default
+          try:
+            from ws_bom_robot_app.llm.main import stream
+            chunks = []
+            async for chunk in stream(rq=app.rq, ctx=None, formatted=False):
+                chunks.append(chunk)
+            rs = ''.join(chunks) if chunks else None
+            return rs
+          except Exception as e:
+            print(f"[!] Error in proxy_app_chat: {e}")
+            return None
 
     async def proxy_app_tool(self) -> None:
         return None

ws_bom_robot_app-0.0.68/ws_bom_robot_app/llm/utils/cms.py

@@ -0,0 +1,109 @@
+import logging, aiohttp
+from typing import Any, List, Optional
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+from ws_bom_robot_app.llm.models.api import LlmAppTool, LlmRules, StreamRequest
+from ws_bom_robot_app.llm.models.kb import LlmKbEndpoint, LlmKbIntegration
+from ws_bom_robot_app.util import cache_with_ttl
+
+class CmsAppCredential(BaseModel):
+  app_key: str = Field(..., description="The app key for the credential", validation_alias=AliasChoices("appKey","app_key"))
+  api_key: str = Field(..., description="The api key for the credential", validation_alias=AliasChoices("apiKey","api_key"))
+  model_config = ConfigDict(extra='ignore')
+class CmsApp(BaseModel):
+  id: str = Field(..., description="Unique identifier for the app")
+  name: str = Field(..., description="Name of the app")
+  mode: str
+  prompt_samples: Optional[List[str]]
+  credentials: CmsAppCredential = None
+  rq: StreamRequest
+  kb: Optional[Any] = None
+  model_config = ConfigDict(extra='ignore')
+
+@cache_with_ttl(600)  # Cache for 10 minutes
+async def get_apps() -> list[CmsApp]:
+  import json
+  from ws_bom_robot_app.config import config
+  class DictObject(object):
+      def __init__(self, dict_):
+          self.__dict__.update(dict_)
+      def __repr__(self):
+          return json.dumps(self.__dict__)
+      @classmethod
+      def from_dict(cls, d):
+          return json.loads(json.dumps(d), object_hook=DictObject)
+  def __attr(obj, *attrs, default=None):
+      for attr in attrs:
+          obj = getattr(obj, attr, default)
+          if obj is None:
+              break
+      return obj
+  host = config.robot_cms_host
+  if host:
+    url = f"{host}/api/llmApp?depth=1&pagination=false&locale=it"
+    auth = config.robot_cms_auth
+    headers = {"Authorization": auth} if auth else {}
+    async with aiohttp.ClientSession() as session:
+      async with session.get(url, headers=headers) as response:
+        if response.status == 200:
+          _apps=[]
+          cms_apps = await response.json()
+          for cms_app in cms_apps:
+             if __attr(cms_app,"isActive",default=True) == True:
+                _cms_app_dict = DictObject.from_dict(cms_app)
+                _app: CmsApp = CmsApp(
+                  id=_cms_app_dict.id,
+                  name=_cms_app_dict.name,
+                  mode=_cms_app_dict.mode,
+                  prompt_samples=[__attr(sample,'sampleInputText') or f"{sample.__dict__}" for sample in _cms_app_dict.contents.sampleInputTexts],
+                  credentials=CmsAppCredential(app_key=_cms_app_dict.settings.credentials.appKey,api_key=_cms_app_dict.settings.credentials.apiKey),
+                  rq=StreamRequest(
+                    #thread_id=str(uuid.uuid1()),
+                    messages=[],
+                    secrets={
+                      "apiKey": __attr(_cms_app_dict.settings,'llmConfig','secrets','openAIApiKey', default=''),
+                      "langChainApiKey": __attr(_cms_app_dict.settings,'llmConfig','secrets','langChainApiKey', default=''),
+                      "nebulyApiKey": __attr(_cms_app_dict.settings,'llmConfig','secrets','nebulyApiKey', default=''),
+                      },
+                    system_message=__attr(_cms_app_dict.settings,'llmConfig','prompt','prompt','systemMessage') if __attr(_cms_app_dict.settings,'llmConfig','prompt','prompt','systemMessage') else __attr(_cms_app_dict.settings,'llmConfig','prompt','systemMessage'),
+                    provider= __attr(_cms_app_dict.settings,'llmConfig','provider') or 'openai',
+                    model= __attr(_cms_app_dict.settings,'llmConfig','model') or 'gpt-4o',
+                    temperature=_cms_app_dict.settings.llmConfig.temperature or 0,
+                    app_tools=[LlmAppTool(**tool) for tool in cms_app.get('settings').get('appTools',[])],
+                    rules=LlmRules(
+                      vector_type=__attr(_cms_app_dict.settings,'rules','vectorDbType', default='faiss'),
+                      vector_db=__attr(_cms_app_dict.settings,'rules','vectorDbFile','filename'),
+                      threshold=__attr(_cms_app_dict.settings,'rules','threshold', default=0.7)
+                      ) if __attr(_cms_app_dict.settings,'rules','vectorDbFile','filename') else None,
+                    #fine_tuned_model=__attr(_cms_app_dict.settings,'llmConfig','fineTunedModel'),
+                    lang_chain_tracing= __attr(_cms_app_dict.settings,'llmConfig','langChainTracing', default=False),
+                    lang_chain_project= __attr(_cms_app_dict.settings,'llmConfig','langChainProject', default='')
+                  )
+                )
+                if _app.rq.app_tools:
+                  for tool in _app.rq.app_tools:
+                    _knowledgeBase = tool.knowledgeBase
+                    tool.integrations = [LlmKbIntegration(**item) for item in _knowledgeBase.get('integrations')] if _knowledgeBase.get('integrations') else []
+                    try:
+                      tool.endpoints = [LlmKbEndpoint(**item) for item in _knowledgeBase.get('externalEndpoints')] if _knowledgeBase.get('externalEndpoints') else []
+                    except Exception as e:
+                      logging.error(f"Error parsing endpoints for app {_cms_app_dict.name} tool {tool.name}: {e}")
+                    tool.vector_db = _knowledgeBase.get('vectorDbFile').get('filename') if _knowledgeBase.get('vectorDbFile') else None
+                    tool.vector_type = _knowledgeBase.get('vectorDbType') if _knowledgeBase.get('vectorDbType') else 'faiss'
+                    del tool.knowledgeBase
+                _apps.append(_app)
+          return _apps
+        else:
+          logging.error(f"Error fetching cms apps: {response.status}")
+  else:
+    logging.error("robot_cms_host environment variable is not set.")
+  return []
+
+
+async def get_app_by_id(app_id: str) -> CmsApp | None:
+    apps = await get_apps()
+    app = next((a for a in apps if a.id == app_id), None)
+    if app:
+        return app
+    else:
+        logging.error(f"App with id {app_id} not found.")
+        return None

{ws_bom_robot_app-0.0.67 → ws_bom_robot_app-0.0.68/ws_bom_robot_app.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ws_bom_robot_app
-Version: 0.0.67
+Version: 0.0.68
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa
@@ -244,7 +244,7 @@ pytest --cov=ws_bom_robot_app --log-cli-level=info
 launch debugger
 
 ```pwsh
-streamlit run debugger.py --server.port 6011
+streamlit run debugger.py --server.port 8051
 ```
 
 dockerize base image

ws_bom_robot_app-0.0.67/ws_bom_robot_app/llm/utils/cms.py

@@ -1,77 +0,0 @@
-import logging, aiohttp
-from typing import List, Optional
-
-from pydantic import AliasChoices, BaseModel, ConfigDict, Field
-from ws_bom_robot_app.llm.models.api import LlmAppTool
-from ws_bom_robot_app.util import cache_with_ttl
-
-class CmsAppCredential(BaseModel):
-  app_key: str = Field(..., description="The app key for the credential", validation_alias=AliasChoices("appKey","app_key"))
-  api_key: str = Field(..., description="The api key for the credential", validation_alias=AliasChoices("apiKey","api_key"))
-  model_config = ConfigDict(extra='ignore')
-class CmsApp(BaseModel):
-  id: str = Field(..., description="Unique identifier for the app")
-  name: str = Field(..., description="Name of the app")
-  credentials: CmsAppCredential = None
-  app_tools: Optional[List[LlmAppTool]] = Field([], validation_alias=AliasChoices("appTools","app_tools"))
-  model_config = ConfigDict(extra='ignore')
-
-@cache_with_ttl(600)  # Cache for 10 minutes
-async def get_apps() -> list[CmsApp]:
-  import json, os
-  from ws_bom_robot_app.config import config
-  class DictObject(object):
-      def __init__(self, dict_):
-          self.__dict__.update(dict_)
-      def __repr__(self):
-          return json.dumps(self.__dict__)
-      @classmethod
-      def from_dict(cls, d):
-          return json.loads(json.dumps(d), object_hook=DictObject)
-  def __attr(obj, *attrs, default=None):
-      for attr in attrs:
-          obj = getattr(obj, attr, default)
-          if obj is None:
-              break
-      return obj
-  host = config.robot_cms_host
-  if host:
-    url = f"{host}/api/llmApp?depth=1&pagination=false"
-    auth = config.robot_cms_auth
-    headers = {"Authorization": auth} if auth else {}
-    async with aiohttp.ClientSession() as session:
-      async with session.get(url, headers=headers) as response:
-        if response.status == 200:
-          _apps=[]
-          cms_apps = await response.json()
-          for cms_app in cms_apps:
-             if __attr(cms_app,"isActive",default=True) == True:
-                _cms_app_dict = DictObject.from_dict(cms_app)
-                _app: CmsApp = CmsApp(
-                  id=_cms_app_dict.id,
-                  name=_cms_app_dict.name,
-                  credentials=CmsAppCredential(app_key=_cms_app_dict.settings.credentials.appKey,api_key=_cms_app_dict.settings.credentials.apiKey),
-                  app_tools=[LlmAppTool(**tool) for tool in cms_app.get('settings').get('appTools',[])]
-                )
-                if _app.app_tools:
-                  for tool in _app.app_tools:
-                    _knowledgeBase = tool.knowledgeBase
-                    tool.vector_db = _knowledgeBase.get('vectorDbFile').get('filename') if _knowledgeBase.get('vectorDbFile') else None
-                    tool.vector_type = _knowledgeBase.get('vectorDbType') if _knowledgeBase.get('vectorDbType') else 'faiss'
-                    del tool.knowledgeBase
-                _apps.append(_app)
-          return _apps
-        else:
-          logging.error(f"Error fetching cms apps: {response.status}")
-  else:
-    logging.error("robot_cms_host environment variable is not set.")
-  return []
-
-async def get_app_by_id(app_id: str) -> CmsApp | None:
-    apps = await get_apps()
-    app = next((a for a in apps if a.id == app_id), None)
-    if app:
-        return app
-    else:
-        logging.error(f"App with id {app_id} not found.")
-        return None