ws-bom-robot-app 0.0.32__py3-none-any.whl → 0.0.34__py3-none-any.whl

ws_bom_robot_app/llm/providers/llm_manager.py

@@ -0,0 +1,174 @@
+from typing import Any, Optional
+from langchain_core.embeddings import Embeddings
+from langchain_core.language_models import BaseChatModel
+from pydantic import BaseModel, ConfigDict, Field
+
+class LlmConfig(BaseModel):
+    api_key: str
+    embedding_api_key: Optional[str] = None
+    model: Optional[str] = None
+    temperature: Optional[float] = Field(0.7, ge=0.0, le=2.0)
+
+# Define an abstract LLM interface
+class LlmInterface:
+    def __init__(self, config: LlmConfig):
+        self.config = config
+
+    def get_llm(self) -> BaseChatModel:
+        raise NotImplementedError
+
+    def get_embeddings(self) -> Embeddings:
+        from langchain_openai import OpenAIEmbeddings
+        return OpenAIEmbeddings(model="text-embedding-3-small")
+
+    def get_models(self) -> list:
+        raise NotImplementedError
+
+    def get_formatter(self,intermadiate_steps):
+        from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages
+        return format_to_openai_tool_messages(intermediate_steps=intermadiate_steps)
+
+    def get_parser(self):
+        from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser
+        return OpenAIToolsAgentOutputParser()
+
+class OpenAI(LlmInterface):
+    def get_llm(self):
+        from langchain_openai import ChatOpenAI
+        chat = ChatOpenAI(api_key=self.config.api_key, model=self.config.model)
+        if not any(self.config.model.startswith(prefix) for prefix in ["o1", "o3"]):
+            chat.temperature = self.config.temperature
+            chat.streaming = True
+        return chat
+
+    def get_embeddings(self):
+        from langchain_openai import OpenAIEmbeddings
+        return OpenAIEmbeddings(
+            api_key=self.config.api_key,
+            model="text-embedding-3-small")
+
+    def get_models(self):
+        import openai
+        openai.api_key = self.config.api_key
+        response = openai.models.list()
+        return response.data
+
+class DeepSeek(LlmInterface):
+    def get_llm(self):
+        from langchain_openai import ChatOpenAI
+        return ChatOpenAI(
+            api_key=self.config.api_key,
+            model=self.config.model,
+            base_url="https://api.deepseek.com/v1",
+            max_tokens=8192,
+            temperature=self.config.temperature,
+            streaming=True,
+        )
+
+    def get_embeddings(self):
+        from langchain_openai import OpenAIEmbeddings
+        return OpenAIEmbeddings(
+            api_key=self.config.embedding_api_key,
+            model="text-embedding-3-small")
+
+    def get_models(self):
+        return [
+              {"id":"deepseek-chat"},
+              {"id":"deepseek-reasoner"}
+            ]
+
+class Google(LlmInterface):
+  def get_llm(self):
+    from langchain_google_genai.chat_models import ChatGoogleGenerativeAI
+    return ChatGoogleGenerativeAI(
+      name="chat",
+      api_key=self.config.api_key,
+      model=self.config.model,
+      temperature=self.config.temperature,
+      disable_streaming=False
+    )
+
+  def get_embeddings(self):
+    from langchain_google_genai.embeddings import GoogleGenerativeAIEmbeddings
+    return GoogleGenerativeAIEmbeddings(
+      google_api_key=self.config.api_key,
+      model="models/text-embedding-004")
+
+  def get_models(self):
+    import google.generativeai as genai
+    genai.configure(api_key=self.config.api_key)
+    response = genai.list_models()
+    return [{
+      "id": model.name,
+      "name": model.display_name,
+      "description": model.description,
+      "input_token_limit": model.input_token_limit,
+      "output_token_limit": model.output_token_limit
+    } for model in response if "gemini" in model.name.lower()]
+
+class Gvertex(LlmInterface):
+    def get_llm(self):
+        from langchain_google_vertexai  import ChatVertexAI
+        return ChatVertexAI(
+            model=self.config.model,
+            temperature=self.config.temperature,
+        )
+    def get_embeddings(self):
+        from langchain_google_vertexai import VertexAIEmbeddings
+        return VertexAIEmbeddings(model_name="text-embedding-004")
+    def get_models(self):
+        from google.cloud import aiplatform
+        aiplatform.init()
+        models = aiplatform.Model.list()
+        #see https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations#united-states for available models
+        return models or [
+              {"id":"gemini-2.0-flash-001"},
+              {"id":"gemini-1.5-pro-001"},
+              {"id":"gemini-1.5-pro-002"}
+            ]
+
+class Anthropic(LlmInterface):
+    def get_llm(self):
+        from langchain_anthropic import ChatAnthropic
+        return ChatAnthropic(
+            api_key=self.config.api_key,
+            model=self.config.model,
+            temperature=self.config.temperature,
+            streaming=True,
+            stream_usage=False
+        )
+
+    def get_embeddings(self):
+        #from langchain_voyageai import VoyageAIEmbeddings
+        #return VoyageAIEmbeddings(
+        #    api_key=self.config.embedding_api_key, #voyage api key
+        #    model="voyage-3")
+        from langchain_openai import OpenAIEmbeddings
+        return OpenAIEmbeddings(
+            api_key=self.config.embedding_api_key,
+            model="text-embedding-3-small")
+
+    def get_models(self):
+        import anthropic
+        client = anthropic.Client(api_key=self.config.api_key)
+        response = client.models.list()
+        return response.data
+
+    def get_formatter(self,intermadiate_steps):
+        from langchain.agents.format_scratchpad.tools import format_to_tool_messages
+        return format_to_tool_messages(intermediate_steps=intermadiate_steps)
+
+    def get_parser(self):
+        from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
+        return ToolsAgentOutputParser()
+
+class LlmManager:
+
+    #class variables (static)
+    _list: dict[str,LlmInterface] = {
+        "anthropic": Anthropic,
+        "deepseek": DeepSeek,
+        "google": Google,
+        "gvertex": Gvertex,
+        "openai": OpenAI,
+    }

ws_bom_robot_app/llm/settings.py

@@ -1,4 +1,4 @@
-def init():
-    """Initialize the chat history list as a global var"""
-    global chat_history
-    chat_history = []
+def init():
+    """Initialize the chat history list as a global var"""
+    global chat_history
+    chat_history = []

ws_bom_robot_app/llm/tools/models/main.py

@@ -1,7 +1,9 @@
 from pydantic import BaseModel, Field
 
+class NoopInput(BaseModel):
+  pass
+class DocumentRetrieverInput(BaseModel):
+  query: str = Field(description="The search query string")
 class ImageGeneratorInput(BaseModel):
-  query: str = Field(
-      description="description of the image to generate."
-  )
+  query: str = Field(description="description of the image to generate.")
   language: str = Field(description="Language of the query. Default is 'it'", default="it")

ws_bom_robot_app/llm/tools/tool_builder.py

@@ -1,19 +1,23 @@
-from asyncio import Queue
-from langchain.tools import StructuredTool
-from ws_bom_robot_app.llm.models.api import LlmAppTool
-from ws_bom_robot_app.llm.tools.tool_manager import ToolManager
-
-def get_structured_tools(tools: list[LlmAppTool], api_key:str, callbacks:list, queue: Queue) -> list[StructuredTool]:
-  _structured_tools :list[StructuredTool] = []
-  for tool in [tool for tool in tools if tool.is_active]:
-    if _tool_config := ToolManager._list.get(tool.function_name):
-      _tool_instance = ToolManager(tool, api_key, callbacks, queue)
-      _structured_tool = StructuredTool.from_function(
-        coroutine=_tool_instance.get_coroutine(),
-        name=tool.function_id,
-        description=tool.function_description,
-        args_schema=_tool_config.model
-      )
-      _structured_tool.tags = [tool.function_id]
-      _structured_tools.append(_structured_tool)
-  return _structured_tools
+from asyncio import Queue
+from langchain.tools import Tool, StructuredTool
+from ws_bom_robot_app.llm.models.api import LlmAppTool
+from ws_bom_robot_app.llm.tools.tool_manager import ToolManager
+from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
+
+def get_structured_tools(llm: LlmInterface, tools: list[LlmAppTool], callbacks:list, queue: Queue) -> list[StructuredTool]:
+  _structured_tools :list[StructuredTool] = []
+  for tool in [tool for tool in tools if tool.is_active]:
+    if _tool_config := ToolManager._list.get(tool.function_name):
+      _tool_instance = ToolManager(llm, tool, callbacks, queue)
+      _structured_tool = StructuredTool.from_function(
+        coroutine=_tool_instance.get_coroutine(),
+        name=tool.function_id if tool.function_id else tool.function_name,
+        description=tool.function_description,
+        args_schema=_tool_config.model
+        #infer_schema=True,
+        #parse_docstring=True,
+        #error_on_invalid_docstring=True
+      )
+      _structured_tool.tags = [tool.function_id if tool.function_id else tool.function_name]
+      _structured_tools.append(_structured_tool)
+  return _structured_tools

ws_bom_robot_app/llm/tools/tool_manager.py

@@ -1,101 +1,133 @@
-from asyncio import Queue
-from typing import  Optional, Type, Callable
-from ws_bom_robot_app.llm.models.api import LlmAppTool
-from ws_bom_robot_app.llm.utils.faiss_helper import FaissHelper
-from ws_bom_robot_app.llm.tools.utils import getRandomWaitingMessage, translate_text
-from ws_bom_robot_app.llm.tools.models.main import ImageGeneratorInput
-from pydantic import BaseModel, ConfigDict
-from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
-
-class ToolConfig(BaseModel):
-    function: Callable
-    model: Optional[Type[BaseModel]] = None
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True
-    )
-
-class ToolManager:
-    """
-    ToolManager is responsible for managing various tools used in the application.
-
-    Attributes:
-        app_tool (LlmAppTool): The application tool configuration.
-        api_key (str): The API key for accessing external services.
-        callbacks (list): A list of callback functions to be executed.
-
-    Methods:
-        document_retriever(query: str): Asynchronously retrieves documents based on the query.
-        image_generator(query: str, language: str = "it"): Asynchronously generates an image based on the query.
-        get_coroutine(): Retrieves the coroutine function based on the tool configuration.
-    """
-
-    def __init__(
-        self,
-        app_tool: LlmAppTool,
-        api_key: str,
-        callbacks: list,
-        queue: Optional[Queue] = None
-    ):
-        self.app_tool = app_tool
-        self.api_key = api_key
-        self.callbacks = callbacks
-        self.queue = queue
-
-
-    #region functions
-    async def document_retriever(self, query: str):
-        if (
-            self.app_tool.type == "function" and self.app_tool.vector_db
-            #and self.settings.get("dataSource") == "knowledgebase"
-        ):
-            search_type = "similarity"
-            search_kwargs = {"k": 4}
-            if self.app_tool.search_settings:
-                search_settings = self.app_tool.search_settings # type: ignore
-                if search_settings.search_type == "similarityScoreThreshold":
-                    search_type = "similarity_score_threshold"
-                    search_kwargs = {
-                        "score_threshold": search_settings.score_threshold_id if search_settings.score_threshold_id else  0.5,
-                        "k": search_settings.search_k if search_settings.search_k else 100
-                    }
-                elif search_settings.search_type == "mmr":
-                    search_type = "mmr"
-                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
-                elif search_settings.search_type == "default":
-                    search_type = "similarity"
-                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
-                else:
-                    search_type = "mixed"
-                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
-            if self.queue:
-              await self.queue.put(getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False))
-            return await FaissHelper.invoke(self.app_tool.vector_db, self.api_key, query, search_type, search_kwargs)
-        return []
-        #raise ValueError(f"Invalid configuration for {self.settings.name} tool of type {self.settings.type}. Must be a function or vector db not found.")
-
-    async def image_generator(self, query: str, language: str = "it"):
-        model = self.app_tool.model or "dall-e-3"
-        random_waiting_message = getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False)
-        if not language:
-            language = "it"
-        await translate_text(
-            self.api_key, language, random_waiting_message, self.callbacks
-        )
-        try:
-            image_url = DallEAPIWrapper(api_key=self.api_key, model=model).run(query)  # type: ignore
-            return image_url
-        except Exception as e:
-            return f"Error: {str(e)}"
-
-    #endregion
-
-    #class variables (static)
-    _list: dict[str,ToolConfig] = {
-        "document_retriever": ToolConfig(function=document_retriever),
-        "image_generator": ToolConfig(function=image_generator, model=ImageGeneratorInput),
-    }
-
-    #instance methods
-    def get_coroutine(self):
-        tool_cfg = self._list.get(self.app_tool.function_name)
-        return getattr(self, tool_cfg.function.__name__)  # type: ignore
+from asyncio import Queue
+from typing import  Optional, Type, Callable
+from ws_bom_robot_app.llm.models.api import LlmAppTool
+from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
+from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager
+from ws_bom_robot_app.llm.tools.utils import getRandomWaitingMessage, translate_text
+from ws_bom_robot_app.llm.tools.models.main import NoopInput,DocumentRetrieverInput,ImageGeneratorInput
+from pydantic import BaseModel, ConfigDict
+
+class ToolConfig(BaseModel):
+    function: Callable
+    model: Optional[Type[BaseModel]] = NoopInput
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True
+    )
+
+class ToolManager:
+    """
+    ToolManager is responsible for managing various tools used in the application.
+
+    Attributes:
+        app_tool (LlmAppTool): The application tool configuration.
+        api_key (str): The API key for accessing external services.
+        callbacks (list): A list of callback functions to be executed.
+
+    Methods:
+        document_retriever(query: str): Asynchronously retrieves documents based on the query.
+        image_generator(query: str, language: str = "it"): Asynchronously generates an image based on the query.
+        get_coroutine(): Retrieves the coroutine function based on the tool configuration.
+    """
+
+    def __init__(
+        self,
+        llm: LlmInterface,
+        app_tool: LlmAppTool,
+        callbacks: list,
+        queue: Optional[Queue] = None
+    ):
+        self.llm = llm
+        self.app_tool = app_tool
+        self.callbacks = callbacks
+        self.queue = queue
+
+
+    #region functions
+    async def document_retriever(self, query: str) -> list:
+        """
+        Asynchronously retrieves documents based on the provided query using the specified search settings.
+
+        Args:
+          query (str): The search query string.
+
+        Returns:
+          list: A list of retrieved documents based on the search criteria.
+
+        Raises:
+          ValueError: If the configuration for the tool is invalid or the vector database is not found.
+
+        Notes:
+          - The function supports different search types such as "similarity", "similarity_score_threshold", "mmr", and "mixed".
+          - The search settings can be customized through the `app_tool.search_settings` attribute.
+          - If a queue is provided, a waiting message is put into the queue before invoking the search.
+        """
+        if (
+            self.app_tool.type == "function" and self.app_tool.vector_db
+            #and self.settings.get("dataSource") == "knowledgebase"
+        ):
+            search_type = "similarity"
+            search_kwargs = {"k": 4}
+            if self.app_tool.search_settings:
+                search_settings = self.app_tool.search_settings # type: ignore
+                if search_settings.search_type == "similarityScoreThreshold":
+                    search_type = "similarity_score_threshold"
+                    search_kwargs = {
+                        "score_threshold": search_settings.score_threshold_id if search_settings.score_threshold_id else  0.5,
+                        "k": search_settings.search_k if search_settings.search_k else 100
+                    }
+                elif search_settings.search_type == "mmr":
+                    search_type = "mmr"
+                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
+                elif search_settings.search_type == "default":
+                    search_type = "similarity"
+                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
+                else:
+                    search_type = "mixed"
+                    search_kwargs = {"k": search_settings.search_k if search_settings.search_k else 4}
+            if self.queue:
+              await self.queue.put(getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False))
+
+            return await VectorDbManager.get_strategy(self.app_tool.vector_type).invoke(
+                self.llm.get_embeddings(),
+                self.app_tool.vector_db,
+                query,
+                search_type,
+                search_kwargs,
+                app_tool=self.app_tool,
+                llm=self.llm.get_llm()
+                )
+        return []
+        #raise ValueError(f"Invalid configuration for {self.settings.name} tool of type {self.settings.type}. Must be a function or vector db not found.")
+
+    async def image_generator(self, query: str, language: str = "it"):
+        """
+        Asynchronously generates an image based on the query.
+        set OPENAI_API_KEY in your environment variables
+        """
+        from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
+        model = self.app_tool.model or "dall-e-3"
+        random_waiting_message = getRandomWaitingMessage(self.app_tool.waiting_message, traduction=False)
+        if not language:
+            language = "it"
+        await translate_text(
+            self.llm, language, random_waiting_message, self.callbacks
+        )
+        try:
+            #set os.environ.get("OPENAI_API_KEY")!
+            image_url = DallEAPIWrapper(model=model).run(query)  # type: ignore
+            return image_url
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    #endregion
+
+    #class variables (static)
+    _list: dict[str,ToolConfig] = {
+        "document_retriever": ToolConfig(function=document_retriever, model=DocumentRetrieverInput),
+        "image_generator": ToolConfig(function=image_generator, model=ImageGeneratorInput),
+    }
+
+    #instance methods
+    def get_coroutine(self):
+        tool_cfg = self._list.get(self.app_tool.function_name)
+        return getattr(self, tool_cfg.function.__name__)  # type: ignore

ws_bom_robot_app/llm/tools/utils.py

@@ -1,25 +1,25 @@
-import random, os
-from langchain_openai import ChatOpenAI
-from langchain_core.prompts import PromptTemplate
-from ws_bom_robot_app.llm.utils.print import printString
-
-def __print_output(data: str) -> str:
-  return printString(data) if os.environ.get("AGENT_HANDLER_FORMATTED") == str(True) else f"{data} "
-
-def getRandomWaitingMessage(waiting_messages: str, traduction: bool = True) -> str:
-  if not waiting_messages: return ""
-  messages = [msg.strip() for msg in waiting_messages.split(";") if msg.strip()]
-  if not messages: return ""
-  chosen_message = random.choice(messages) + "\n"
-  if not traduction:
-      return __print_output(chosen_message)
-  return chosen_message
-
-async def translate_text(api_key, language, text: str, callbacks: list) -> str:
-  if language == "it":
-      return __print_output(text)
-  llm = ChatOpenAI(api_key=api_key, model="gpt-3.5-turbo-0125", streaming=True)
-  sys_message = """Il tuo compito è di tradurre il testo_da_tradure nella seguente lingua: \n\n lingua: {language}\n\n testo_da_tradure: {testo_da_tradure} \n\nTraduci il testo_da_tradure nella lingua {language} senza aggiungere altro:"""
-  prompt = PromptTemplate.from_template(sys_message)
-  chain = prompt | llm
-  await chain.ainvoke({"language":language, "testo_da_tradure": text}, {"callbacks": callbacks})
+import random, os
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from ws_bom_robot_app.llm.providers.llm_manager import LlmInterface
+from ws_bom_robot_app.llm.utils.print import printString
+
+def __print_output(data: str) -> str:
+  return printString(data) if os.environ.get("AGENT_HANDLER_FORMATTED") == str(True) else f"{data} "
+
+def getRandomWaitingMessage(waiting_messages: str, traduction: bool = True) -> str:
+  if not waiting_messages: return ""
+  messages = [msg.strip() for msg in waiting_messages.split(";") if msg.strip()]
+  if not messages: return ""
+  chosen_message = random.choice(messages) + "\n"
+  if not traduction:
+      return __print_output(chosen_message)
+  return chosen_message
+
+async def translate_text(llm: LlmInterface, language, text: str, callbacks: list) -> str:
+  if language == "it":
+      return __print_output(text)
+  sys_message = """Il tuo compito è di tradurre il testo_da_tradurre nella seguente lingua: \n\n lingua: {language}\n\n testo_da_tradurre: {testo_da_tradurre} \n\nTraduci il testo_da_tradurre nella lingua {language} senza aggiungere altro:"""
+  prompt = PromptTemplate.from_template(sys_message)
+  chain = prompt | llm.get_llm()
+  await chain.ainvoke({"language":language, "testo_da_tradurre": text}, {"callbacks": callbacks})

ws_bom_robot_app/llm/utils/agent_utils.py

@@ -1,16 +1,17 @@
-import os
-from ws_bom_robot_app.llm.models.api import LlmRules
-from ws_bom_robot_app.llm.utils.print import HiddenPrints
-from ws_bom_robot_app.llm.utils.faiss_helper import FaissHelper
-
-async def get_rules(rules: LlmRules, api_key:str, input: str) -> str:
-  with HiddenPrints():
-    if any([input=="",rules is None,rules and rules.vector_db == "",rules and not os.path.exists(rules.vector_db)]):
-      return ""
-    rules_prompt = ""
-    rules_doc = await FaissHelper.invoke(rules.vector_db,api_key,input,search_type="similarity_score_threshold", search_kwargs={"score_threshold": rules.threshold}) #type: ignore
-    if len(rules_doc) > 0:
-      rules_prompt = "\nFollow this rules: \n RULES: \n"
-      for rule_doc in rules_doc:
-        rules_prompt += "- " + rule_doc.page_content + "\n"
-    return rules_prompt
+import os
+from langchain_core.embeddings import Embeddings
+from ws_bom_robot_app.llm.models.api import LlmRules
+from ws_bom_robot_app.llm.utils.print import HiddenPrints
+from ws_bom_robot_app.llm.vector_store.db.manager import VectorDbManager
+
+async def get_rules(embeddings: Embeddings, rules: LlmRules, input: str) -> str:
+  with HiddenPrints():
+    if any([input=="",rules is None,rules and rules.vector_db == "",rules and not os.path.exists(rules.vector_db)]):
+      return ""
+    rules_prompt = ""
+    rules_doc = await VectorDbManager.get_strategy(rules.vector_type).invoke(embeddings, rules.vector_db,input,search_type="similarity_score_threshold", search_kwargs={"score_threshold": rules.threshold}) #type: ignore
+    if len(rules_doc) > 0:
+      rules_prompt = "\nFollow this rules: \n RULES: \n"
+      for rule_doc in rules_doc:
+        rules_prompt += "- " + rule_doc.page_content + "\n"
+    return rules_prompt