lollms-client 0.33.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-__version__ = "0.33.0" # Updated version
+__version__ = "1.1.0" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/llm_bindings/azure_openai/__init__.py

@@ -45,10 +45,6 @@ class AzureOpenAIBinding(LollmsLLMBinding):
     """
 
     def __init__(self,
-                 model_name: str, # In Azure, this is the DEPLOYMENT NAME
-                 azure_api_key: str = None,
-                 azure_endpoint: str = None,
-                 azure_api_version: str = "2024-02-01",
                  **kwargs
                  ):
         """
@@ -56,15 +52,15 @@ class AzureOpenAIBinding(LollmsLLMBinding):
 
         Args:
             model_name (str): The name of the Azure OpenAI DEPLOYMENT to use.
-            azure_api_key (str): The API key for the Azure OpenAI service.
+            service_key (str): The API key for the Azure OpenAI service.
             azure_endpoint (str): The endpoint URL for the Azure OpenAI service.
             azure_api_version (str): The API version to use.
         """
-        super().__init__(binding_name=BindingName)
-        self.model_name = model_name  # Here, it's the deployment name
-        self.azure_api_key = azure_api_key or os.getenv("AZURE_OPENAI_API_KEY")
-        self.azure_endpoint = azure_endpoint or os.getenv("AZURE_OPENAI_ENDPOINT")
-        self.azure_api_version = azure_api_version or os.getenv("AZURE_OPENAI_API_VERSION", "2024-02-01")
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name")  # Here, it's the deployment name
+        self.azure_api_key = kwargs.get("service_key") or os.getenv("AZURE_OPENAI_API_KEY")
+        self.azure_endpoint = kwargs.get("azure_endpoint") or os.getenv("AZURE_OPENAI_ENDPOINT")
+        self.azure_api_version = kwargs.get("azure_api_version") or os.getenv("AZURE_OPENAI_API_VERSION", "2024-02-01")
 
         if not self.model_name:
             raise ValueError("Azure deployment name ('model_name') is required.")

lollms_client/llm_bindings/claude/__init__.py

@@ -66,10 +66,6 @@ class ClaudeBinding(LollmsLLMBinding):
     """Anthropic Claude-specific binding implementation."""
 
     def __init__(self,
-                 host_address: str = None,  # Ignored, for compatibility
-                 model_name: str = "claude-3-sonnet-20240229",
-                 service_key: str = None,
-                 verify_ssl_certificate: bool = True, # Ignored, for compatibility
                  **kwargs
                  ):
         """
@@ -79,9 +75,9 @@ class ClaudeBinding(LollmsLLMBinding):
             model_name (str): Name of the Claude model to use.
             service_key (str): Anthropic API key.
         """
-        super().__init__(binding_name=BindingName)
-        self.model_name = model_name
-        self.service_key = service_key
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name")
+        self.service_key = kwargs.get("service_key")
         self._cached_models: Optional[List[Dict[str, str]]] = None
 
         if not self.service_key:
@@ -335,6 +331,7 @@ class ClaudeBinding(LollmsLLMBinding):
             )
             return response.token_count # Updated to correct response attribute
         except Exception as e:
+            trace_exception(e)
             ASCIIColors.error(f"Failed to count tokens with Claude API: {e}")
             return len(self.tokenize(text))
 

lollms_client/llm_bindings/gemini/__init__.py

@@ -33,10 +33,6 @@ class GeminiBinding(LollmsLLMBinding):
     """Google Gemini-specific binding implementation."""
 
     def __init__(self,
-                 host_address: str = None,  # Ignored, for compatibility
-                 model_name: str = "gemini-1.5-pro-latest",
-                 service_key: str = None,
-                 verify_ssl_certificate: bool = True, # Ignored, for compatibility
                  **kwargs
                  ):
         """
@@ -46,9 +42,9 @@ class GeminiBinding(LollmsLLMBinding):
             model_name (str): Name of the Gemini model to use.
             service_key (str): Google AI Studio API key.
         """
-        super().__init__(binding_name=BindingName)
-        self.model_name = model_name
-        self.service_key = service_key
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name", None)
+        self.service_key = kwargs.get("service_key", None)
 
         if not self.service_key:
             self.service_key = os.getenv("GOOGLE_API_KEY")

lollms_client/llm_bindings/grok/__init__.py

@@ -60,10 +60,6 @@ class GrokBinding(LollmsLLMBinding):
     """xAI Grok-specific binding implementation."""
 
     def __init__(self,
-                 host_address: str = None,  # Ignored, for compatibility
-                 model_name: str = "grok-1.5-vision-preview",
-                 service_key: str = None,
-                 verify_ssl_certificate: bool = True, # Ignored, for compatibility
                  **kwargs
                  ):
         """
@@ -73,9 +69,9 @@ class GrokBinding(LollmsLLMBinding):
             model_name (str): Name of the Grok model to use.
             service_key (str): xAI API key.
         """
-        super().__init__(binding_name=BindingName)
-        self.model_name = model_name
-        self.service_key = service_key
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name", "grok-1.5-vision-preview")
+        self.service_key = kwargs.get("service_key")
         self.base_url = kwargs.get("base_url", GROK_API_BASE_URL)
         self._cached_models: Optional[List[Dict[str, str]]] = None
 

lollms_client/llm_bindings/groq/__init__.py

@@ -29,8 +29,6 @@ class GroqBinding(LollmsLLMBinding):
     """
 
     def __init__(self,
-                 model_name: str = "llama3-8b-8192",
-                 service_key: str|None = None,
                  **kwargs
                  ):
         """
@@ -38,11 +36,11 @@ class GroqBinding(LollmsLLMBinding):
 
         Args:
             model_name (str): The name of the Groq model to use.
-            groq_api_key (str): The API key for the Groq service.
+            service_key (str): The API key for the Groq service.
         """
-        super().__init__(binding_name=BindingName)
-        self.model_name = model_name
-        self.groq_api_key = service_key or os.getenv("GROQ_API_KEY")
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name", "llama3-8b-8192")
+        self.groq_api_key = kwargs.get("service_key") or os.getenv("GROQ_API_KEY")
 
         if not self.groq_api_key:
             raise ValueError("Groq API key is required. Set it via 'groq_api_key' or GROQ_API_KEY env var.")

lollms_client/llm_bindings/hugging_face_inference_api/__init__.py

@@ -25,8 +25,6 @@ class HuggingFaceInferenceAPIBinding(LollmsLLMBinding):
     """
 
     def __init__(self,
-                 model_name: str = "mistralai/Mistral-7B-Instruct-v0.2",
-                 hf_api_key: str = None,
                  **kwargs
                  ):
         """
@@ -34,11 +32,11 @@ class HuggingFaceInferenceAPIBinding(LollmsLLMBinding):
 
         Args:
             model_name (str): The repository ID of the model on the Hugging Face Hub.
-            hf_api_key (str): The Hugging Face API key.
+            service_key (str): The Hugging Face API key.
         """
-        super().__init__(binding_name=BindingName)
-        self.model_name = model_name
-        self.hf_api_key = hf_api_key or os.getenv("HUGGING_FACE_HUB_TOKEN")
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name")
+        self.hf_api_key = kwargs.get("service_key") or os.getenv("HUGGING_FACE_HUB_TOKEN")
 
         if not self.hf_api_key:
             raise ValueError("Hugging Face API key is required. Set it via 'hf_api_key' or HUGGING_FACE_HUB_TOKEN env var.")

lollms_client/llm_bindings/litellm/__init__.py

@@ -36,12 +36,21 @@ class LiteLLMBinding(LollmsLLMBinding):
     and correct payload formatting for both streaming and non-streaming modes.
     """
     
-    def __init__(self, host_address: str, model_name: str, service_key: str = "anything", verify_ssl_certificate: bool = True, **kwargs):
-        super().__init__(binding_name="litellm")
-        self.host_address = host_address.rstrip('/')
-        self.model_name = model_name
-        self.service_key = service_key
-        self.verify_ssl_certificate = verify_ssl_certificate
+    def __init__(self, 
+                 **kwargs):
+        """ Initializes the LiteLLM binding with the provided parameters.
+        Args:
+            host_address (str): The base URL of the LiteLLM server.
+            model_name (str): The name of the model to use.
+            service_key (str): The API key for authentication.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates.
+        """
+        super().__init__(BindingName, **kwargs)
+        self.host_address = kwargs.get("host_address")
+        if self.host_address: self.host_address = self.host_address.rstrip('/')
+        self.model_name = kwargs.get("model_name")
+        self.service_key = kwargs.get("service_key")
+        self.verify_ssl_certificate = kwargs.get("verify_ssl_certificate")
 
     def _perform_generation(self, messages: List[Dict], n_predict: Optional[int], stream: bool, temperature: float, top_p: float, repeat_penalty: float, seed: Optional[int], streaming_callback: Optional[Callable[[str, MSG_TYPE], None]]) -> Union[str, dict]:
         url = f'{self.host_address}/v1/chat/completions'

lollms_client/llm_bindings/llamacpp/__init__.py

@@ -121,7 +121,14 @@ BindingName = "LlamaCppServerBinding"
 DEFAULT_LLAMACPP_SERVER_HOST = "127.0.0.1"
 
 class LlamaCppServerProcess:
-    def __init__(self, model_path: Union[str, Path], clip_model_path: Optional[Union[str, Path]] = None, server_binary_path: Optional[Union[str, Path]]=None, server_args: Dict[str, Any]={}):
+    def __init__(self, 
+                 model_path: Union[str, Path], 
+                 clip_model_path: Optional[Union[str, Path]] = None, 
+                 server_binary_path: Optional[Union[str, Path]]=None, 
+                 server_args: Dict[str, Any]={}
+                 ):
+        """Initialize the Llama.cpp server process.
+        """
         self.model_path = Path(model_path)
         self.clip_model_path = Path(clip_model_path) if clip_model_path else None
         
@@ -264,24 +271,35 @@ class LlamaCppServerBinding(LollmsLLMBinding):
         "parallel_slots": 4, # Default parallel slots for server
     }
 
-    def __init__(self, model_name: Optional[str], models_path: str, clip_model_name: Optional[str] = None,
-                 config: Optional[Dict[str, Any]] = None, default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat, **kwargs):
-        super().__init__(binding_name=BindingName)
+    def __init__(self, 
+                 **kwargs
+                ):
+        """Initialize the Llama.cpp server binding.
+        Args:
+            model_name (str): Name of the model to load. If None, will use initial_model_name_preference.
+            models_path (str): Path to the directory containing model files.
+            clip_model_name (str): Optional name of the clip model to use. If None, will try to auto-detect based on the main model.
+            config (dict): Additional configuration options for the server.
+            default_completion_format (ELF_COMPLETION_FORMAT): Default format for completions.
+
+        """
+        super().__init__(BindingName, **kwargs)
         if llama_cpp_binaries is None: raise ImportError("llama-cpp-binaries package is required but not found.")
 
+        models_path = kwargs.get("models_path", Path(__file__).parent/"models")
         self.models_path = Path(models_path)
         # Store initial preferences, but do not load/start server yet.
-        self.initial_model_name_preference: Optional[str] = model_name
-        self.user_provided_model_name: Optional[str] = model_name # Tracks the latest requested model
-        self.initial_clip_model_name_preference: Optional[str] = clip_model_name
+        self.initial_model_name_preference: Optional[str] = kwargs.get("model_name")
+        self.user_provided_model_name: Optional[str] = kwargs.get("model_name") # Tracks the latest requested model
+        self.initial_clip_model_name_preference: Optional[str] = kwargs.get("clip_model_name") 
         
         self._model_path_map: Dict[str, Path] = {}  # Maps unique name to full Path
 
         # Initial scan for available models (to populate listModels)
         self._scan_models()
 
-        self.default_completion_format = default_completion_format
-        self.server_args = {**self.DEFAULT_SERVER_ARGS, **(config or {}), **kwargs}
+        self.default_completion_format =  kwargs.get("default_completion_format", ELF_COMPLETION_FORMAT.Chat)
+        self.server_args = {**self.DEFAULT_SERVER_ARGS, **(kwargs.get("config") or {}), **kwargs}
         self.server_binary_path = self._get_server_binary_path()
         
         # Current state of the loaded model and server

lollms_client/llm_bindings/lollms/__init__.py

@@ -26,11 +26,6 @@ class LollmsBinding(LollmsLLMBinding):
     
     
     def __init__(self,
-                 host_address: str = "http://localhost:9642", #This is the default local installation 
-                 model_name: str = "",
-                 service_key: str|None = None, # a key generated on the lollms interface (it is advised to use LOLLMS_API_KEY environment variable instead)
-                 verify_ssl_certificate: bool = True,
-                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat,
                  **kwargs):
         """
         Initialize the OpenAI binding.
@@ -43,20 +38,35 @@ class LollmsBinding(LollmsLLMBinding):
             verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
             personality (Optional[int]): Ignored parameter for compatibility with LollmsLLMBinding.
         """
-        super().__init__(
-            binding_name = "openai",
-        )
-        self.host_address=host_address
-        self.model_name=model_name
-        self.service_key=service_key
-        self.verify_ssl_certificate=verify_ssl_certificate
-        self.default_completion_format=default_completion_format
+        super().__init__(BindingName, **kwargs)
+        self.host_address=kwargs.get("host_address","http://localhost:9642/v1").rstrip("/")
+        if not self.host_address.endswith("v1"):
+            self.host_address += "/v1"  
+        self.model_name=kwargs.get("model_name")
+        self.service_key=kwargs.get("service_key")
+        self.verify_ssl_certificate=kwargs.get("verify_ssl_certificate", True)
+        self.default_completion_format=kwargs.get("default_completion_format", ELF_COMPLETION_FORMAT.Chat)
 
         if not self.service_key:
             self.service_key = os.getenv("LOLLMS_API_KEY", self.service_key)
-        self.client = openai.OpenAI(api_key=self.service_key, base_url=None if host_address is None else host_address if len(host_address)>0 else None)
+        self.client = openai.OpenAI(api_key=self.service_key, base_url=None if self.host_address is None else self.host_address if len(self.host_address)>0 else None)
         self.completion_format = ELF_COMPLETION_FORMAT.Chat
 
+    def lollms_listMountedPersonalities(self, host_address:str|None=None):
+        host_address = host_address if host_address else self.host_address
+        url = f"{host_address}/list_mounted_personalities"
+
+        response = requests.get(url)
+
+        if response.status_code == 200:
+            try:
+                text = json.loads(response.content.decode("utf-8"))
+                return text
+            except Exception as ex:
+                return {"status": False, "error": str(ex)}
+        else:
+            return {"status": False, "error": response.text}
+
     
     def generate_text(self,
                      prompt: str,

lollms_client/llm_bindings/lollms_webui/__init__.py

@@ -18,10 +18,6 @@ class LollmsWebuiLLMBinding(LollmsLLMBinding):
     DEFAULT_HOST_ADDRESS = "http://localhost:9600"
     
     def __init__(self, 
-                 host_address: str = None,
-                 model_name: str = "",
-                 service_key: str = None,
-                 verify_ssl_certificate: bool = True,
                  personality: Optional[int] = None, 
                  **kwargs
                  ):
@@ -35,16 +31,14 @@ class LollmsWebuiLLMBinding(LollmsLLMBinding):
             verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
             personality (Optional[int]): Personality ID for generation. Defaults to None.
         """
-        super().__init__(
-            binding_name = "lollms"
-        )
-        
+        super().__init__(BindingName, **kwargs)
+        host_address = kwargs.get("host_address")
         self.host_address=host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS
-        self.model_name=model_name
-        self.service_key=service_key
-        self.verify_ssl_certificate=verify_ssl_certificate
+        self.model_name=kwargs.get("model_name")
+        self.service_key=kwargs.get("service_key")
+        self.verify_ssl_certificate=kwargs.get("verify_ssl_certificate")
         self.default_completion_format=kwargs.get("default_completion_format",ELF_COMPLETION_FORMAT.Chat) 
-        self.personality = personality
+        self.personality = kwargs.get("personality")
         self.model = None
     
     def generate_text(self,

lollms_client/llm_bindings/mistral/__init__.py

@@ -27,8 +27,6 @@ class MistralBinding(LollmsLLMBinding):
     """
 
     def __init__(self,
-                 model_name: str = "mistral-large-latest",
-                 service_key: str|None = None,
                  **kwargs
                  ):
         """
@@ -38,9 +36,9 @@ class MistralBinding(LollmsLLMBinding):
             model_name (str): The name of the Mistral model to use.
             mistral_api_key (str): The API key for the Mistral service.
         """
-        super().__init__(binding_name=BindingName)
-        self.model_name = model_name
-        self.mistral_api_key = service_key or os.getenv("MISTRAL_API_KEY")
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name","mistral-large-latest")
+        self.mistral_api_key = kwargs.get("service_key") or os.getenv("MISTRAL_API_KEY")
 
         if not self.mistral_api_key:
             raise ValueError("Mistral API key is required. Set it via 'mistral_api_key' or MISTRAL_API_KEY env var.")

lollms_client/llm_bindings/ollama/__init__.py

@@ -67,10 +67,6 @@ class OllamaBinding(LollmsLLMBinding):
     DEFAULT_HOST_ADDRESS = "http://localhost:11434"
     
     def __init__(self,
-                 host_address: str = None,
-                 model_name: str = "",
-                 service_key: str = None,
-                 verify_ssl_certificate: bool = True,
                  **kwargs
                  ):
         """
@@ -83,14 +79,13 @@ class OllamaBinding(LollmsLLMBinding):
             verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
             default_completion_format (ELF_COMPLETION_FORMAT): Default completion format.
         """
+        host_address = kwargs.get("host_address")
         _host_address = host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS
-        super().__init__(
-            binding_name=BindingName, # Use the module-level BindingName
-        )
+        super().__init__(BindingName, **kwargs)
         self.host_address=_host_address
-        self.model_name=model_name
-        self.service_key=service_key
-        self.verify_ssl_certificate=verify_ssl_certificate
+        self.model_name=kwargs.get("model_name")
+        self.service_key=kwargs.get("service_key")
+        self.verify_ssl_certificate=kwargs.get("verify_ssl_certificate", True)
         self.default_completion_format=kwargs.get("default_completion_format",ELF_COMPLETION_FORMAT.Chat) 
 
         if ollama is None:
@@ -376,7 +371,7 @@ class OllamaBinding(LollmsLLMBinding):
         # 2. Build the generation options dictionary
         options = {
             'num_predict': n_predict,
-            'temperature': float(temperature),
+            'temperature': float(temperature) if temperature else None,
             'top_k': top_k,
             'top_p': top_p,
             'repeat_penalty': repeat_penalty,

lollms_client/llm_bindings/open_router/__init__.py

@@ -28,8 +28,6 @@ class OpenRouterBinding(LollmsLLMBinding):
     BASE_URL = "https://openrouter.ai/api/v1"
 
     def __init__(self,
-                 model_name: str = "google/gemini-flash-1.5", # A good, fast default
-                 service_key: str|None = None,
                  **kwargs
                  ):
         """
@@ -39,9 +37,9 @@ class OpenRouterBinding(LollmsLLMBinding):
             model_name (str): The name of the model to use from OpenRouter (e.g., 'anthropic/claude-3-haiku-20240307').
             service_key (str): The API key for the OpenRouter service.
         """
-        super().__init__(binding_name=BindingName)
-        self.model_name = model_name
-        self.api_key = service_key or os.getenv("OPENROUTER_API_KEY")
+        super().__init__(BindingName, **kwargs)
+        self.model_name = kwargs.get("model_name","google/gemini-flash-1.5")
+        self.api_key = kwargs.get("service_key") or os.getenv("OPENROUTER_API_KEY")
 
         if not self.api_key:
             raise ValueError("OpenRouter API key is required. Set it via 'open_router_api_key' or OPENROUTER_API_KEY env var.")
@@ -154,7 +152,7 @@ class OpenRouterBinding(LollmsLLMBinding):
             response = self.client.chat.completions.create(
                 model=self.model_name,
                 messages=messages,
-                stream=stream,
+                stream=stream if stream else False,
                 **api_params
             )
 

lollms_client/llm_bindings/openai/__init__.py

@@ -27,11 +27,6 @@ class OpenAIBinding(LollmsLLMBinding):
     
     
     def __init__(self,
-                 host_address: str = None,
-                 model_name: str = "",
-                 service_key: str = None,
-                 verify_ssl_certificate: bool = True,
-                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat,
                  **kwargs):
         """
         Initialize the OpenAI binding.
@@ -43,18 +38,16 @@ class OpenAIBinding(LollmsLLMBinding):
             verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
             personality (Optional[int]): Ignored parameter for compatibility with LollmsLLMBinding.
         """
-        super().__init__(
-            binding_name = "openai",
-        )
-        self.host_address=host_address
-        self.model_name=model_name
-        self.service_key=service_key
-        self.verify_ssl_certificate=verify_ssl_certificate
-        self.default_completion_format=default_completion_format
+        super().__init__(BindingName, **kwargs)
+        self.host_address=kwargs.get("host_address")
+        self.model_name=kwargs.get("model_name")
+        self.service_key=kwargs.get("service_key")
+        self.verify_ssl_certificate=kwargs.get("verify_ssl_certificate", True)
+        self.default_completion_format=kwargs.get("default_completion_format", ELF_COMPLETION_FORMAT.Chat)
 
         if not self.service_key:
             self.service_key = os.getenv("OPENAI_API_KEY", self.service_key)
-        self.client = openai.OpenAI(api_key=self.service_key, base_url=None if host_address is None else host_address if len(host_address)>0 else None)
+        self.client = openai.OpenAI(api_key=self.service_key, base_url=None if self.host_address is None else self.host_address if len(self.host_address)>0 else None)
         self.completion_format = ELF_COMPLETION_FORMAT.Chat
 
     def _build_openai_params(self, messages: list, **kwargs) -> dict:

lollms_client/llm_bindings/openllm/__init__.py

@@ -61,23 +61,23 @@ class OpenLLMBinding(LollmsLLMBinding):
     DEFAULT_HOST_ADDRESS = "http://localhost:3000" # Default OpenLLM server address
     
     def __init__(self,
-                 host_address: str = None,
-                 model_name: str = "", # Informational, as client connects to specific model server
-                 # service_key and verify_ssl_certificate are not directly used by openllm.client.HTTPClient constructor
-                 # but kept for potential future extensions or custom client logic.
-                 service_key: Optional[str] = None, 
-                 verify_ssl_certificate: bool = True,
-                 timeout: int = 120, # Timeout for client requests
                  **kwargs
                  ):
+        """        Initialize the OpenLLM binding.
+        Args:
+            host_address (str): The address of the OpenLLM server (default: http://localhost:3000).
+            model_name (str): The name of the model to connect to. This is primarily for informational purposes.
+            service_key (Optional[str]): Optional service key for authentication, not used by openllm client.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates (default: True).
+            timeout (int): Timeout for client requests in seconds (default: 120).
+        """
+        host_address = kwargs.get("host_address")
         _host_address = host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS
-        super().__init__(
-            binding_name=BindingName,
-        )
+        super().__init__(BindingName, **kwargs)
         self.host_address = _host_address
-        self.model_name = model_name # Can be set by load_model or from config
+        self.model_name = kwargs.get("model_name") # Can be set by load_model or from config
         self.default_completion_format=kwargs.get("default_completion_format",ELF_COMPLETION_FORMAT.Chat) 
-        self.timeout = timeout
+        self.timeout = kwargs.get("timeout")
 
         if openllm is None or openllm.client is None:
             raise ImportError("OpenLLM library is not installed or client module not found. Please run 'pip install openllm'.")

lollms_client/llm_bindings/pythonllamacpp/__init__.py

@@ -89,7 +89,7 @@ class PythonLlamaCppBinding(LollmsLLMBinding):
                  **kwargs 
                  ):
         
-        super().__init__(binding_name=BindingName)
+        super().__init__(BindingName, **kwargs)
         
         if Llama is None: # Check if import failed
             raise ImportError("Llama-cpp-python library is not available. Please install it.")

lollms_client/llm_bindings/tensor_rt/__init__.py

@@ -232,25 +232,20 @@ def resolve_hf_model_path(model_id_or_gguf_id: str, models_base_path: Path) -> P
 # --- VLLM Binding Class ---
 class VLLMBinding(LollmsLLMBinding):
     def __init__(self, 
-                 models_folder: Optional[Union[str, Path]] = None, 
-                 model_name: str = "", 
-                 service_key: Optional[str] = None, 
-                 verify_ssl_certificate: bool = True, 
-                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat,
                  **kwargs 
         ):
         if not _vllm_deps_installed:
             raise ImportError(f"vLLM or its dependencies not installed. Binding unusable. Error: {_vllm_installation_error}")
         if engine_manager is None:
              raise RuntimeError("VLLMEngineManager failed to initialize. Binding unusable.")
-
+        models_folder = kwargs.get("models_folder")
         _models_folder = Path(models_folder) if models_folder is not None else DEFAULT_models_folder
         _models_folder.mkdir(parents=True, exist_ok=True)
 
-        super().__init__(BindingName)
-        self.models_folder= models_folder
-        self.model_name=model_name
-        self.default_completion_format=default_completion_format
+        super().__init__(BindingName, **kwargs)
+        self.models_folder= _models_folder
+        self.model_name=kwargs.get("model_name", "")
+        self.default_completion_format=kwargs.get("default_completion_format", ELF_COMPLETION_FORMAT.Chat)
 
         
         self.models_folder: Path = _models_folder
@@ -261,11 +256,11 @@ class VLLMBinding(LollmsLLMBinding):
         self.current_engine_params: Optional[Dict[str, Any]] = None
         self.vllm_engine_kwargs_config = kwargs.copy()
 
-        if model_name:
+        if self.model_name:
             try:
-                self.load_model(model_name)
+                self.load_model(self.model_name)
             except Exception as e:
-                ASCIIColors.error(f"Auto-load model '{model_name}' failed: {e}")
+                ASCIIColors.error(f"Auto-load model '{self.model_name}' failed: {e}")
                 trace_exception(e)
 
     def _get_vllm_engine_params_for_load(self) -> Dict[str, Any]:

lollms_client/llm_bindings/transformers/__init__.py

@@ -91,14 +91,22 @@ class HuggingFaceHubBinding(LollmsLLMBinding):
     }
 
     def __init__(self,
-                 model_name_or_id: str, # Can be HF Hub ID or local folder name relative to models_path
-                 models_path: Union[str, Path],
-                 config: Optional[Dict[str, Any]] = None,
-                 default_completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat,
                  **kwargs # Overrides for config_args
                  ):
-        
-        super().__init__(binding_name=BindingName)
+        """
+        Initializes the Hugging Face Hub binding.
+        Args:
+            model_name (str): Hugging Face Hub model ID or local folder name.
+            models_path (str or Path): Path to the directory containing local models.
+            config (Optional[Dict[str, Any]]): Optional configuration dictionary to override defaults.
+            default_completion_format (ELF_COMPLETION_FORMAT): Default format for text generation.
+        """
+        super().__init__(BindingName, **kwargs)
+
+        model_name_or_id = kwargs.get("model_name")
+        models_path = kwargs.get("models_path")
+        config = kwargs.get("config")
+        default_completion_format = kwargs.get("default_completion_format", ELF_COMPLETION_FORMAT.Chat)
 
         if torch is None or transformers is None: # Check if core imports failed
             raise ImportError("Core libraries (torch, transformers) not available. Binding cannot function.")