lollms-client 0.32.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

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

@@ -11,11 +11,11 @@ import pipmaster as pm
 # Ensure the required packages are installed
 pm.ensure_packages(["mistralai", "pillow", "tiktoken"])
 
-from mistralai.client import MistralClient
-from mistralai.models.chat_completion import ChatMessage
+from mistralai import Mistral
 from PIL import Image, ImageDraw
 import tiktoken
 
+
 BindingName = "MistralBinding"
 
 class MistralBinding(LollmsLLMBinding):
@@ -27,8 +27,6 @@ class MistralBinding(LollmsLLMBinding):
     """
 
     def __init__(self,
-                 model_name: str = "mistral-large-latest",
-                 mistral_api_key: str = None,
                  **kwargs
                  ):
         """
@@ -38,15 +36,15 @@ 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 = mistral_api_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.")
 
         try:
-            self.client = MistralClient(api_key=self.mistral_api_key)
+            self.client = Mistral(api_key=self.mistral_api_key)
         except Exception as e:
             ASCIIColors.error(f"Failed to configure Mistral client: {e}")
             self.client = None
@@ -64,35 +62,67 @@ class MistralBinding(LollmsLLMBinding):
         if n_predict is not None: params['max_tokens'] = n_predict
         if seed is not None: params['random_seed'] = seed # Mistral uses 'random_seed'
         return params
+    
 
-    def _prepare_messages(self, discussion: LollmsDiscussion, branch_tip_id: Optional[str] = None) -> List[ChatMessage]:
-        """Prepares the message list for the Mistral API from a LollmsDiscussion."""
+    def _prepare_messages(self, discussion: LollmsDiscussion, branch_tip_id: Optional[str] = None) -> List[Dict[str, any]]:
+        """Prepares the message list for the API from a LollmsDiscussion."""
         history = []
         if discussion.system_prompt:
-            # Mistral prefers the system prompt as the first message with a user/assistant turn.
-            # A lone system message is not ideal. We will prepend it to the first user message.
-            # However, for API consistency, we will treat it as a separate message if it exists.
-            # The official client will likely handle this.
-            history.append(ChatMessage(role="system", content=discussion.system_prompt))
+            history.append({"role": "system", "content": discussion.system_prompt})
 
         for msg in discussion.get_messages(branch_tip_id):
             role = 'user' if msg.sender_type == "user" else 'assistant'
-            # Note: Mistral API currently does not support image inputs via the chat endpoint.
+            # Note: Vision support depends on the specific model being called via OpenRouter.
+            # We will not implement it in this generic binding to avoid complexity,
+            # as different models might expect different formats.
             if msg.content:
-                history.append(ChatMessage(role=role, content=msg.content))
+                history.append({'role': role, 'content': msg.content})
         return history
 
-    def generate_text(self, prompt: str, **kwargs) -> Union[str, dict]:
+    def generate_text(self,
+                    prompt: str,
+                    images: Optional[List[str]] = None,
+                    system_prompt: str = "",
+                    n_predict: Optional[int] = None,
+                    stream: Optional[bool] = None,
+                    temperature: float = 0.7,  # Ollama default is 0.8, common default 0.7
+                    top_k: int = 40,          # Ollama default is 40
+                    top_p: float = 0.9,       # Ollama default is 0.9
+                    repeat_penalty: float = 1.1,  # Ollama default is 1.1
+                    repeat_last_n: int = 64,  # Ollama default is 64
+                    seed: Optional[int] = None,
+                    n_threads: Optional[int] = None,
+                    ctx_size: int | None = None,
+                    streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                    split: Optional[bool] = False,  # put to true if the prompt is a discussion
+                    user_keyword: Optional[str] = "!@>user:",
+                    ai_keyword: Optional[str] = "!@>assistant:",
+                    **kwargs
+                    ) -> Union[str, dict]:
         """
-        Generate text using Mistral. This is a wrapper around the chat method.
+        Generate text using OpenRouter. This is a wrapper around the chat method.
         """
-        temp_discussion = LollmsDiscussion.from_messages([
-            LollmsMessage.new_message(sender_type="user", content=prompt)
-        ])
-        if kwargs.get("system_prompt"):
-            temp_discussion.system_prompt = kwargs.get("system_prompt")
+        temp_discussion = LollmsDiscussion(None)
+        temp_discussion.add_message(sender="user", content=prompt, images=images or [])
+        if system_prompt:
+            temp_discussion.system_prompt = system_prompt
         
-        return self.chat(temp_discussion, **kwargs)
+        return self.chat(temp_discussion, 
+                        n_predict=n_predict,
+                        stream=stream,
+                        temperature=temperature,
+                        top_k=top_k,
+                        top_p=top_p,
+                        repeat_penalty=repeat_penalty,
+                        repeat_last_n=repeat_last_n,
+                        seed=seed,
+                        n_threads=n_threads,
+                        ctx_size=ctx_size,
+                        streaming_callback=streaming_callback,
+                        split=split,
+                        user_keyword=user_keyword,
+                        ai_keyword=ai_keyword,
+                        **kwargs)
 
     def chat(self,
              discussion: LollmsDiscussion,
@@ -117,7 +147,7 @@ class MistralBinding(LollmsLLMBinding):
 
         try:
             if stream:
-                response = self.client.chat_stream(
+                response = self.client.chat.stream(
                     model=self.model_name,
                     messages=messages,
                     **api_params
@@ -131,7 +161,7 @@ class MistralBinding(LollmsLLMBinding):
                                 break
                 return full_response_text
             else:
-                response = self.client.chat(
+                response = self.client.chat.complete(
                     model=self.model_name,
                     messages=messages,
                     **api_params
@@ -201,7 +231,7 @@ class MistralBinding(LollmsLLMBinding):
             return []
         try:
             ASCIIColors.debug("Listing Mistral models...")
-            models = self.client.list_models()
+            models = self.client.models.list()
             model_info_list = []
             for m in models.data:
                 model_info_list.append({
@@ -264,7 +294,6 @@ if __name__ == '__main__':
         ASCIIColors.cyan("\n--- Text Generation (Streaming) ---")
         full_streamed_text = ""
         def stream_callback(chunk: str, msg_type: int):
-            nonlocal full_streamed_text
             ASCIIColors.green(chunk, end="", flush=True)
             full_streamed_text += chunk
             return True

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
-                 open_router_api_key: str = None,
                  **kwargs
                  ):
         """
@@ -37,11 +35,11 @@ class OpenRouterBinding(LollmsLLMBinding):
 
         Args:
             model_name (str): The name of the model to use from OpenRouter (e.g., 'anthropic/claude-3-haiku-20240307').
-            open_router_api_key (str): The API key for the OpenRouter service.
+            service_key (str): The API key for the OpenRouter service.
         """
-        super().__init__(binding_name=BindingName)
-        self.model_name = model_name
-        self.api_key = open_router_api_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.")
@@ -84,17 +82,50 @@ class OpenRouterBinding(LollmsLLMBinding):
                 history.append({'role': role, 'content': msg.content})
         return history
 
-    def generate_text(self, prompt: str, **kwargs) -> Union[str, dict]:
+    def generate_text(self,
+                    prompt: str,
+                    images: Optional[List[str]] = None,
+                    system_prompt: str = "",
+                    n_predict: Optional[int] = None,
+                    stream: Optional[bool] = None,
+                    temperature: float = 0.7,  # Ollama default is 0.8, common default 0.7
+                    top_k: int = 40,          # Ollama default is 40
+                    top_p: float = 0.9,       # Ollama default is 0.9
+                    repeat_penalty: float = 1.1,  # Ollama default is 1.1
+                    repeat_last_n: int = 64,  # Ollama default is 64
+                    seed: Optional[int] = None,
+                    n_threads: Optional[int] = None,
+                    ctx_size: int | None = None,
+                    streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                    split: Optional[bool] = False,  # put to true if the prompt is a discussion
+                    user_keyword: Optional[str] = "!@>user:",
+                    ai_keyword: Optional[str] = "!@>assistant:",
+                    **kwargs
+                    ) -> Union[str, dict]:
         """
         Generate text using OpenRouter. This is a wrapper around the chat method.
         """
-        temp_discussion = LollmsDiscussion.from_messages([
-            LollmsMessage.new_message(sender_type="user", content=prompt)
-        ])
-        if kwargs.get("system_prompt"):
-            temp_discussion.system_prompt = kwargs.get("system_prompt")
+        temp_discussion = LollmsDiscussion(None)
+        temp_discussion.add_message(sender="user", content=prompt, images=images or [])
+        if system_prompt:
+            temp_discussion.system_prompt = system_prompt
         
-        return self.chat(temp_discussion, **kwargs)
+        return self.chat(temp_discussion, 
+                        n_predict=n_predict,
+                        stream=stream,
+                        temperature=temperature,
+                        top_k=top_k,
+                        top_p=top_p,
+                        repeat_penalty=repeat_penalty,
+                        repeat_last_n=repeat_last_n,
+                        seed=seed,
+                        n_threads=n_threads,
+                        ctx_size=ctx_size,
+                        streaming_callback=streaming_callback,
+                        split=split,
+                        user_keyword=user_keyword,
+                        ai_keyword=ai_keyword,
+                        **kwargs)
 
     def chat(self,
              discussion: LollmsDiscussion,
@@ -121,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.")

lollms_client/llm_bindings/vllm/__init__.py

@@ -232,24 +232,28 @@ 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 
         ):
+        """Initializes the VLLM binding with the specified model and configuration.
+        Args:
+            models_folder (Optional[Union[str, Path]]): Path to the directory containing local models.²
+            model_name (str): Name or ID of the model to load. Can be a Hugging Face Hub ID or local folder name.
+            service_key (Optional[str]): Service key for authentication (not used in this binding).
+            verify_ssl_certificate (bool): Whether to verify SSL certificates (not used in this binding).
+            default_completion_format (ELF_COMPLETION_FORMAT): Default format for text generation.
+        """
         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")
+        default_completion_format = kwargs.get("default_completion_format", ELF_COMPLETION_FORMAT.Chat)
         _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
+        super().__init__(BindingName, **kwargs)
+        self.models_folder= kwargs.get("models_folder")
+        self.model_name=kwargs.get("model_name")
         self.default_completion_format=default_completion_format
 
         
@@ -261,11 +265,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]: