lollms-client 0.12.3__py3-none-any.whl → 0.12.4__py3-none-any.whl

lollms_client/llm_bindings/ollama/__init__.py

@@ -3,11 +3,19 @@ import requests
 import json
 from lollms_client.lollms_llm_binding import LollmsLLMBinding
 from lollms_client.lollms_types import MSG_TYPE
-from lollms_client.lollms_utilities import encode_image
+# encode_image is not strictly needed if ollama-python handles paths, but kept for consistency if ever needed.
+# from lollms_client.lollms_utilities import encode_image 
 from lollms_client.lollms_types import ELF_COMPLETION_FORMAT
-from typing import Optional, Callable, List, Union
+from typing import Optional, Callable, List, Union, Dict
+
 from ascii_colors import ASCIIColors, trace_exception
 
+try:
+    import ollama
+except ImportError:
+    ASCIIColors.warning("Ollama library not found. Please install it using 'pip install ollama'")
+    ollama = None
+
 BindingName = "OllamaBinding"
 
 
@@ -15,7 +23,9 @@ def count_tokens_ollama(
     text_to_tokenize: str,
     model_name: str,
     ollama_host: str = "http://localhost:11434",
-    timeout: int = 30
+    timeout: int = 30,
+    verify_ssl_certificate: bool = True,
+    headers: Optional[Dict[str, str]] = None
 ) -> int:
     """
     Counts the number of tokens in a given text using a specified Ollama model
@@ -26,25 +36,21 @@ def count_tokens_ollama(
         model_name (str): The name of the Ollama model to use (e.g., "llama3", "mistral").
         ollama_host (str): The base URL of the Ollama server (default: "http://localhost:11434").
         timeout (int): Timeout for the request in seconds (default: 30).
+        verify_ssl_certificate (bool): Whether to verify SSL.
+        headers (Optional[Dict[str, str]]): Optional headers for the request.
 
     Returns:
         int: The number of tokens. Returns -1 if an error occurs.
-
-    Raises:
-        requests.exceptions.RequestException: For network issues or timeouts.
-        requests.exceptions.HTTPError: For HTTP error responses (4xx or 5xx).
-        ValueError: If the response from Ollama is not as expected (e.g., missing 'tokens' key).
     """
-    api_url = f"{ollama_host}/api/tokenize"
+    api_url = f"{ollama_host.rstrip('/')}/api/tokenize"
     payload = {
         "model": model_name,
         "prompt": text_to_tokenize
-        # You can add "options" here if needed, but for tokenization, it's usually not required.
-        # "options": {"num_ctx": 4096} # Example, might influence tokenizer for specific context length
     }
+    request_headers = headers if headers else {}
 
     try:
-        response = requests.post(api_url, json=payload, timeout=timeout)
+        response = requests.post(api_url, json=payload, timeout=timeout, verify=verify_ssl_certificate, headers=request_headers)
         response.raise_for_status()  # Raises HTTPError for bad responses (4xx or 5xx)
 
         response_data = response.json()
@@ -52,33 +58,28 @@ def count_tokens_ollama(
         if "tokens" in response_data and isinstance(response_data["tokens"], list):
             return len(response_data["tokens"])
         else:
-            raise ValueError(
-                f"Ollama response did not contain a 'tokens' list. Response: {response_data}"
+            ASCIIColors.warning(
+                f"Ollama response for token count did not contain a 'tokens' list. Response: {response_data}"
             )
+            return -1 # Or raise ValueError
 
     except requests.exceptions.HTTPError as http_err:
-        # You might want to inspect http_err.response.text for more details from Ollama
-        print(f"HTTP error occurred: {http_err} - {http_err.response.text}")
-        raise  # Re-raise the exception
-    except requests.exceptions.ConnectionError as conn_err:
-        print(f"Connection error occurred: {conn_err}")
-        raise
-    except requests.exceptions.Timeout as timeout_err:
-        print(f"Timeout error occurred: {timeout_err}")
-        raise
+        ASCIIColors.error(f"HTTP error occurred during token count: {http_err} - {http_err.response.text if http_err.response else 'No response text'}")
+        return -1
     except requests.exceptions.RequestException as req_err:
-        print(f"An unexpected error occurred with the request: {req_err}")
-        raise
+        ASCIIColors.error(f"Request error occurred during token count: {req_err}")
+        return -1
     except json.JSONDecodeError as json_err:
-        # This can happen if the server returns non-JSON, e.g., an HTML error page
-        raise ValueError(
-            f"Failed to decode JSON response from Ollama: {json_err}. Response text: {response.text}"
-        ) from json_err
-    except ValueError as val_err: # Catches the ValueError raised above for missing 'tokens'
-        print(f"Value error: {val_err}")
-        raise
+        ASCIIColors.error(
+            f"Failed to decode JSON response from Ollama during token count: {json_err}. Response text: {response.text if hasattr(response, 'text') else 'No response object'}"
+        )
+        return -1
+    except Exception as e:
+        ASCIIColors.error(f"An unexpected error occurred during token count: {e}")
+        return -1
+
 class OllamaBinding(LollmsLLMBinding):
-    """Ollama-specific binding implementation"""
+    """Ollama-specific binding implementation using the ollama-python library."""
     
     DEFAULT_HOST_ADDRESS = "http://localhost:11434"
     
@@ -95,282 +96,483 @@ class OllamaBinding(LollmsLLMBinding):
         Args:
             host_address (str): Host address for the Ollama service. Defaults to DEFAULT_HOST_ADDRESS.
             model_name (str): Name of the model to use. Defaults to empty string.
-            service_key (str): Authentication key for the service. Defaults to None.
+            service_key (str): Authentication key for the service (used in Authorization header). Defaults to None.
             verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
-            personality (Optional[int]): Ignored parameter for compatibility with LollmsLLMBinding.
+            default_completion_format (ELF_COMPLETION_FORMAT): Default completion format.
         """
+        _host_address = host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS
         super().__init__(
-            binding_name="ollama",
-            host_address=host_address if host_address is not None else self.DEFAULT_HOST_ADDRESS,
+            binding_name=BindingName, # Use the module-level BindingName
+            host_address=_host_address,
             model_name=model_name,
             service_key=service_key,
             verify_ssl_certificate=verify_ssl_certificate,
             default_completion_format=default_completion_format
         )
-        self.model = None
+        if ollama is None:
+            raise ImportError("Ollama library is not installed. Please run 'pip install ollama'.")
+
+        self.ollama_client_headers = {}
+        if self.service_key:
+            self.ollama_client_headers['Authorization'] = f'Bearer {self.service_key}'
+
+        try:
+            self.ollama_client = ollama.Client(
+                host=self.host_address,
+                headers=self.ollama_client_headers if self.ollama_client_headers else None,
+                verify=self.verify_ssl_certificate # Passed to httpx.Client
+            )
+        except Exception as e:
+            ASCIIColors.error(f"Failed to initialize Ollama client: {e}")
+            self.ollama_client = None # Ensure it's None if initialization fails
+            # Optionally re-raise or handle so the binding is clearly unusable
+            raise ConnectionError(f"Could not connect or initialize Ollama client at {self.host_address}: {e}") from e
     
     def generate_text(self, 
                      prompt: str,
-                     images: Optional[List[str]] = None,
+                     images: Optional[List[str]] = None, # List of image file paths
                      n_predict: Optional[int] = None,
                      stream: bool = False,
-                     temperature: float = 0.1,
-                     top_k: int = 50,
-                     top_p: float = 0.95,
-                     repeat_penalty: float = 0.8,
-                     repeat_last_n: int = 40,
+                     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: int = 8,
-                     ctx_size: int | None = None,
-                     streaming_callback: Optional[Callable[[str, str], None]] = None) -> Union[str, dict]:
+                     n_threads: Optional[int] = None, # Ollama calls this num_thread
+                     ctx_size: Optional[int] = None,  # Ollama calls this num_ctx
+                     streaming_callback: Optional[Callable[[str, int], bool]] = None
+                     ) -> Union[str, Dict[str, any]]:
         """
         Generate text using the Ollama service, with optional image support.
 
         Args:
             prompt (str): The input prompt for text generation.
             images (Optional[List[str]]): List of image file paths for multimodal generation.
-                If provided, uses the /api endpoint with message format.
-            n_predict (Optional[int]): Maximum number of tokens to generate.
+            n_predict (Optional[int]): Maximum number of tokens to generate (num_predict).
             stream (bool): Whether to stream the output. Defaults to False.
-            temperature (float): Sampling temperature. Defaults to 0.1.
-            top_k (int): Top-k sampling parameter. Defaults to 50 (not used in Ollama API directly).
-            top_p (float): Top-p sampling parameter. Defaults to 0.95 (not used in Ollama API directly).
-            repeat_penalty (float): Penalty for repeated tokens. Defaults to 0.8 (not used in Ollama API directly).
-            repeat_last_n (int): Number of previous tokens to consider for repeat penalty. Defaults to 40 (not used).
+            temperature (float): Sampling temperature.
+            top_k (int): Top-k sampling parameter.
+            top_p (float): Top-p sampling parameter.
+            repeat_penalty (float): Penalty for repeated tokens.
+            repeat_last_n (int): Number of previous tokens to consider for repeat penalty.
             seed (Optional[int]): Random seed for generation.
-            n_threads (int): Number of threads to use. Defaults to 8 (not used in Ollama API directly).
-            streaming_callback (Optional[Callable[[str, str], None]]): Callback for streaming output.
+            n_threads (Optional[int]): Number of threads to use (num_thread).
+            ctx_size (Optional[int]): Context window size (num_ctx).
+            streaming_callback (Optional[Callable[[str, int], bool]]): Callback for streaming output.
                 - First parameter (str): The chunk of text received from the stream.
-                - Second parameter (str): The message type (typically MSG_TYPE.MSG_TYPE_CHUNK).
+                - Second parameter (int): The message type (typically MSG_TYPE.MSG_TYPE_CHUNK).
+                Return False to stop streaming.
 
         Returns:
-            Union[str, dict]: Generated text if successful, or a dictionary with status and error if failed.
-
-        Note:
-            Some parameters (top_k, top_p, repeat_penalty, repeat_last_n, n_threads) are included for interface
-            consistency but are not directly used in the Ollama API implementation.
+            Union[str, Dict[str, any]]: Generated text if successful, or a dictionary with status and error if failed.
         """
-        # Set headers
-        headers = {
-            'Content-Type': 'application/json',
-        }
-        if self.service_key:
-            headers['Authorization'] = f'Bearer {self.service_key}'
-
-        # Clean host address
-        host_address = self.host_address.rstrip('/')
-
-        # Prepare data based on whether images are provided
-        if images:
-            # Multimodal generation using /api endpoint
-            images_list = [encode_image(image_path) for image_path in images]
-            data = {
-                'model': self.model_name,
-                'messages': [{
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": prompt}
-                    ] + [
-                        {
-                            "type": "image_url",
-                            "image_url": {"url": f"data:image/jpeg;base64,{img}"}
-                        } for img in images_list
-                    ]
-                }],
-                "stream": stream,
-                "temperature": float(temperature),
-                "max_tokens": n_predict,
-            }
-            if ctx_size is not None:
-                data["num_ctx"] = ctx_size            
-            url = f'{host_address}/api/chat'
-        else:
-            # Text-only generation using /api/generate endpoint
-            data = {
-                'model': self.model_name,
-                'prompt': prompt,
-                "stream": stream,
-                "temperature": float(temperature),
-                "max_tokens": n_predict
-            }
-            url = f'{host_address}/api/generate'
-
-        # Make the request
-        response = requests.post(url, json=data, headers=headers, stream=stream)
-
-        # Handle response
-        if not stream:
-            if response.status_code == 200:
-                try:
-                    if images:
-                        # For multimodal, response is in chat format
-                        return response.json()["message"]["content"]
-                    else:
-                        # For text-only
-                        return response.json()["response"]
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
-            elif response.status_code == 404:
-                ASCIIColors.error(response.content.decode("utf-8", errors='ignore'))
-                return {"status": False, "error": "404 Not Found"}
-            else:
-                return {"status": False, "error": response.text}
-        else:
-            text = ""
-            if response.status_code == 200:
-                try:
-                    for line in response.iter_lines():
-                        decoded = line.decode("utf-8")
-                        if images:
-                            # Streaming with images (chat format)
-                            if decoded.startswith("data: "):
-                                json_data = json.loads(decoded[5:].strip())
-                                chunk = json_data["message"]["content"] if "message" in json_data else ""
-                            else:
-                                continue
-                        else:
-                            # Streaming without images (generate format)
-                            json_data = json.loads(decoded)
-                            chunk = json_data["response"]
-                        
-                        text += chunk
-                        if streaming_callback:
-                            if not streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK):
-                                break
-                    return text
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
-            elif response.status_code == 404:
-                ASCIIColors.error(response.content.decode("utf-8", errors='ignore'))
-                return {"status": False, "error": "404 Not Found"}
-            elif response.status_code == 400:
-                try:
-                    content = json.loads(response.content.decode("utf8"))
-                    return {"status": False, "error": content.get("error", {}).get("message", content.get("message", "Unknown error"))}
-                except:
-                    return {"status": False, "error": response.content.decode("utf8")}
-            else:
-                return {"status": False, "error": response.text}
+        if not self.ollama_client:
+             return {"status": False, "error": "Ollama client not initialized."}
+
+        options = {}
+        if n_predict is not None: options['num_predict'] = n_predict
+        if temperature is not None: options['temperature'] = float(temperature)
+        if top_k is not None: options['top_k'] = top_k
+        if top_p is not None: options['top_p'] = top_p
+        if repeat_penalty is not None: options['repeat_penalty'] = repeat_penalty
+        if repeat_last_n is not None: options['repeat_last_n'] = repeat_last_n
+        if seed is not None: options['seed'] = seed
+        if n_threads is not None: options['num_thread'] = n_threads
+        if ctx_size is not None: options['num_ctx'] = ctx_size
+        
+        full_response_text = ""
+
+        try:
+            if images: # Multimodal
+                # ollama-python expects paths or bytes for images
+                processed_images = []
+                for img_path in images:
+                    # Assuming img_path is a file path. ollama-python will read and encode it.
+                    # If images were base64 strings, they would need decoding to bytes first.
+                    processed_images.append(img_path)
+
+                messages = [{'role': 'user', 'content': prompt, 'images': processed_images if processed_images else None}]
+                
+                if stream:
+                    response_stream = self.ollama_client.chat(
+                        model=self.model_name,
+                        messages=messages,
+                        stream=True,
+                        options=options if options else None
+                    )
+                    for chunk_dict in response_stream:
+                        chunk_content = chunk_dict.get('message', {}).get('content', '')
+                        if chunk_content: # Ensure there is content to process
+                            full_response_text += chunk_content
+                            if streaming_callback:
+                                if not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                    break # Callback requested stop
+                    return full_response_text
+                else: # Not streaming
+                    response_dict = self.ollama_client.chat(
+                        model=self.model_name,
+                        messages=messages,
+                        stream=False,
+                        options=options if options else None
+                    )
+                    return response_dict.get('message', {}).get('content', '')
+            else: # Text-only
+                if stream:
+                    response_stream = self.ollama_client.generate(
+                        model=self.model_name,
+                        prompt=prompt,
+                        stream=True,
+                        options=options if options else None
+                    )
+                    for chunk_dict in response_stream:
+                        chunk_content = chunk_dict.get('response', '')
+                        if chunk_content:
+                            full_response_text += chunk_content
+                            if streaming_callback:
+                                if not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                    break
+                    return full_response_text
+                else: # Not streaming
+                    response_dict = self.ollama_client.generate(
+                        model=self.model_name,
+                        prompt=prompt,
+                        stream=False,
+                        options=options if options else None
+                    )
+                    return response_dict.get('response', '')
+        except ollama.ResponseError as e:
+            error_message = f"Ollama API ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code})"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message, "status_code": e.status_code}
+        except ollama.RequestError as e: # Covers connection errors, timeouts during request
+            error_message = f"Ollama API RequestError: {str(e)}"
+            ASCIIColors.error(error_message)
+            return {"status": False, "error": error_message}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred: {str(ex)}"
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
     
-    def tokenize(self, text: str) -> list:
+    def tokenize(self, text: str) -> List[Union[int, str]]:
         """
-        Tokenize the input text into a list of characters.
+        Tokenize the input text. For Ollama, this is complex as tokenization is model-specific
+        and best done by the server. This method provides a basic character-level tokenization
+        as a fallback or placeholder, or one could attempt to call /api/tokenize if desired.
+        The `count_tokens` method is more accurate for Ollama.
 
         Args:
             text (str): The text to tokenize.
 
         Returns:
-            list: List of individual characters.
+            list: List of tokens (characters or token IDs if /api/tokenize is used).
         """
-        return list(text)
-    
-    def detokenize(self, tokens: list) -> str:
+        # Basic character-level tokenization
+        # return list(text)
+
+        # For actual token IDs (slower, makes a network request):
+        api_url = f"{self.host_address.rstrip('/')}/api/tokenize"
+        payload = {"model": self.model_name, "prompt": text}
+        try:
+            response = requests.post(api_url, json=payload, timeout=10, verify=self.verify_ssl_certificate, headers=self.ollama_client_headers)
+            response.raise_for_status()
+            return response.json().get("tokens", [])
+        except Exception as e:
+            ASCIIColors.warning(f"Failed to tokenize text with Ollama server, falling back to char tokens: {e}")
+            return list(text)
+
+    def detokenize(self, tokens: List[Union[int,str]]) -> str:
         """
-        Convert a list of tokens back to text.
+        Convert a list of tokens back to text. If tokens are characters, joins them.
+        If tokens are IDs, this is non-trivial without the model's tokenizer.
 
         Args:
-            tokens (list): List of tokens (characters) to detokenize.
+            tokens (list): List of tokens to detokenize.
 
         Returns:
             str: Detokenized text.
         """
-        return "".join(tokens)
+        if not tokens:
+            return ""
+        if isinstance(tokens[0], str): # Assuming character tokens
+            return "".join(tokens)
+        else: 
+            # Detokenizing IDs from Ollama is not straightforward client-side without specific tokenizer.
+            # This is a placeholder. For Ollama, detokenization usually happens server-side.
+            ASCIIColors.warning("Detokenizing integer tokens is not accurately supported by this Ollama client binding. Returning joined string of token IDs.")
+            return "".join(map(str, tokens))
     
     def count_tokens(self, text: str) -> int:
         """
-        Count tokens from a text.
+        Count tokens from a text using the Ollama server's /api/tokenize endpoint.
 
         Args:
-            tokens (list): List of tokens to detokenize.
+            text (str): Text to count tokens from.
 
         Returns:
-            int: Number of tokens in text.
+            int: Number of tokens in text. Returns -1 on error.
         """        
-        return count_tokens_ollama(text, self.model_name, self.host_address)
+        if not self.model_name:
+            ASCIIColors.warning("Cannot count tokens, model_name is not set.")
+            return -1
+        return count_tokens_ollama(text, self.model_name, self.host_address, verify_ssl_certificate=self.verify_ssl_certificate, headers=self.ollama_client_headers)
     
-    def embed(self, text: str, **kwargs) -> list:
+    def embed(self, text: str, **kwargs) -> List[float]:
         """
-        Get embeddings for the input text using Ollama API
+        Get embeddings for the input text using Ollama API.
         
         Args:
-            text (str or List[str]): Input text to embed
-            **kwargs: Additional arguments like model, truncate, options, keep_alive
+            text (str): Input text to embed.
+            **kwargs: Optional arguments. Can include 'model' to override self.model_name,
+                      and 'options' dictionary for Ollama embedding options.
         
         Returns:
-            dict: Response containing embeddings
-        """
-        import requests
-        
-        url = f"{self.base_url}/api/embed"
-        
-        # Prepare the request payload
-        payload = {
-            "input": text,
-            "model": kwargs.get("model", "llama2")  # default model
-        }
-        
-        # Add optional parameters if provided
-        if "truncate" in kwargs:
-            payload["truncate"] = kwargs["truncate"]
-        if "options" in kwargs:
-            payload["options"] = kwargs["options"]
-        if "keep_alive" in kwargs:
-            payload["keep_alive"] = kwargs["keep_alive"]
+            List[float]: The embedding vector.
         
+        Raises:
+            Exception: if embedding fails or Ollama client is not available.
+        """
+        if not self.ollama_client:
+             raise Exception("Ollama client not initialized.")
+
+        model_to_use = kwargs.get("model", self.model_name)
+        if not model_to_use:
+            raise ValueError("Model name for embedding must be specified either in init or via kwargs.")
+            
+        ollama_options = kwargs.get("options", None)
         try:
-            response = requests.post(url, json=payload)
-            response.raise_for_status()  # Raise exception for bad status codes
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            raise Exception(f"Embedding request failed: {str(e)}")  
+            response = self.ollama_client.embeddings(
+                model=model_to_use, 
+                prompt=text,
+                options=ollama_options
+            )
+            return response['embedding']
+        except ollama.ResponseError as e:
+            error_message = f"Ollama API Embeddings ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code})"
+            ASCIIColors.error(error_message)
+            raise Exception(error_message) from e
+        except ollama.RequestError as e:
+            error_message = f"Ollama API Embeddings RequestError: {str(e)}"
+            ASCIIColors.error(error_message)
+            raise Exception(error_message) from e
+        except Exception as ex:
+            trace_exception(ex)
+            raise Exception(f"Embedding failed: {str(ex)}") from ex
         
-
     def get_model_info(self) -> dict:
         """
-        Return information about the current Ollama model.
+        Return information about the current Ollama model setup.
 
         Returns:
-            dict: Dictionary containing model name, version, and host address.
+            dict: Dictionary containing binding name, version, host address, and model name.
         """
         return {
-            "name": "ollama",
-            "version": "2.0",
+            "name": self.binding_name, # from super class
+            "version": ollama.__version__ if ollama else "unknown", # Ollama library version
             "host_address": self.host_address,
-            "model_name": self.model_name
+            "model_name": self.model_name,
+            "supports_structured_output": False, # Ollama primarily supports text/chat
+            "supports_vision": True # Many Ollama models (e.g. llava, bakllava) support vision
         }
-    def listModels(self):
-        """ Lists available models """
-        url = f'{self.host_address}/api/tags'
-        headers = {
-                    'accept': 'application/json',
-                    'Authorization': f'Bearer {self.service_key}'
-                }
-        response = requests.get(url, headers=headers, verify= self.verify_ssl_certificate)
-        try:
-            ASCIIColors.debug("Listing ollama models")
-            data = response.json()
-            model_info = []
 
-            for model in data['models']:
-                model_name = model['name']
-                owned_by = ""
-                created_datetime = model["modified_at"]
-                model_info.append({'model_name': model_name, 'owned_by': owned_by, 'created_datetime': created_datetime})
-
-            return model_info
+    def listModels(self) -> List[Dict[str, str]]:
+        """
+        Lists available models from the Ollama service using the ollama-python library.
+        The returned list of dictionaries matches the format of the original template.
+        
+        Returns:
+            List[Dict[str, str]]: A list of model information dictionaries.
+                                  Each dict has 'model_name', 'owned_by', 'created_datetime'.
+        """
+        if not self.ollama_client:
+            ASCIIColors.error("Ollama client not initialized. Cannot list models.")
+            return []
+        try:
+            ASCIIColors.debug(f"Listing ollama models from {self.host_address}")
+            response_data = self.ollama_client.list() # This returns {'models': [{'name':..., 'modified_at':..., ...}]}
+            
+            model_info_list = []
+            if 'models' in response_data:
+                for model_entry in response_data['models']:
+                    model_info_list.append({
+                        'model_name': model_entry.get('model'),
+                        'owned_by': "", # Ollama API doesn't provide a direct "owned_by" field.
+                        'created_datetime': model_entry.get('modified_at') 
+                    })
+            return model_info_list
+        except ollama.ResponseError as e:
+            ASCIIColors.error(f"Ollama API listModels ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code}) from {self.host_address}")
+            return []
+        except ollama.RequestError as e: # Covers connection errors, timeouts during request
+            ASCIIColors.error(f"Ollama API listModels RequestError: {str(e)} from {self.host_address}")
+            return []
         except Exception as ex:
             trace_exception(ex)
             return []
+
     def load_model(self, model_name: str) -> bool:
         """
-        Load a specific model into the Ollama binding.
+        Set the model name for subsequent operations. Ollama loads models on demand.
+        This method can be used to verify if a model exists by attempting a small operation,
+        but for now, it just sets the name.
 
         Args:
-            model_name (str): Name of the model to load.
+            model_name (str): Name of the model to set.
 
         Returns:
-            bool: True if model loaded successfully.
+            bool: True if model name is set.
         """
-        self.model = model_name
         self.model_name = model_name
+        # Optionally, you could try a quick self.ollama_client.show(model_name) to verify existence.
+        # For simplicity, we just set it.
+        ASCIIColors.info(f"Ollama model set to: {model_name}. It will be loaded by the server on first use.")
         return True
+
+if __name__ == '__main__':
+    global full_streamed_text
+    # Example Usage (requires an Ollama server running)
+    ASCIIColors.yellow("Testing OllamaBinding...")
+
+    # --- Configuration ---
+    # Replace with your Ollama server details if not localhost
+    ollama_host = "http://localhost:11434" 
+    # Common model, pull it first: `ollama pull llama3` or `ollama pull llava` for vision
+    test_model_name = "llama3" 
+    test_vision_model_name = "llava" # or another vision model you have
+
+    try:
+        # --- Initialization ---
+        ASCIIColors.cyan("\n--- Initializing Binding ---")
+        binding = OllamaBinding(host_address=ollama_host, model_name=test_model_name)
+        ASCIIColors.green("Binding initialized successfully.")
+        ASCIIColors.info(f"Using Ollama client version: {ollama.__version__ if ollama else 'N/A'}")
+
+        # --- List Models ---
+        ASCIIColors.cyan("\n--- Listing Models ---")
+        models = binding.listModels()
+        if models:
+            ASCIIColors.green(f"Found {len(models)} models. First 5:")
+            for m in models[:5]:
+                print(m)
+        else:
+            ASCIIColors.warning("No models found or failed to list models. Ensure Ollama is running and has models.")
+
+        # --- Load Model (sets active model) ---
+        ASCIIColors.cyan(f"\n--- Setting model to: {test_model_name} ---")
+        binding.load_model(test_model_name)
+
+        # --- Count Tokens ---
+        ASCIIColors.cyan("\n--- Counting Tokens ---")
+        sample_text = "Hello, world! This is a test."
+        token_count = binding.count_tokens(sample_text)
+        ASCIIColors.green(f"Token count for '{sample_text}': {token_count}")
+
+        # --- Tokenize/Detokenize (using server for tokenize) ---
+        ASCIIColors.cyan("\n--- Tokenize/Detokenize ---")
+        tokens = binding.tokenize(sample_text)
+        ASCIIColors.green(f"Tokens for '{sample_text}': {tokens[:10]}...") # Print first 10
+        detokenized_text = binding.detokenize(tokens)
+        # Note: detokenize might not be perfect if tokens are IDs and not chars
+        ASCIIColors.green(f"Detokenized text (may vary based on tokenization type): {detokenized_text}")
+
+
+        # --- Text Generation (Non-Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Non-Streaming) ---")
+        prompt_text = "Why is the sky blue?"
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        generated_text = binding.generate_text(prompt_text, n_predict=50, stream=False)
+        if isinstance(generated_text, str):
+            ASCIIColors.green(f"Generated text: {generated_text}")
+        else:
+            ASCIIColors.error(f"Generation failed: {generated_text}")
+
+        # --- Text Generation (Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Streaming) ---")
+        full_streamed_text = ""
+        def stream_callback(chunk: str, msg_type: int):
+            global full_streamed_text
+            print(f"{ASCIIColors.GREEN}Stream chunk: {chunk}{ASCIIColors.RESET}", end="", flush=True)
+            full_streamed_text += chunk
+            if len(full_streamed_text) > 100: # Example: stop after 100 chars for test
+                # print("\nStopping stream early for test.")
+                # return False # uncomment to test early stop
+                pass
+            return True
+        
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        result = binding.generate_text(prompt_text, n_predict=100, stream=True, streaming_callback=stream_callback)
+        print("\n--- End of Stream ---")
+        if isinstance(result, str):
+             ASCIIColors.green(f"Full streamed text: {result}") # 'result' is the full_streamed_text
+        else:
+            ASCIIColors.error(f"Streaming generation failed: {result}")
+
+
+        # --- Embeddings ---
+        ASCIIColors.cyan("\n--- Embeddings ---")
+        # Ensure you have an embedding model like 'mxbai-embed-large' or 'nomic-embed-text'
+        # Or use a general model if it supports embedding (some do implicitly)
+        # For this test, we'll try with the current test_model_name, 
+        # but ideally use a dedicated embedding model.
+        # binding.load_model("mxbai-embed-large") # if you have it
+        try:
+            embedding_text = "Lollms is a cool project."
+            embedding_vector = binding.embed(embedding_text) # Uses current self.model_name
+            ASCIIColors.green(f"Embedding for '{embedding_text}' (first 5 dims): {embedding_vector[:5]}...")
+            ASCIIColors.info(f"Embedding vector dimension: {len(embedding_vector)}")
+        except Exception as e:
+            ASCIIColors.warning(f"Could not get embedding with '{binding.model_name}': {e}. Some models don't support /api/embeddings or may need to be specified.")
+            ASCIIColors.warning("Try `ollama pull mxbai-embed-large` and set it as model for embedding.")
+
+
+        # --- Vision Model Test (if llava or similar is available) ---
+        # Create a dummy image file for testing
+        dummy_image_path = "dummy_test_image.png"
+        try:
+            from PIL import Image, ImageDraw
+            img = Image.new('RGB', (100, 30), color = ('red'))
+            d = ImageDraw.Draw(img)
+            d.text((10,10), "Hello", fill=('white'))
+            img.save(dummy_image_path)
+            ASCIIColors.info(f"Created dummy image: {dummy_image_path}")
+
+            ASCIIColors.cyan(f"\n--- Vision Generation (using {test_vision_model_name}) ---")
+            # Check if vision model exists
+            vision_model_exists = any(m['model_name'].startswith(test_vision_model_name) for m in models)
+            if not vision_model_exists:
+                ASCIIColors.warning(f"Vision model '{test_vision_model_name}' not found in pulled models. Skipping vision test.")
+                ASCIIColors.warning(f"Try: `ollama pull {test_vision_model_name}`")
+            else:
+                binding.load_model(test_vision_model_name) # Switch to vision model
+                vision_prompt = "What is written in this image?"
+                ASCIIColors.info(f"Vision Prompt: {vision_prompt} with image {dummy_image_path}")
+                
+                vision_response = binding.generate_text(
+                    prompt=vision_prompt,
+                    images=[dummy_image_path],
+                    n_predict=50,
+                    stream=False
+                )
+                if isinstance(vision_response, str):
+                    ASCIIColors.green(f"Vision model response: {vision_response}")
+                else:
+                    ASCIIColors.error(f"Vision generation failed: {vision_response}")
+        except ImportError:
+            ASCIIColors.warning("Pillow library not found. Cannot create dummy image for vision test. `pip install Pillow`")
+        except Exception as e:
+            ASCIIColors.error(f"Error during vision test: {e}")
+        finally:
+            import os
+            if os.path.exists(dummy_image_path):
+                os.remove(dummy_image_path)
+
+
+    except ConnectionRefusedError:
+        ASCIIColors.error("Connection to Ollama server refused. Is Ollama running?")
+    except ImportError as e:
+        ASCIIColors.error(f"Import error: {e}. Make sure 'ollama' library is installed ('pip install ollama').")
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during testing: {e}")
+        trace_exception(e)
+
+    ASCIIColors.yellow("\nOllamaBinding test finished.")

{lollms_client-0.12.3.dist-info → lollms_client-0.12.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.12.3
+Version: 0.12.4
 Summary: A client library for LoLLMs generate endpoint
 Home-page: https://github.com/ParisNeo/lollms_client
 Author: ParisNeo

{lollms_client-0.12.3.dist-info → lollms_client-0.12.4.dist-info}/RECORD

@@ -21,7 +21,7 @@ lollms_client/lollms_types.py,sha256=cfc1sremM8KR4avkYX99fIVkkdRvXErrCWKGjLrgv50
 lollms_client/lollms_utilities.py,sha256=YAgamfp0pBVApR68AHKjhp1lh6isMNF8iadwWLl63c0,7045
 lollms_client/llm_bindings/__init__.py,sha256=9sWGpmWSSj6KQ8H4lKGCjpLYwhnVdL_2N7gXCphPqh4,14
 lollms_client/llm_bindings/lollms/__init__.py,sha256=H1Vw6trTzinS_xaeNWZ7Aq-3XngbzoYxtA4Se2IeCpQ,12213
-lollms_client/llm_bindings/ollama/__init__.py,sha256=oOSWM7eVpDPTBGulRdHukOxpIwvA1x5VNsJEVgT2jFk,15843
+lollms_client/llm_bindings/ollama/__init__.py,sha256=o2FVeOXVSV28Rqt4cGLyFEOtV47hkwD8DOImMYVVR30,28509
 lollms_client/llm_bindings/openai/__init__.py,sha256=n8y14j6MAkaZSGMsvvUogr8LRgLsNz4S6QJJdB6H0lQ,10763
 lollms_client/llm_bindings/transformers/__init__.py,sha256=UyaiQcJQricBZJGe1zfNIVy6Cb3QpHSvImSoE9FhgC0,12771
 lollms_client/stt_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -34,8 +34,8 @@ lollms_client/tts_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 lollms_client/tts_bindings/lollms/__init__.py,sha256=8x2_T9XscvISw2TiaLoFxvrS7TIsVLdqbwSc04cX-wc,7164
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-0.12.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.12.3.dist-info/METADATA,sha256=t92LRON5mw051xnzqLrPRyagxWEklQZrnaOJwEXy9OM,6866
-lollms_client-0.12.3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-lollms_client-0.12.3.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-0.12.3.dist-info/RECORD,,
+lollms_client-0.12.4.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.12.4.dist-info/METADATA,sha256=1rYfyIfrUvJz3Sj_sAvV2ZE-G4E7Se0KZL5tipmZO0o,6866
+lollms_client-0.12.4.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+lollms_client-0.12.4.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-0.12.4.dist-info/RECORD,,