lollms-client 0.9.2__py3-none-any.whl → 0.11.0__py3-none-any.whl

lollms_client/lollms_core.py

@@ -1,143 +1,109 @@
 import requests
 from ascii_colors import ASCIIColors, trace_exception
-from lollms_client.lollms_types import MSG_TYPE
+from lollms_client.lollms_types import MSG_TYPE, ELF_COMPLETION_FORMAT
 from lollms_client.lollms_utilities import encode_image
+from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 import json
 from enum import Enum
-import tiktoken
 import base64
 import requests
 import pipmaster as pm
-from typing import List, Optional, Callable, Union
+from typing import List, Optional, Callable, Union, Dict
 import numpy as np
 import pipmaster as pm
+from pathlib import Path
 import os
-
-class ELF_GENERATION_FORMAT(Enum):
-    LOLLMS = 0
-    OPENAI = 1
-    OLLAMA = 2
-    LITELLM = 3
-    TRANSFORMERS = 4
-    VLLM = 5
-    
-    @classmethod
-    def from_string(cls, format_string: str) -> 'ELF_GENERATION_FORMAT':
-        format_mapping = {
-            "LOLLMS": cls.LOLLMS,
-            "OPENAI": cls.OPENAI,
-            "OLLAMA": cls.OLLAMA,
-            "LITELLM": cls.LITELLM,
-            "TRANSFORMERS": cls.TRANSFORMERS,
-            "VLLM": cls.VLLM
-        }
-
-        try:
-            return format_mapping[format_string.upper()]
-        except KeyError:
-            raise ValueError(f"Invalid format string: {format_string}. Must be one of {list(format_mapping.keys())}.")
-    
-    def __str__(self):
-        return self.name    
-class ELF_COMPLETION_FORMAT(Enum):
-    Instruct = 0
-    Chat = 1
-    @classmethod
-    def from_string(cls, format_string: str) -> 'ELF_COMPLETION_FORMAT':
-        format_mapping = {
-            "Instruct": cls.Instruct,
-            "Chat": cls.Chat,
-        }
-
-        try:
-            return format_mapping[format_string.upper()]
-        except KeyError:
-            raise ValueError(f"Invalid format string: {format_string}. Must be one of {list(format_mapping.keys())}.")
-    
-    def __str__(self):
-        return self.name    
         
 class LollmsClient():
-    def __init__(
-                    self, 
-                    host_address=None,
-                    model_name=None,
-                    ctx_size=32000,
-                    personality=-1, 
-                    n_predict=4096,
-                    min_n_predict=512, 
-                    temperature=0.1, 
-                    top_k=50, 
-                    top_p=0.95, 
-                    repeat_penalty=0.8, 
-                    repeat_last_n=40, 
-                    seed=None, 
-                    n_threads=8, 
-                    service_key:str="",
-                    tokenizer=None,
-                    default_generation_mode=ELF_GENERATION_FORMAT.LOLLMS,
-                    verify_ssl_certificate = True,
-                    user_name = "user",
-                    ai_name = "assistant"
-                ) -> None:
-        import tiktoken
+    """Core class for interacting with LOLLMS bindings"""
+    def __init__(self, 
+                 binding_name: str = "lollms",
+                 host_address: Optional[str] = None,
+                 model_name: str = "",
+                 service_key: Optional[str] = None,
+                 verify_ssl_certificate: bool = True,
+                 personality: Optional[int] = None,
+                 llm_bindings_dir: Path = Path(__file__).parent / "llm_bindings",
+                 binding_config: Optional[Dict[str, any]] = None,
+                 ctx_size: Optional[int] = 8192,
+                 n_predict: Optional[int] = 4096,
+                 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,
+                 seed: Optional[int] = None,
+                 n_threads: int = 8,
+                 streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                 user_name ="user",
+                 ai_name = "assistant"):
+        """
+        Initialize the LollmsCore with a binding and generation parameters.
+
+        Args:
+            binding_name (str): Name of the binding to use (e.g., "lollms", "ollama").
+            host_address (Optional[str]): Host address for the service. Overrides binding default if provided.
+            model_name (str): Name of the model to use. Defaults to empty string.
+            service_key (Optional[str]): Authentication key for the service.
+            verify_ssl_certificate (bool): Whether to verify SSL certificates. Defaults to True.
+            personality (Optional[int]): Personality ID (used only by LOLLMS binding).
+            llm_bindings_dir (Path): Directory containing binding implementations. 
+                Defaults to the "bindings" subdirectory relative to this file's location.
+            binding_config (Optional[Dict[str, any]]): Additional configuration for the binding.
+            n_predict (Optional[int]): Maximum number of tokens to generate. Default for generate_text.
+            stream (bool): Whether to stream the output. Defaults to False for generate_text.
+            temperature (float): Sampling temperature. Defaults to 0.1 for generate_text.
+            top_k (int): Top-k sampling parameter. Defaults to 50 for generate_text.
+            top_p (float): Top-p sampling parameter. Defaults to 0.95 for generate_text.
+            repeat_penalty (float): Penalty for repeated tokens. Defaults to 0.8 for generate_text.
+            repeat_last_n (int): Number of previous tokens to consider for repeat penalty. Defaults to 40.
+            seed (Optional[int]): Random seed for generation. Default for generate_text.
+            n_threads (int): Number of threads to use. Defaults to 8 for generate_text.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+                Default for generate_text. Takes a string chunk and an MSG_TYPE enum value.
+
+        Raises:
+            ValueError: If the specified binding cannot be created.
+        """
+        self.binding_manager = LollmsLLMBindingManager(llm_bindings_dir)
+        self.binding_config = binding_config or {}
+        
+        # Store generation parameters as instance variables
+        self.default_ctx_size = ctx_size
+        self.default_n_predict = n_predict
+        self.default_stream = stream
+        self.default_temperature = temperature
+        self.default_top_k = top_k
+        self.default_top_p = top_p
+        self.default_repeat_penalty = repeat_penalty
+        self.default_repeat_last_n = repeat_last_n
+        self.default_seed = seed
+        self.default_n_threads = n_threads
+        self.default_streaming_callback = streaming_callback
+        
+        # Create the binding instance
+        self.binding = self.binding_manager.create_binding(
+            binding_name=binding_name,
+            host_address=host_address,
+            model_name=model_name,
+            service_key=service_key,
+            verify_ssl_certificate=verify_ssl_certificate,
+            personality=personality
+        )
+        
+        if self.binding is None:
+            raise ValueError(f"Failed to create binding: {binding_name}. Available bindings: {self.binding_manager.get_available_bindings()}")
+        
+        # Apply additional configuration if provided
+        if binding_config:
+            for key, value in binding_config.items():
+                setattr(self.binding, key, value)
         self.user_name = user_name
         self.ai_name = ai_name
-        self.host_address=host_address
-        if not self.host_address:
-            if default_generation_mode==ELF_GENERATION_FORMAT.LOLLMS:
-                self.host_address = "http://localhost:9600"
-            elif default_generation_mode==ELF_GENERATION_FORMAT.OPENAI:
-                self.host_address = "https://api.openai.com"
-            elif default_generation_mode==ELF_GENERATION_FORMAT.OLLAMA:
-                self.host_address = "http://localhost:11434"
-            else:
-                self.host_address = "http://localhost:9600"
-
-        self.model_name = model_name
-        self.ctx_size = ctx_size
-        self.n_predict = n_predict
-        self.min_n_predict = min_n_predict
-        self.personality = personality
-        self.temperature = temperature
-        self.top_k = top_k
-        self.top_p = top_p
-        self.repeat_penalty = repeat_penalty
-        self.repeat_last_n = repeat_last_n
-        self.seed = seed
-        self.n_threads = n_threads
         self.service_key = service_key
-        if not self.service_key and default_generation_mode == ELF_GENERATION_FORMAT.OPENAI:
-            self.service_key = os.getenv("OPENAI_API_KEY","")
-        self.default_generation_mode = default_generation_mode
-        self.verify_ssl_certificate = verify_ssl_certificate
-        self.tokenizer = tiktoken.model.encoding_for_model("gpt-3.5-turbo-1106") if tokenizer is None else tokenizer
-        if default_generation_mode == ELF_GENERATION_FORMAT.TRANSFORMERS:
-            if not pm.is_installed("torch"):
-                ASCIIColors.yellow("Diffusers: Torch not found. Installing it")
-                pm.install_multiple(["torch","torchvision","torchaudio"], "https://download.pytorch.org/whl/cu121", force_reinstall=True)
-            
-            import torch
-            if not torch.cuda.is_available():
-                ASCIIColors.yellow("Diffusers: Torch not using cuda. Reinstalling it")
-                pm.install_multiple(["torch","torchvision","torchaudio"], "https://download.pytorch.org/whl/cu121", force_reinstall=True)
-                import torch
-            
-            if not pm.is_installed("transformers"):
-                pm.install_or_update("transformers")
-            from transformers import AutoModelForCausalLM, AutoTokenizer,   GenerationConfig  
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                    str(model_name), trust_remote_code=False
-                    )
-            
-            self.model = AutoModelForCausalLM.from_pretrained(
-                        str(model_name),
-                        device_map="auto",
-                        load_in_4bit=True,
-                        torch_dtype=torch.bfloat16  # Load in float16 for quantization
-                    )
-            self.generation_config = GenerationConfig.from_pretrained(str(model_name))
 
+        self.verify_ssl_certificate = verify_ssl_certificate
         self.start_header_id_template ="!@>"
         self.end_header_id_template =": "
         self.system_message_template ="system"
@@ -149,12 +115,6 @@ class LollmsClient():
         self.end_ai_header_id_template =": "
         self.end_ai_message_id_template =""
 
-        if default_generation_mode==ELF_GENERATION_FORMAT.OPENAI:        
-            if not pm.is_installed("openai"):
-                pm.install("openai")
-            import openai
-            self.client = openai.OpenAI(base_url=host_address)
-
 
     @property
     def system_full_header(self) -> str:
@@ -185,1150 +145,121 @@ class LollmsClient():
 
     def sink(self, s=None,i=None,d=None):
         pass
-
-    def tokenize(self, prompt:str):
+    def tokenize(self, text: str) -> list:
         """
-        Tokenizes the given prompt using the model's tokenizer.
+        Tokenize text using the active binding.
 
         Args:
-            prompt (str): The input prompt to be tokenized.
+            text (str): The text to tokenize.
 
         Returns:
-            list: A list of tokens representing the tokenized prompt.
+            list: List of tokens.
         """
-        tokens_list = self.tokenizer.encode(prompt)
-
-        return tokens_list
-
-    def detokenize(self, tokens_list:list):
+        return self.binding.tokenize(text)
+    
+    def detokenize(self, tokens: list) -> str:
         """
-        Detokenizes the given list of tokens using the model's tokenizer.
+        Detokenize tokens using the active binding.
 
         Args:
-            tokens_list (list): A list of tokens to be detokenized.
+            tokens (list): List of tokens to detokenize.
 
         Returns:
-            str: The detokenized text as a string.
+            str: Detokenized text.
         """
-        text = self.tokenizer.decode(tokens_list)
-
-        return text
+        return self.binding.detokenize(tokens)
     
-    def embed(self, text):
-        if self.default_generation_mode == ELF_GENERATION_FORMAT.LOLLMS:
-            return self.lollms_embed(text)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.OLLAMA:
-            return self.ollama_embed(text)
-        else:
-            return #not implemented
-            
-    def ollama_embed(self, text, **kwargs):
+    def get_model_details(self) -> dict:
         """
-        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
-        
+        Get model information from the active binding.
+
         Returns:
-            dict: Response containing embeddings
+            dict: Model information dictionary.
         """
-        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"]
-        
-        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)}")
-
-
-    def lollms_embed(self, texts, **kwargs):
-        api_key = kwargs.pop("api_key", None)
-        headers = (
-            {"Content-Type": "application/json", "Authorization": api_key}
-            if api_key
-            else {"Content-Type": "application/json"}
-        )
-        embeddings = []
-        for text in texts:
-            request_data = {"text": text}
-            response = requests.post(f"{self.host_address}/lollms_embed", json=request_data, headers=headers)
-            response.raise_for_status()
-            result = response.json()
-            embeddings.append(result["vector"])
-        return np.array(embeddings)
+        return self.binding.get_model_info()
     
-    def generate_with_images(self, prompt, images, n_predict=None, stream=False, temperature=0.1, top_k=50, top_p=0.95, repeat_penalty=0.8, repeat_last_n=40, seed=None, n_threads=8, service_key:str="", streaming_callback=None):
-        if self.default_generation_mode == ELF_GENERATION_FORMAT.LOLLMS:
-            return self.lollms_generate_with_images(prompt, images, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, service_key, streaming_callback)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.OPENAI:
-            return self.openai_generate_with_images(prompt, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, ELF_COMPLETION_FORMAT.Instruct, service_key, streaming_callback)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.OLLAMA:
-            return self.ollama_generate_with_images(prompt, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, ELF_COMPLETION_FORMAT.Instruct, service_key, streaming_callback)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.LITELLM:
-            return # To be implemented #self.litellm_generate_with_images(prompt, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, ELF_COMPLETION_FORMAT.Instruct, service_key, streaming_callback)
-
-
-    def generate(self, prompt, n_predict=None, stream=False, temperature=0.1, top_k=50, top_p=0.95, repeat_penalty=0.8, repeat_last_n=40, seed=None, n_threads=8, service_key:str="", streaming_callback=None, completion_format = ELF_COMPLETION_FORMAT.Chat):
-        if self.default_generation_mode == ELF_GENERATION_FORMAT.LOLLMS:
-            return self.lollms_generate(prompt, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, service_key, streaming_callback)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.OPENAI:
-            return self.openai_generate(prompt, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, completion_format, service_key, streaming_callback)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.OLLAMA:
-            return self.ollama_generate(prompt, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, completion_format, service_key, streaming_callback)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.LITELLM:
-            return self.litellm_generate(prompt, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, completion_format, service_key, streaming_callback)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.VLLM:
-            return self.vllm_generate(prompt, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, completion_format, service_key, streaming_callback)
-        
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.TRANSFORMERS:
-            return self.transformers_generate(prompt, self.host_address, self.model_name, -1, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, service_key, streaming_callback)
-
-
-    def generate_text(self, prompt, host_address=None, model_name=None, personality=None, n_predict=None, stream=False, temperature=0.1, top_k=50, top_p=0.95, repeat_penalty=0.8, repeat_last_n=40, seed=None, n_threads=8, service_key:str="", streaming_callback=None):
-        return self.lollms_generate(prompt, host_address, model_name, personality, n_predict, stream, temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads, service_key, streaming_callback)
-
-    def lollms_generate(self, prompt, host_address=None, model_name=None, personality=None, n_predict=None, stream=False, temperature=0.1, top_k=50, top_p=0.95, repeat_penalty=0.8, repeat_last_n=40, seed=None, n_threads=8, service_key:str="", streaming_callback=None):
-        # Set default values to instance variables if optional arguments are None
-        host_address = host_address if host_address else self.host_address
-        model_name = model_name if model_name else self.model_name
-        n_predict = n_predict if n_predict else self.n_predict
-        personality = personality if personality is not None else self.personality
-        # Set temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads to the instance variables if they are not provided or None
-        temperature = temperature if temperature is not None else self.temperature
-        top_k = top_k if top_k is not None else self.top_k
-        top_p = top_p if top_p is not None else self.top_p
-        repeat_penalty = repeat_penalty if repeat_penalty is not None else self.repeat_penalty
-        repeat_last_n = repeat_last_n if repeat_last_n is not None else self.repeat_last_n
-        seed = seed or self.seed  # Use the instance seed if not provided
-        n_threads = n_threads if n_threads else self.n_threads
-
-
-        url = f"{host_address}/lollms_generate"
-        if service_key!="":
-            headers = {
-                'Content-Type': 'application/json;',
-                'Authorization': f'Bearer {service_key}',
-            }
-        else:
-            headers = {
-                'Content-Type': 'application/json',
-            }
-        data = {
-            "prompt": prompt,
-            "model_name": self.model_name,
-            "personality": self.personality,
-            "n_predict": n_predict,
-            "stream": stream,
-            "temperature": self.temperature,
-            "top_k": self.top_k,
-            "top_p": self.top_p,
-            "repeat_penalty": repeat_penalty,
-            "repeat_last_n": repeat_last_n,
-            "seed": seed,
-            "n_threads": n_threads
-        }
-
-        response = requests.post(url, json=data, headers=headers, stream=stream)
-        if not stream:
-            if response.status_code == 200:
-                try:
-                    text = response.text.strip().rstrip('!')
-                    return text
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
-            else:
-                return {"status": False, "error": response.text}
-        else:
-            text = ""
-            if response.status_code==200:
-                try:
-                    for line in response.iter_lines():
-                        chunk = line.decode("utf-8")
-                        text += chunk
-                        if streaming_callback:
-                            streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK)
-                    return text.rstrip('!')
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
-            else:
-                return {"status": False, "error": response.text}
-            
-
-    def lollms_generate_with_images(
-        self,
-        prompt: str,
-        images: List[str],
-        host_address: Optional[str] = None,
-        model_name: Optional[str] = None,
-        personality: Optional[str] = None,
-        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,
-        seed: Optional[int] = None,
-        n_threads: int = 8,
-        service_key: str = "",
-        streaming_callback: Optional[Callable[[str, int], None]] = None
-    ) -> Union[str, dict]:
+    def switch_model(self, model_name: str) -> bool:
         """
-        Generates text based on a prompt and a list of images using a specified model.
+        Load a new model in the active binding.
 
         Args:
-            prompt (str): The text prompt to generate responses for.
-            images (List[str]): A list of file paths to images to be included in the generation.
-            host_address (Optional[str]): The host address for the service. Defaults to instance variable.
-            model_name (Optional[str]): The model name to use. Defaults to instance variable.
-            personality (Optional[str]): The personality setting for the generation. Defaults to instance variable.
-            n_predict (Optional[int]): The number of tokens to predict. Defaults to instance variable.
-            stream (bool): Whether to stream the response. Defaults to False.
-            temperature (float): Sampling temperature. Defaults to 0.1.
-            top_k (int): Top-k sampling parameter. Defaults to 50.
-            top_p (float): Top-p (nucleus) sampling parameter. Defaults to 0.95.
-            repeat_penalty (float): Penalty for repeating tokens. Defaults to 0.8.
-            repeat_last_n (int): Number of last tokens to consider for repeat penalty. Defaults to 40.
-            seed (Optional[int]): Random seed for generation. Defaults to instance variable.
-            n_threads (int): Number of threads to use. Defaults to 8.
-            service_key (str): Optional service key for authorization.
-            streaming_callback (Optional[Callable[[str, int], None]]): Callback for streaming responses.
+            model_name (str): Name of the model to load.
 
         Returns:
-            Union[str, dict]: The generated text if not streaming, or a dictionary with status and error if applicable.
+            bool: True if model loaded successfully, False otherwise.
         """
-        
-        # Set default values to instance variables if optional arguments are None
-        host_address = host_address if host_address else self.host_address
-        model_name = model_name if model_name else self.model_name
-        n_predict = n_predict if n_predict else self.n_predict
-        personality = personality if personality is not None else self.personality
-        
-        # Set parameters to instance variables if they are not provided or None
-        temperature = temperature if temperature is not None else self.temperature
-        top_k = top_k if top_k is not None else self.top_k
-        top_p = top_p if top_p is not None else self.top_p
-        repeat_penalty = repeat_penalty if repeat_penalty is not None else self.repeat_penalty
-        repeat_last_n = repeat_last_n if repeat_last_n is not None else self.repeat_last_n
-        seed = seed or self.seed  # Use the instance seed if not provided
-        n_threads = n_threads if n_threads else self.n_threads
-
-        def encode_image_to_base64(image_path: str) -> str:
-            """Encodes an image file to a base64 string."""
-            with open(image_path, "rb") as image_file:
-                encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
-            return encoded_string
-
-        # Encode images in base64
-        encoded_images = [encode_image_to_base64(image) for image in images]
-
-        url = f"{host_address}/lollms_generate_with_images"
-        headers = {
-            'Content-Type': 'application/json',
-            'Authorization': f'Bearer {service_key}' if service_key else '',
-        }
-
-        data = {
-            "prompt": prompt,
-            "model_name": model_name,
-            "personality": personality,
-            "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,
-            "images": encoded_images  # Add encoded images to the request payload
-        }
-
-        response = requests.post(url, json=data, headers=headers, stream=stream)
-        if not stream:
-            if response.status_code == 200:
-                try:
-                    text = response.text.rstrip('!')
-                    return text
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
-            else:
-                return {"status": False, "error": response.text}
-        else:
-            text = ""
-            if response.status_code == 200:
-                try:
-                    for line in response.iter_lines():
-                        chunk = line.decode("utf-8")
-                        text += chunk
-                        if streaming_callback:
-                            streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK)
-                    if text[0] == '"':
-                        text = text[1:]
-                    if text[-1] == '"':
-                        text = text[:-1]
-                    return text
-                except Exception as ex:
-                    return {"status": False, "error": str(ex)}
-            else:
-                return {"status": False, "error": response.text}
-
+        return self.binding.load_model(model_name)
     
-    def transformers_generate(self, prompt, host_address=None, model_name=None, personality=None, n_predict=None, stream=False, temperature=0.1, top_k=50, top_p=0.95, repeat_penalty=0.8, repeat_last_n=40, seed=None, n_threads=8, service_key:str="", streaming_callback=None):
-        # Set default values to instance variables if optional arguments are None
-        model_name = model_name if model_name else self.model_name
-        n_predict = n_predict if n_predict else self.n_predict
-        personality = personality if personality is not None else self.personality
-        # Set temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads to the instance variables if they are not provided or None
-        temperature = temperature if temperature is not None else self.temperature
-        top_k = top_k if top_k is not None else self.top_k
-        top_p = top_p if top_p is not None else self.top_p
-        repeat_penalty = repeat_penalty if repeat_penalty is not None else self.repeat_penalty
-        repeat_last_n = repeat_last_n if repeat_last_n is not None else self.repeat_last_n
-        seed = seed or self.seed  # Use the instance seed if not provided
-        n_threads = n_threads if n_threads else self.n_threads
-
-        self.generation_config.max_new_tokens = int(n_predict)
-        self.generation_config.temperature = float(temperature)
-        self.generation_config.top_k = int(top_k)
-        self.generation_config.top_p = float(top_p)
-        self.generation_config.repetition_penalty = float(repeat_penalty)
-        self.generation_config.do_sample = True if float(temperature)>0 else False
-        self.generation_config.pad_token_id = self.tokenizer.pad_token_id
-        self.generation_config.eos_token_id = self.tokenizer.eos_token_id
-        self.generation_config.output_attentions = False
-
-        try:
-            input_ids = self.tokenizer(prompt, add_special_tokens=False, return_tensors='pt').input_ids
-            class StreamerClass:
-                def __init__(self, tokenizer, callback):
-                    self.output = ""
-                    self.skip_prompt = True
-                    self.decode_kwargs = {}
-                    self.tokenizer = tokenizer
-
-                    # variables used in the streaming process
-                    self.token_cache = []
-                    self.print_len = 0
-                    self.next_tokens_are_prompt = True                    
-                    self.callback = callback
-                def put(self, value):
-                    """
-                    Recives tokens, decodes them, and prints them to stdout as soon as they form entire words.
-                    """
-                    if len(value.shape)==1 and (value[0] == self.tokenizer.eos_token_id or value[0] == self.tokenizer.bos_token_id):
-                        print("eos detected")
-                        return
-                    if len(value.shape) > 1 and value.shape[0] > 1:
-                        raise ValueError("TextStreamer only supports batch size 1")
-                    elif len(value.shape) > 1:
-                        value = value[0]
-                    
-                    if self.skip_prompt and self.next_tokens_are_prompt:
-                        self.next_tokens_are_prompt = False
-                        return
-                    
-                    # Add the new token to the cache and decodes the entire thing.
-                    self.token_cache.extend(value.tolist())
-                    text = self.tokenizer.decode(self.token_cache, **self.decode_kwargs)
-                    
-                    # After the symbol for a new line, we flush the cache.
-                    if text.endswith("\n"):
-                        printable_text = text[self.print_len :]
-                        self.token_cache = []
-                        self.print_len = 0
-                    # If the last token is a CJK character, we print the characters.
-                    elif len(text) > 0 and self._is_chinese_char(ord(text[-1])):
-                        printable_text = text[self.print_len :]
-                        self.print_len += len(printable_text)
-                    # Otherwise, prints until the last space char (simple heuristic to avoid printing incomplete words,
-                    # which may change with the subsequent token -- there are probably smarter ways to do this!)
-                    else:
-                        printable_text = text[self.print_len : text.rfind(" ") + 1]
-                        self.print_len += len(printable_text)
-                    
-                    self.output += printable_text
-                    if  self.callback:
-                        if not self.callback(printable_text, 0):
-                            raise Exception("canceled")    
-                    
-                def _is_chinese_char(self, cp):
-                    """Checks whether CP is the codepoint of a CJK character."""
-                    # This defines a "chinese character" as anything in the CJK Unicode block:
-                    #   https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
-                    #
-                    # Note that the CJK Unicode block is NOT all Japanese and Korean characters,
-                    # despite its name. The modern Korean Hangul alphabet is a different block,
-                    # as is Japanese Hiragana and Katakana. Those alphabets are used to write
-                    # space-separated words, so they are not treated specially and handled
-                    # like the all of the other languages.
-                    if (
-                        (cp >= 0x4E00 and cp <= 0x9FFF)
-                        or (cp >= 0x3400 and cp <= 0x4DBF)  #
-                        or (cp >= 0x20000 and cp <= 0x2A6DF)  #
-                        or (cp >= 0x2A700 and cp <= 0x2B73F)  #
-                        or (cp >= 0x2B740 and cp <= 0x2B81F)  #
-                        or (cp >= 0x2B820 and cp <= 0x2CEAF)  #
-                        or (cp >= 0xF900 and cp <= 0xFAFF)
-                        or (cp >= 0x2F800 and cp <= 0x2FA1F)  #
-                    ):  #
-                        return True
-                    
-                    return False
-                def end(self):
-                    """Flushes any remaining cache and prints a newline to stdout."""
-                    # Flush the cache, if it exists
-                    if len(self.token_cache) > 0:
-                        text = self.tokenizer.decode(self.token_cache, **self.decode_kwargs)
-                        printable_text = text[self.print_len :]
-                        self.token_cache = []
-                        self.print_len = 0
-                    else:
-                        printable_text = ""
-                    
-                    self.next_tokens_are_prompt = True
-                    if  self.callback:
-                        if self.callback(printable_text, 0):
-                            raise Exception("canceled")    
-            streamer = StreamerClass(self.tokenizer, streaming_callback)
-            self.generate(
-                        inputs=input_ids, 
-                        generation_config=self.generation_config,
-                        streamer = streamer,
-                        )
-            return streamer.output.rstrip('!')
-        except Exception as ex:
-            return {"status": False, "error": str(ex)}
-                
-    def openai_generate(self, 
-                        prompt, 
-                        host_address=None, 
-                        model_name=None, 
-                        personality=None, 
-                        n_predict=None, 
-                        stream=False, 
-                        temperature=0.1, 
-                        top_k=50, 
-                        top_p=0.95, 
-                        repeat_penalty=0.8, 
-                        repeat_last_n=40, 
-                        seed=None, 
-                        n_threads=8, 
-                        completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Chat, 
-                        service_key: str = "", 
-                        streaming_callback=None):
+    def get_available_bindings(self) -> List[str]:
         """
-        Generates text using the OpenAI API based on the provided prompt and parameters.
-
-        Parameters:
-            prompt (str): The input text prompt to generate completions for.
-            host_address (str, optional): The API host address. Defaults to instance variable.
-            model_name (str, optional): The model to use for generation. Defaults to instance variable.
-            personality (str, optional): The personality setting for the model. Defaults to instance variable.
-            n_predict (int, optional): The number of tokens to predict. Defaults to instance variable.
-            stream (bool, optional): Whether to stream the response. Defaults to False.
-            temperature (float, optional): Sampling temperature. Higher values mean more randomness. Defaults to 0.1.
-            top_k (int, optional): The number of highest probability vocabulary tokens to keep for top-k filtering. Defaults to 50.
-            top_p (float, optional): The cumulative probability of parameter options to keep for nucleus sampling. Defaults to 0.95.
-            repeat_penalty (float, optional): The penalty for repeating tokens. Defaults to 0.8.
-            repeat_last_n (int, optional): The number of last tokens to consider for repeat penalty. Defaults to 40.
-            seed (int, optional): Random seed for reproducibility. Defaults to instance variable.
-            n_threads (int, optional): The number of threads to use for generation. Defaults to 8.
-            completion_format (ELF_COMPLETION_FORMAT, optional): The format of the completion request (Instruct or Chat). Defaults to ELF_COMPLETION_FORMAT.Instruct.
-            service_key (str, optional): The API service key for authorization. Defaults to an empty string.
-            streaming_callback (callable, optional): A callback function to handle streaming responses.
+        Get list of available bindings.
 
         Returns:
-            str: The generated text response from the OpenAI API.
+            List[str]: List of binding names that can be used.
         """
-        # Set default values to instance variables if optional arguments are None
-        host_address = host_address if host_address else self.host_address
-        model_name = model_name if model_name else self.model_name
-        n_predict = n_predict if n_predict else self.n_predict
-        personality = personality if personality is not None else self.personality
-        # Set temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads to the instance variables if they are not provided or None
-        temperature = temperature if temperature is not None else self.temperature
-        top_k = top_k if top_k is not None else self.top_k
-        top_p = top_p if top_p is not None else self.top_p
-        repeat_penalty = repeat_penalty if repeat_penalty is not None else self.repeat_penalty
-        repeat_last_n = repeat_last_n if repeat_last_n is not None else self.repeat_last_n
-        seed = seed or self.seed  # Use the instance seed if not provided
-        n_threads = n_threads if n_threads else self.n_threads
-        service_key = service_key if service_key else self.service_key
-        self.client.api_key = service_key
-        count = 0
-        output= ""
-
-
-        if "vision" in self.model_name:
-            messages = [
-                        {
-                            "role": "user", 
-                            "content": [
-                                {
-                                    "type":"text",
-                                    "text":prompt
-                                }
-                            ]
-                        }
-                    ]
-        else:
-            messages = [{"role": "user", "content": prompt}]
-            
-
-        if completion_format == ELF_COMPLETION_FORMAT.Chat:
-            if "o1" in self.model_name:
-                chat_completion = self.client.chat.completions.create(
-                            model=self.model_name,  # Choose the engine according to your OpenAI plan
-                            messages=messages,
-                            n=1,  # Specify the number of responses you want
-                            )
-                output = chat_completion.choices[0].message.content
-            else:
-                chat_completion = self.client.chat.completions.create(
-                                model=self.model_name,  # Choose the engine according to your OpenAI plan
-                                messages=messages,
-                                max_tokens=n_predict-7 if n_predict>512 else n_predict,  # Adjust the desired length of the generated response
-                                n=1,  # Specify the number of responses you want
-                                temperature=float(self.temperature),  # Adjust the temperature for more or less randomness in the output
-                                stream=True)
-            
-                for resp in chat_completion:
-                    if count >= n_predict:
-                        break
-                    try:
-                        word = resp.choices[0].delta.content
-                    except Exception as ex:
-                        word = ""
-                    if streaming_callback is not None:
-                        if not streaming_callback(word):
-                            break
-                    if word:
-                        output += word
-                        count += 1
-        else:
-            completion = self.client.completions.create(
-                            model=self.model_name,  # Choose the engine according to your OpenAI plan
-                            prompt=prompt,
-                            max_tokens=n_predict-7 if n_predict>512 else n_predict,  # Adjust the desired length of the generated response
-                            n=1,  # Specify the number of responses you want
-                            temperature=float(self.temperature),  # Adjust the temperature for more or less randomness in the output
-                            stream=True)
-            
-            for resp in completion:
-                if count >= n_predict:
-                    break
-                try:
-                    word = resp.choices[0].text
-                except Exception as ex:
-                    word = ""
-                if streaming_callback is not None:
-                    if not streaming_callback(word):
-                        break
-                if word:
-                    output += word
-                    count += 1
-
-        return output
-
-
-    def vllm_generate(self, 
-                        prompt, 
-                        host_address=None, 
-                        model_name=None, 
-                        personality=None, 
-                        n_predict=None, 
-                        stream=False, 
-                        temperature=0.1, 
-                        top_k=50, 
-                        top_p=0.95, 
-                        repeat_penalty=0.8, 
-                        repeat_last_n=40, 
-                        seed=None, 
-                        n_threads=8, 
-                        completion_format: ELF_COMPLETION_FORMAT = ELF_COMPLETION_FORMAT.Instruct, 
-                        service_key: str = "", 
-                        streaming_callback=None):
+        return self.binding_manager.get_available_bindings()
+    
+    def generate_text(self, 
+                     prompt: str,
+                     images: Optional[List[str]] = None,
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: Optional[float] = None,
+                     top_k: Optional[int] = None,
+                     top_p: Optional[float] = None,
+                     repeat_penalty: Optional[float] = None,
+                     repeat_last_n: Optional[int] = None,
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None) -> str:
         """
-        Generates text using the OpenAI API based on the provided prompt and parameters.
+        Generate text using the active binding, using instance defaults if parameters are not provided.
 
-        Parameters:
-            prompt (str): The input text prompt to generate completions for.
-            host_address (str, optional): The API host address. Defaults to instance variable.
-            model_name (str, optional): The model to use for generation. Defaults to instance variable.
-            personality (str, optional): The personality setting for the model. Defaults to instance variable.
-            n_predict (int, optional): The number of tokens to predict. Defaults to instance variable.
-            stream (bool, optional): Whether to stream the response. Defaults to False.
-            temperature (float, optional): Sampling temperature. Higher values mean more randomness. Defaults to 0.1.
-            top_k (int, optional): The number of highest probability vocabulary tokens to keep for top-k filtering. Defaults to 50.
-            top_p (float, optional): The cumulative probability of parameter options to keep for nucleus sampling. Defaults to 0.95.
-            repeat_penalty (float, optional): The penalty for repeating tokens. Defaults to 0.8.
-            repeat_last_n (int, optional): The number of last tokens to consider for repeat penalty. Defaults to 40.
-            seed (int, optional): Random seed for reproducibility. Defaults to instance variable.
-            n_threads (int, optional): The number of threads to use for generation. Defaults to 8.
-            completion_format (ELF_COMPLETION_FORMAT, optional): The format of the completion request (Instruct or Chat). Defaults to ELF_COMPLETION_FORMAT.Instruct.
-            service_key (str, optional): The API service key for authorization. Defaults to an empty string.
-            streaming_callback (callable, optional): A callback function to handle streaming responses.
+        Args:
+            prompt (str): The input prompt for text generation.
+            images (Optional[List[str]]): List of image file paths for multimodal generation.
+            n_predict (Optional[int]): Maximum number of tokens to generate. Uses instance default if None.
+            stream (Optional[bool]): Whether to stream the output. Uses instance default if None.
+            temperature (Optional[float]): Sampling temperature. Uses instance default if None.
+            top_k (Optional[int]): Top-k sampling parameter. Uses instance default if None.
+            top_p (Optional[float]): Top-p sampling parameter. Uses instance default if None.
+            repeat_penalty (Optional[float]): Penalty for repeated tokens. Uses instance default if None.
+            repeat_last_n (Optional[int]): Number of previous tokens to consider for repeat penalty. Uses instance default if None.
+            seed (Optional[int]): Random seed for generation. Uses instance default if None.
+            n_threads (Optional[int]): Number of threads to use. Uses instance default if None.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+                Uses instance default if None.
+                - First parameter (str): The chunk of text received from the stream.
+                - Second parameter (MSG_TYPE): The message type enum (e.g., MSG_TYPE.MSG_TYPE_CHUNK).
 
         Returns:
-            str: The generated text response from the OpenAI API.
+            Union[str, dict]: Generated text or error dictionary if failed.
         """
-        # Set default values to instance variables if optional arguments are None
-        host_address = host_address if host_address else self.host_address
-        model_name = model_name if model_name else self.model_name
-        n_predict = n_predict if n_predict else self.n_predict
-        personality = personality if personality is not None else self.personality
-        # Set temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads to the instance variables if they are not provided or None
-        temperature = temperature if temperature is not None else self.temperature
-        top_k = top_k if top_k is not None else self.top_k
-        top_p = top_p if top_p is not None else self.top_p
-        repeat_penalty = repeat_penalty if repeat_penalty is not None else self.repeat_penalty
-        repeat_last_n = repeat_last_n if repeat_last_n is not None else self.repeat_last_n
-        seed = seed or self.seed  # Use the instance seed if not provided
-        n_threads = n_threads if n_threads else self.n_threads
-
-        if service_key != "":
-            headers = {
-                'Content-Type': 'application/json',
-                'Authorization': f'Bearer {service_key}',
-            }
-        else:
-            headers = {
-                'Content-Type': 'application/json',
-            }
+        return self.binding.generate_text(
+            prompt=prompt,
+            images=images,
+            n_predict=n_predict if n_predict is not None else self.default_n_predict,
+            stream=stream if stream is not None else self.default_stream,
+            temperature=temperature if temperature is not None else self.default_temperature,
+            top_k=top_k if top_k is not None else self.default_top_k,
+            top_p=top_p if top_p is not None else self.default_top_p,
+            repeat_penalty=repeat_penalty if repeat_penalty is not None else self.default_repeat_penalty,
+            repeat_last_n=repeat_last_n if repeat_last_n is not None else self.default_repeat_last_n,
+            seed=seed if seed is not None else self.default_seed,
+            n_threads=n_threads if n_threads is not None else self.default_n_threads,
+            ctx_size = ctx_size if ctx_size is not None else self.default_ctx_size,
+            streaming_callback=streaming_callback if streaming_callback is not None else self.default_streaming_callback
+        )
 
-        if completion_format == ELF_COMPLETION_FORMAT.Instruct:
-            data = {
-                'model': model_name, 
-                'prompt': prompt,
-                "stream": True,
-                "temperature": float(temperature),
-                "max_tokens": n_predict
-            }
-            completion_format_path = "/v1/completions"
-        elif completion_format == ELF_COMPLETION_FORMAT.Chat:
-            data = {
-                'model': model_name,
-                'messages': [{
-                    'role': "user",
-                    'content': prompt
-                }],
-                "stream": True,
-                "temperature": float(temperature),
-                "max_tokens": n_predict
-            }
-            completion_format_path = "/v1/chat/completions"
-
-        if host_address.endswith("/"):
-            host_address = host_address[:-1]
-           
-        url = f'{host_address}{completion_format_path}'
-
-        response = requests.post(url, headers=headers, data=json.dumps(data), stream=True, verify=self.verify_ssl_certificate)
-
-        if response.status_code == 400:
-            try:
-                content = response.content.decode("utf8")
-                content = json.loads(content)
-                self.error(content["error"]["message"])
-                return
-            except:
-                content = response.content.decode("utf8")
-                content = json.loads(content)
-                self.error(content["message"])
-                return
-        elif response.status_code == 404:
-            ASCIIColors.error(response.content.decode("utf-8", errors='ignore'))
-        
-        text = ""
-        for line in response.iter_lines():
-            decoded = line.decode("utf-8")
-            if decoded.startswith("data: "):
-                try:
-                    json_data = json.loads(decoded[5:].strip())
-                    if completion_format == ELF_COMPLETION_FORMAT.Chat:
-                        try:
-                            chunk = json_data["choices"][0]["delta"]["content"]
-                        except:
-                            chunk = ""
-                    else:
-                        chunk = json_data["choices"][0]["text"]
-                    # Process the JSON data here
-                    text += chunk
-                    if streaming_callback:
-                        if not streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK):
-                            break
-                except:
-                    break
-            else:
-                if decoded.startswith("{"):
-                    for line_ in response.iter_lines():
-                        decoded += line_.decode("utf-8")
-                    try:
-                        json_data = json.loads(decoded)
-                        if json_data["object"] == "error":
-                            self.error(json_data["message"])
-                            break
-                    except:
-                        self.error("Couldn't generate text, verify your key or model name")
-                else:
-                    text += decoded
-                    if streaming_callback:
-                        if not streaming_callback(decoded, MSG_TYPE.MSG_TYPE_CHUNK):
-                            break
-        return text
     
-    def openai_generate_with_images(self, 
-                        prompt,
-                        images,
-                        host_address=None, 
-                        model_name=None, 
-                        personality=None, 
-                        n_predict=None, 
-                        stream=False, 
-                        temperature=0.1, 
-                        top_k=50, 
-                        top_p=0.95, 
-                        repeat_penalty=0.8, 
-                        repeat_last_n=40, 
-                        seed=None, 
-                        n_threads=8,
-                        max_image_width=-1, 
-                        service_key: str = "", 
-                        streaming_callback=None,):
-        """Generates text out of a prompt
-
-        Args:
-            prompt (str): The prompt to use for generation
-            n_predict (int, optional): Number of tokens to prodict. Defaults to 128.
-            callback (Callable[[str], None], optional): A callback function that is called everytime a new text element is generated. Defaults to None.
-            verbose (bool, optional): If true, the code will spit many informations about the generation process. Defaults to False.
-        """
-        # Set default values to instance variables if optional arguments are None
-        host_address = host_address if host_address else self.host_address
-        model_name = model_name if model_name else self.model_name
-        n_predict = n_predict if n_predict else self.n_predict
-        personality = personality if personality is not None else self.personality
-        # Set temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads to the instance variables if they are not provided or None
-        temperature = temperature if temperature is not None else self.temperature
-        top_k = top_k if top_k is not None else self.top_k
-        top_p = top_p if top_p is not None else self.top_p
-        repeat_penalty = repeat_penalty if repeat_penalty is not None else self.repeat_penalty
-        repeat_last_n = repeat_last_n if repeat_last_n is not None else self.repeat_last_n
-        seed = seed or self.seed  # Use the instance seed if not provided
-        n_threads = n_threads if n_threads else self.n_threads
-
-        count = 0
-        output = ""
-
-        messages = [
-                    {
-                        "role": "user", 
-                        "content": [
-                            {
-                                "type":"text",
-                                "text":prompt
-                            }
-                        ]+[
-                            {
-                                "type": "image_url",
-                                "image_url": {
-                                "url": f"data:image/jpeg;base64,{encode_image(image_path, max_image_width)}"
-                                }                                    
-                            }
-                            for image_path in images
-                        ]
-                    }
-                ]
-        chat_completion = self.client.chat.completions.create(
-                        model=self.model_name,  # Choose the engine according to your OpenAI plan
-                        messages=messages,
-                        max_tokens=n_predict,  # Adjust the desired length of the generated response
-                        n=1,  # Specify the number of responses you want
-                        temperature=temperature,  # Adjust the temperature for more or less randomness in the output
-                        stream=True
-                        )
-        
-        for resp in chat_completion:
-            if count >= n_predict:
-                break
-            try:
-                word = resp.choices[0].delta.content
-            except Exception as ex:
-                word = ""
-            if streaming_callback is not None:
-                if not streaming_callback(word):
-                    break
-            if word:
-                output += word
-                count += 1
-        return output
-    
-    
-    def ollama_generate(self, prompt, host_address=None, model_name=None, personality=None, n_predict=None, stream=False, temperature=0.1, top_k=50, top_p=0.95, repeat_penalty=0.8, repeat_last_n=40, seed=None, n_threads=8, completion_format:ELF_COMPLETION_FORMAT=ELF_COMPLETION_FORMAT.Instruct, service_key:str="", streaming_callback=None):
-        # Set default values to instance variables if optional arguments are None
-        host_address = host_address if host_address else self.host_address
-        model_name = model_name if model_name else self.model_name
-        n_predict = n_predict if n_predict else self.n_predict
-        personality = personality if personality is not None else self.personality
-        # Set temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads to the instance variables if they are not provided or None
-        temperature = temperature if temperature is not None else self.temperature
-        top_k = top_k if top_k is not None else self.top_k
-        top_p = top_p if top_p is not None else self.top_p
-        repeat_penalty = repeat_penalty if repeat_penalty is not None else self.repeat_penalty
-        repeat_last_n = repeat_last_n if repeat_last_n is not None else self.repeat_last_n
-        seed = seed or self.seed  # Use the instance seed if not provided
-        n_threads = n_threads if n_threads else self.n_threads
-
-        if service_key!="":
-            headers = {
-                'Content-Type': 'application/json',
-                'Authorization': f'Bearer {service_key}',
-            }
-        else:
-            headers = {
-                'Content-Type': 'application/json',
-            }
-
-        data = {
-            'model':model_name,
-            'prompt': prompt,
-            "stream":stream,
-            "temperature": float(temperature),
-            "max_tokens": n_predict
-        }
-        completion_format_path = "/api/generate"
-        if host_address.endswith("/"):
-            host_address = host_address[:-1]
-        url = f'{host_address}{completion_format_path}'
-
-        response = requests.post(url, json=data, headers=headers)
-
-        if response.status_code==404:
-            ASCIIColors.error(response.content.decode("utf-8", errors='ignore'))
-        text = ""
-        if stream:
-            for line in response.iter_lines():
-                decoded = line.decode("utf-8")
-                json_data = json.loads(decoded)
-                chunk = json_data["response"]
-                ## Process the JSON data here
-                text +=chunk
-                if streaming_callback:
-                    if not streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK):
-                        break            
-                return text
-        else:
-            return response.json()["response"]
-
-    def ollama_generate_with_images(self, 
-                        prompt,
-                        images,
-                        host_address=None, 
-                        model_name=None, 
-                        personality=None, 
-                        n_predict=None, 
-                        stream=False, 
-                        temperature=0.1, 
-                        top_k=50, 
-                        top_p=0.95, 
-                        repeat_penalty=0.8, 
-                        repeat_last_n=40, 
-                        seed=None, 
-                        n_threads=8,
-                        max_image_width=-1, 
-                        service_key: str = "", 
-                        streaming_callback=None,):
-        """Generates text out of a prompt
-
-        Args:
-            prompt (str): The prompt to use for generation
-            n_predict (int, optional): Number of tokens to prodict. Defaults to 128.
-            callback (Callable[[str], None], optional): A callback function that is called everytime a new text element is generated. Defaults to None.
-            verbose (bool, optional): If true, the code will spit many informations about the generation process. Defaults to False.
-        """
-        # Set default values to instance variables if optional arguments are None
-        host_address = host_address if host_address else self.host_address
-        model_name = model_name if model_name else self.model_name
-        n_predict = n_predict if n_predict else self.n_predict
-        personality = personality if personality is not None else self.personality
-        # Set temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads to the instance variables if they are not provided or None
-        temperature = temperature if temperature is not None else self.temperature
-        top_k = top_k if top_k is not None else self.top_k
-        top_p = top_p if top_p is not None else self.top_p
-        repeat_penalty = repeat_penalty if repeat_penalty is not None else self.repeat_penalty
-        repeat_last_n = repeat_last_n if repeat_last_n is not None else self.repeat_last_n
-        seed = seed or self.seed  # Use the instance seed if not provided
-        n_threads = n_threads if n_threads else self.n_threads
-        if service_key != "":
-            headers = {
-                'Content-Type': 'application/json',
-                'Authorization': f'Bearer {service_key}',
-            }
-        else:
-            headers = {
-                'Content-Type': 'application/json',
-            }
-            
-        images_list = []
-        for image in images:
-            images_list.append(f"{encode_image(image, max_image_width)}")
-
-        data = {
-            'model': model_name,
-            'prompt': prompt,
-            'images': images_list,
-            "raw": True,
-            "stream":True,
-            "temperature": float(temperature),
-            "max_tokens": n_predict
-        }
-
-        
-        data = {
-            'model': model_name,
-            'messages': [            
-                    {
-                        "role": "user", 
-                        "content": [
-                            {
-                                "type":"text",
-                                "text":prompt
-                            }
-                        ]+[
-                            {
-                                "type": "image_url",
-                                "image_url": {
-                                "url": f"data:image/jpeg;base64,{encode_image(image_path, max_image_width)}"
-                                }                                    
-                            }
-                            for image_path in images
-                        ]
-                    }
-            ],
-            "stream": True,
-            "temperature": float(temperature),
-            "max_tokens": n_predict
-        }
-
-        completion_format_path = "/api"
-
-        if host_address.endswith("/"):
-            host_address = host_address[:-1]
-        url = f'{host_address}{completion_format_path}'
-
-        response = requests.post(url, json=data, headers=headers)
-
-        if response.status_code == 400:
-            try:
-                content = response.content.decode("utf8")
-                content = json.loads(content)
-                self.error(content["error"]["message"])
-                return
-            except:
-                content = response.content.decode("utf8")
-                content = json.loads(content)
-                self.error(content["message"])
-                return
-        elif response.status_code == 404:
-            ASCIIColors.error(response.content.decode("utf-8", errors='ignore'))
-        
-        text = ""
-        for line in response.iter_lines():
-            decoded = line.decode("utf-8")
-            if decoded.startswith("data: "):
-                try:
-                    json_data = json.loads(decoded[5:].strip())
-                    try:
-                        chunk = json_data["choices"][0]["delta"]["content"]
-                    except:
-                        chunk = ""
-                    # Process the JSON data here
-                    text += chunk
-                    if streaming_callback:
-                        if not streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK):
-                            break
-                except:
-                    break
-            else:
-                if decoded.startswith("{"):
-                    for line_ in response.iter_lines():
-                        decoded += line_.decode("utf-8")
-                    try:
-                        json_data = json.loads(decoded)
-                        if json_data["object"] == "error":
-                            self.error(json_data["message"])
-                            break
-                    except:
-                        self.error("Couldn't generate text, verify your key or model name")
-                else:
-                    text += decoded
-                    if streaming_callback:
-                        if not streaming_callback(decoded, MSG_TYPE.MSG_TYPE_CHUNK):
-                            break
-        return text
-
-    def litellm_generate(self, prompt, host_address=None, model_name=None, personality=None, n_predict=None, stream=False, temperature=0.1, top_k=50, top_p=0.95, repeat_penalty=0.8, repeat_last_n=40, seed=None, n_threads=8, completion_format:ELF_COMPLETION_FORMAT=ELF_COMPLETION_FORMAT.Instruct, service_key:str="", streaming_callback=None):
-        # Set default values to instance variables if optional arguments are None
-        host_address = host_address if host_address else self.host_address
-        model_name = model_name if model_name else self.model_name
-        n_predict = n_predict if n_predict else self.n_predict
-        personality = personality if personality is not None else self.personality
-        # Set temperature, top_k, top_p, repeat_penalty, repeat_last_n, seed, n_threads to the instance variables if they are not provided or None
-        temperature = temperature if temperature is not None else self.temperature
-        top_k = top_k if top_k is not None else self.top_k
-        top_p = top_p if top_p is not None else self.top_p
-        repeat_penalty = repeat_penalty if repeat_penalty is not None else self.repeat_penalty
-        repeat_last_n = repeat_last_n if repeat_last_n is not None else self.repeat_last_n
-        seed = seed or self.seed  # Use the instance seed if not provided
-        n_threads = n_threads if n_threads else self.n_threads
-
-        if service_key!="":
-            headers = {
-                'Content-Type': 'application/json',
-                'Authorization': f'Bearer {service_key}',
-            }
-        else:
-            headers = {
-                'Content-Type': 'application/json',
-            }
+    def embed(self, text):
+        self.binding.embed(text)
 
-        data = {
-            'model':model_name,
-            'prompt': prompt,
-            "stream":True,
-            "temperature": float(temperature),
-            "max_tokens": n_predict
-        }
-        completion_format_path = "/api/generate"
-        if host_address.endswith("/"):
-            host_address = host_address[:-1]
-        url = f'{host_address}{completion_format_path}'
-
-        response = requests.post(url, json=data, headers=headers)
-
-        if response.status_code==404:
-            ASCIIColors.error(response.content.decode("utf-8", errors='ignore'))
-        text = ""
-        for line in response.iter_lines():
-            decoded = line.decode("utf-8")
-            if decoded.startswith("{"):
-                json_data = json.loads(decoded)
-                if "error" in json_data:
-                    self.error(json_data["error"]["message"])
-                    break
-            else:
-                text +=decoded
-                if streaming_callback:
-                    if not streaming_callback(decoded, MSG_TYPE.MSG_TYPE_CHUNK):
-                            break
-       
-            return text
-
-
-    def lollms_listMountedPersonalities(self, host_address:str=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 listModels(self, host_address:str=None):
-        if self.default_generation_mode == ELF_GENERATION_FORMAT.LOLLMS:
-            return self.lollms_listModels(host_address)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.OLLAMA:
-            return self.ollama_listModels(host_address)
-        elif self.default_generation_mode == ELF_GENERATION_FORMAT.OPENAI:
-            return self.openai_listModels(host_address)
-
-    def lollms_listModels(self, host_address:str=None):
-        host_address = host_address if host_address else self.host_address
-        url = f"{host_address}/list_models"
-
-        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 ollama_listModels(self, host_address:str=None):
-        if host_address is None:
-            host_address = self.host_address
-        url = f'{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:
-            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
-        except Exception as ex:
-            trace_exception(ex)
-            return []
-
-    def openai_listModels(self, host_address:str=None):
-        if host_address is None:
-            host_address = self.host_address
-        url = f'{host_address}/v1/models'
-        headers = {
-                    'accept': 'application/json',
-                    'Authorization': f'Bearer {self.service_key}'
-                }
-        response = requests.get(url, headers=headers, verify= self.verify_ssl_certificate)
-        try:
-            data = response.json()
-            model_info = []
 
-            for model in data["data"]:
-                model_name = model['id']
-                owned_by = model['owned_by']
-                created_datetime = model["created"]
-                model_info.append({'model_name': model_name, 'owned_by': owned_by, 'created_datetime': created_datetime})
+    def listModels(self):
+        return self.binding.listModels()
 
-            return model_info
-        except Exception as ex:
-            trace_exception(ex)
-            return []
 
 
     def generate_codes(
@@ -1376,11 +307,11 @@ Don't forget encapsulate the code inside a html code tag. This is mandatory.
 {self.ai_full_header}"""
 
         if len(self.image_files)>0:
-            response = self.generate_with_images(full_prompt, self.image_files, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, callback, debug=debug)
+            response = self.generate_text_with_images(full_prompt, self.image_files, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, callback, debug=debug)
         elif  len(images)>0:
-            response = self.generate_with_images(full_prompt, images, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, callback, debug=debug)
+            response = self.generate_text_with_images(full_prompt, images, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, callback, debug=debug)
         else:
-            response = self.generate(full_prompt, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, callback, debug=debug)
+            response = self.generate_text(full_prompt, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, callback, debug=debug)
         response_full += response
         codes = self.extract_code_blocks(response)
         return codes
@@ -1428,16 +359,13 @@ Don't forget encapsulate the code inside a html code tag. This is mandatory.
         full_prompt += f"""You must return a single code tag.
 Do not split the code in multiple tags.
 {self.ai_full_header}"""
-        if len(images)>0:
-            response = self.generate_with_images(full_prompt, images, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, streaming_callback=callback)
-        else:
-            response = self.generate(full_prompt, max_size, False, temperature, top_k, top_p, repeat_penalty, repeat_last_n, streaming_callback=callback)
+        response = self.generate_text(full_prompt, images, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, streaming_callback=callback)
         codes = self.extract_code_blocks(response)
         if len(codes)>0:
             if not codes[-1]["is_complete"]:
                 code = "\n".join(codes[-1]["content"].split("\n")[:-1])
                 while not codes[-1]["is_complete"]:
-                    response = self.generate(prompt+code+self.user_full_header+"continue the code. Start from last line and continue the code. Put the code inside a markdown code tag."+self.separator_template+self.ai_full_header, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, streaming_callback=callback)
+                    response = self.generate_text(prompt+code+self.user_full_header+"continue the code. Start from last line and continue the code. Put the code inside a markdown code tag."+self.separator_template+self.ai_full_header, max_size, temperature, top_k, top_p, repeat_penalty, repeat_last_n, streaming_callback=callback)
                     codes = self.extract_code_blocks(response)
                     if len(codes)==0:
                         break
@@ -1453,103 +381,135 @@ Do not split the code in multiple tags.
         else:
             return None
 
-    def extract_code_blocks(self, text: str) -> List[dict]:
+    def extract_code_blocks(self, text: str, format: str = "markdown") -> List[dict]:
         """
-        This function extracts code blocks from a given text.
+        Extracts code blocks from text in Markdown or HTML format.
 
         Parameters:
-        text (str): The text from which to extract code blocks. Code blocks are identified by triple backticks (```).
+        text (str): The text to extract code blocks from.
+        format (str): The format of code blocks ("markdown" for ``` or "html" for <code class="">).
 
         Returns:
-        List[dict]: A list of dictionaries where each dictionary represents a code block and contains the following keys:
-            - 'index' (int): The index of the code block in the text.
-            - 'file_name' (str): The name of the file extracted from the preceding line, if available.
-            - 'content' (str): The content of the code block.
-            - 'type' (str): The type of the code block. If the code block starts with a language specifier (like 'python' or 'java'), this field will contain that specifier. Otherwise, it will be set to 'language-specific'.
-            - 'is_complete' (bool): True if the block has a closing tag, False otherwise.
-
-        Note:
-        The function assumes that the number of triple backticks in the text is even.
-        If the number of triple backticks is odd, it will consider the rest of the text as the last code block.
-        """        
+        List[dict]: A list of dictionaries with:
+            - 'index' (int): Index of the code block.
+            - 'file_name' (str): File name from preceding text, if available.
+            - 'content' (str): Code block content.
+            - 'type' (str): Language type (from Markdown first line or HTML class).
+            - 'is_complete' (bool): True if block has a closing tag.
+        """
+        code_blocks = []
         remaining = text
-        bloc_index = 0
         first_index = 0
         indices = []
-        while len(remaining) > 0:
-            try:
-                index = remaining.index("```")
-                indices.append(index + first_index)
-                remaining = remaining[index + 3:]
-                first_index += index + 3
-                bloc_index += 1
-            except Exception as ex:
-                if bloc_index % 2 == 1:
-                    index = len(remaining)
-                    indices.append(index)
-                remaining = ""
 
-        code_blocks = []
-        is_start = True
-        for index, code_delimiter_position in enumerate(indices):
+        if format.lower() == "markdown":
+            # Markdown: Find triple backtick positions
+            while remaining:
+                try:
+                    index = remaining.index("```")
+                    indices.append(index + first_index)
+                    remaining = remaining[index + 3:]
+                    first_index += index + 3
+                except ValueError:
+                    if len(indices) % 2 == 1:  # Odd number of delimiters
+                        indices.append(first_index + len(remaining))
+                    break
+
+        elif format.lower() == "html":
+            # HTML: Find <code> and </code> positions, handling nested tags
+            while remaining:
+                try:
+                    # Look for opening <code> tag
+                    start_index = remaining.index("<code")
+                    end_of_opening = remaining.index(">", start_index)
+                    indices.append(start_index + first_index)
+                    opening_tag = remaining[start_index:end_of_opening + 1]
+                    remaining = remaining[end_of_opening + 1:]
+                    first_index += end_of_opening + 1
+
+                    # Look for matching </code>, accounting for nested <code>
+                    nest_level = 0
+                    temp_index = 0
+                    while temp_index < len(remaining):
+                        if remaining[temp_index:].startswith("<code"):
+                            nest_level += 1
+                            temp_index += remaining[temp_index:].index(">") + 1
+                        elif remaining[temp_index:].startswith("</code>"):
+                            if nest_level == 0:
+                                indices.append(first_index + temp_index)
+                                remaining = remaining[temp_index + len("</code>"):]
+                                first_index += temp_index + len("</code>")
+                                break
+                            nest_level -= 1
+                            temp_index += len("</code>")
+                        else:
+                            temp_index += 1
+                    else:
+                        indices.append(first_index + len(remaining))
+                        break
+                except ValueError:
+                    break
+
+        else:
+            raise ValueError("Format must be 'markdown' or 'html'")
+
+        for i in range(0, len(indices), 2):
             block_infos = {
-                'index': index,
+                'index': i // 2,
                 'file_name': "",
-                'section': "",
                 'content': "",
-                'type': "",
+                'type': 'language-specific',
                 'is_complete': False
             }
-            if is_start:
-                # Check the preceding line for file name
-                preceding_text = text[:code_delimiter_position].strip().splitlines()
-                if preceding_text:
-                    last_line = preceding_text[-1].strip()
-                    if last_line.startswith("<file_name>") and last_line.endswith("</file_name>"):
-                        file_name = last_line[len("<file_name>"):-len("</file_name>")].strip()
-                        block_infos['file_name'] = file_name
-                    elif last_line.startswith("## filename:"):
-                        file_name = last_line[len("## filename:"):].strip()
-                        block_infos['file_name'] = file_name
-                    if last_line.startswith("<section>") and last_line.endswith("</section>"):
-                        section = last_line[len("<section>"):-len("</section>")].strip()
-                        block_infos['section'] = section
-
-                sub_text = text[code_delimiter_position + 3:]
-                if len(sub_text) > 0:
-                    try:
-                        find_space = sub_text.index(" ")
-                    except:
-                        find_space = int(1e10)
-                    try:
-                        find_return = sub_text.index("\n")
-                    except:
-                        find_return = int(1e10)
-                    next_index = min(find_return, find_space)
-                    if '{' in sub_text[:next_index]:
-                        next_index = 0
-                    start_pos = next_index
-                    if code_delimiter_position + 3 < len(text) and text[code_delimiter_position + 3] in ["\n", " ", "\t"]:
-                        block_infos["type"] = 'language-specific'
-                    else:
-                        block_infos["type"] = sub_text[:next_index]
 
-                    if index + 1 < len(indices):
-                        next_pos = indices[index + 1] - code_delimiter_position
-                        if next_pos - 3 < len(sub_text) and sub_text[next_pos - 3] == "`":
-                            block_infos["content"] = sub_text[start_pos:next_pos - 3].strip()
-                            block_infos["is_complete"] = True
-                        else:
-                            block_infos["content"] = sub_text[start_pos:next_pos].strip()
-                            block_infos["is_complete"] = False
-                    else:
-                        block_infos["content"] = sub_text[start_pos:].strip()
-                        block_infos["is_complete"] = False
-                    code_blocks.append(block_infos)
-                is_start = False
-            else:
-                is_start = True
-                continue
+            # Extract preceding text for file name
+            start_pos = indices[i]
+            preceding_text = text[:start_pos].strip().splitlines()
+            if preceding_text:
+                last_line = preceding_text[-1].strip()
+                if last_line.startswith("<file_name>") and last_line.endswith("</file_name>"):
+                    block_infos['file_name'] = last_line[len("<file_name>"):-len("</file_name>")].strip()
+                elif last_line.startswith("## filename:"):
+                    block_infos['file_name'] = last_line[len("## filename:"):].strip()
+
+            # Extract content and type
+            if format.lower() == "markdown":
+                sub_text = text[start_pos + 3:]
+                if i + 1 < len(indices):
+                    end_pos = indices[i + 1]
+                    content = text[start_pos + 3:end_pos].strip()
+                    block_infos['is_complete'] = True
+                else:
+                    content = sub_text.strip()
+                    block_infos['is_complete'] = False
+
+                if content:
+                    first_line = content.split('\n', 1)[0].strip()
+                    if first_line and not first_line.startswith(('{', ' ', '\t')):
+                        block_infos['type'] = first_line
+                        content = content[len(first_line):].strip()
+
+            elif format.lower() == "html":
+                opening_tag = text[start_pos:text.index(">", start_pos) + 1]
+                sub_text = text[start_pos + len(opening_tag):]
+                if i + 1 < len(indices):
+                    end_pos = indices[i + 1]
+                    content = text[start_pos + len(opening_tag):end_pos].strip()
+                    block_infos['is_complete'] = True
+                else:
+                    content = sub_text.strip()
+                    block_infos['is_complete'] = False
+
+                # Extract language from class attribute
+                if 'class="' in opening_tag:
+                    class_start = opening_tag.index('class="') + len('class="')
+                    class_end = opening_tag.index('"', class_start)
+                    class_value = opening_tag[class_start:class_end]
+                    if class_value.startswith("language-"):
+                        block_infos['type'] = class_value[len("language-"):]
+
+            block_infos['content'] = content
+            code_blocks.append(block_infos)
 
         return code_blocks
 
@@ -1631,7 +591,7 @@ Do not split the code in multiple tags.
         }
         """
         
-        response = self.generate_code(
+        response = self.generate_text_code(
             prompt=prompt,
             template=template,
             language="json",
@@ -1699,7 +659,7 @@ Do not split the code in multiple tags.
         else:
             prompt += "{\"index\": (the selected answer index)}"
         
-        response = self.generate_code(prompt, language="json", max_size=max_answer_length, 
+        response = self.generate_text_code(prompt, language="json", max_size=max_answer_length, 
             accept_all_if_no_code_tags_is_present=True, return_full_generated_code=False, callback=callback)
         
         try:
@@ -1761,7 +721,7 @@ Do not split the code in multiple tags.
         else:
             prompt += "{\"ranking\": (list of indices ordered from best to worst)}"
         
-        response = self.generate_code(prompt, language="json", return_full_generated_code=False, callback=callback)
+        response = self.generate_text_code(prompt, language="json", return_full_generated_code=False, callback=callback)
         
         try:
             result = json.loads(response)
@@ -1883,7 +843,7 @@ Do not discuss the information inside thememory, just put the relevant informati
                 ASCIIColors.yellow(f" ----- {chunk_id-1} ------")
                 ASCIIColors.red(prompt)
             
-            memory = self.generate(prompt, n_predict=ctx_size//4, streaming_callback=callback).strip()
+            memory = self.generate_text(prompt, n_predict=ctx_size//4, streaming_callback=callback).strip()
             code = self.extract_code_blocks(memory)
             if code:
                 memory=code[0]["content"]
@@ -1919,171 +879,206 @@ The updated memory must be put in a {chunk_processing_output_format} markdown ta
         
         # Generate final summary
         final_prompt = final_prompt_template
-        memory = self.generate(final_prompt, streaming_callback=callback)
+        memory = self.generate_text(final_prompt, streaming_callback=callback)
         code = self.extract_code_blocks(memory)
         if code:
             memory=code[0]["content"]
         return memory
 
-    def deepsearch(
-            self,
-            query: str,
-            text: str = None,
-            files: list = None,
-            search_prompt: str = "Extract information related to the query from the current text chunk and update the memory with new findings.",
-            aggregation_prompt: str = None,
-            output_format: str = "markdown",
-            ctx_size: int = None,
-            chunk_size: int = None,
-            bootstrap_chunk_size: int = None,
-            bootstrap_steps: int = None,
-            callback=None,
-            debug: bool = False
-        ):
-            """
-            Searches for specific information related to a query in a long text or a list of files.
-            Processes the input in chunks, updates a memory with relevant findings, and optionally aggregates them.
-
-            Parameters:
-            - query (str): The query to search for.
-            - text (str, optional): The input text to search in. Defaults to None.
-            - files (list, optional): List of file paths to search in. Defaults to None.
-            - search_prompt (str, optional): Prompt for processing each chunk. Defaults to a standard extraction prompt.
-            - aggregation_prompt (str, optional): Prompt for aggregating findings. Defaults to None.
-            - output_format (str, optional): Output format. Defaults to "markdown".
-            - ctx_size (int, optional): Context size for the model. Defaults to None (uses self.ctx_size).
-            - chunk_size (int, optional): Size of each chunk. Defaults to None (ctx_size // 4). Smaller chunk sizes yield better results but is slower.
-            - bootstrap_chunk_size (int, optional): Size for initial chunks. Defaults to None.
-            - bootstrap_steps (int, optional): Number of initial chunks using bootstrap size. Defaults to None.
-            - callback (callable, optional): Function called after each chunk. Defaults to None.
-            - debug (bool, optional): Enable debug output. Defaults to False.
 
-            Returns:
-            - str: The search findings or aggregated output in the specified format.
-            """
-            # Set defaults
-            if ctx_size is None:
-                ctx_size = self.ctx_size
-            if chunk_size is None:
-                chunk_size = ctx_size // 4
-
-            # Prepare input
-            if files:
-                all_texts = [(file, open(file, 'r', encoding='utf-8').read()) for file in files]
-            elif text:
-                all_texts = [("input_text", text)]
-            else:
-                raise ValueError("Either text or files must be provided.")
+    def update_memory_from_file_chunk_prompt(self, file_name, file_chunk_id, global_chunk_id, chunk, memory, memory_template, query, task_prompt):
+        return f"""{self.system_full_header}
+You are a search assistant that processes documents chunk by chunk to find information related to a query, updating a markdown memory of findings at each step.
 
-            # Initialize memory and chunk counter
-            memory = ""
-            chunk_id = 0
+Your goal is to extract relevant information from each text chunk and update the provided markdown memory structure, ensuring no key details are omitted or invented. Maintain the structure of the JSON template.
 
-            # Define search prompt template using f-string and the provided search_prompt
-            search_prompt_template = f"""{self.system_full_header}
-You are a search assistant that processes documents chunk by chunk to find information related to a query, updating a memory of findings at each step.
+----
+# Current file: {file_name}
+# Chunk number in this file: {file_chunk_id}
+# Global chunk number: {global_chunk_id}
+# Text chunk:
+```markdown
+{chunk}
+```
+{'Current findings memory (cumulative across all files):' if memory!="" else 'Memory template:'}
+```markdown
+{memory if memory!="" else memory_template}
+```
+{self.user_full_header}
+Query: '{query}'
+Task: {task_prompt}
+Update the markdown memory by adding new information from this chunk relevant to the query. Retain all prior findings unless contradicted or updated. Only include explicitly relevant details.
+Ensure the output is valid markdown matching the structure of the provided template.
+Make sure to extract only information relevant to answering the user's query or providing important contextual information.
+Return the updated markdown memory inside a markdown code block.
+{self.ai_full_header}
+"""
 
-Your goal is to extract and combine relevant information from each text chunk with the existing memory, ensuring no key details are omitted or invented.
+    def update_memory_from_file_chunk_prompt_markdown(self, file_name, file_chunk_id, global_chunk_id, chunk, memory, query):
+        return f"""{self.system_full_header}
+You are a search assistant that processes documents chunk by chunk to find information related to a query, updating a markdown memory of findings at each step.
 
+Your goal is to extract relevant information from each text chunk and update the provided markdown memory structure, ensuring no key details are omitted or invented. Maintain the structure of the markdown template.
 
 ----
-# Chunk number: {{chunk_id}}
+# Current file: {file_name}
+# Chunk number in this file: {file_chunk_id}
+# Global chunk number: {global_chunk_id}
 # Text chunk:
 ```markdown
-{{chunk}}
+{chunk}
 ```
-
-Current findings memory:
+Current findings memory (cumulative across all files):
 ```markdown
-{{memory}}
+{memory}
 ```
 {self.user_full_header}
 Query: '{query}'
-Task: {search_prompt}
-
-Update the memory by adding new relevant information from this chunk. Retain all prior findings unless contradicted or updated. Only include explicitly relevant details.
-Make sure to extrafct only information relevant to be able to answer the query of the user or at least gives important contextual information that can be completed to answer the user query.
+{'Start Creating a memory from the text chunk in a format adapted to answer the user Query' if memory=="" else 'Update the markdown memory by adding new information from this chunk relevant to the query.'} Retain all prior findings unless contradicted or updated. Only include explicitly relevant details.
+{'Ensure the output is valid markdown matching the structure of the current memory' if memory!='' else 'Ensure the output is valid markdown matching the structure of the provided template.'}
+Make sure to extract only information relevant to answering the user's query or providing important contextual information.
+Return the updated markdown memory inside a markdown code block.
 {self.ai_full_header}
 """
 
-            # Calculate static prompt tokens
-            example_prompt = search_prompt_template.replace("{{chunk_id}}", "0")\
-                                                .replace("{{memory}}", "")\
-                                                .replace("{{chunk}}", "")
-            static_tokens = len(self.tokenize(example_prompt))
-
-            # Process each text (file or input)
-            for file_name, file_text in all_texts:
-                file_tokens = self.tokenize(file_text)
-                start_token_idx = 0
-
-                while start_token_idx < len(file_tokens):
-                    # Calculate available tokens
-                    current_memory_tokens = len(self.tokenize(memory))
-                    available_tokens = ctx_size - static_tokens - current_memory_tokens
-                    if available_tokens <= 0:
-                        raise ValueError("Memory too large - consider reducing chunk size or increasing context window")
-
-                    # Adjust chunk size
-                    actual_chunk_size = (
-                        min(bootstrap_chunk_size, available_tokens)
-                        if bootstrap_chunk_size is not None and bootstrap_steps is not None and chunk_id < bootstrap_steps
-                        else min(chunk_size, available_tokens)
-                    )
-                    
-                    end_token_idx = min(start_token_idx + actual_chunk_size, len(file_tokens))
-                    chunk_tokens = file_tokens[start_token_idx:end_token_idx]
-                    chunk = self.detokenize(chunk_tokens)
-
-                    # Generate updated memory
-                    prompt = search_prompt_template.replace("{chunk_id}", str(chunk_id))\
-                                                .replace("{memory}", memory)\
-                                                .replace("{chunk}", chunk)
-                    if debug:
-                        print(f"----- Chunk {chunk_id} from {file_name} ------")
-                        print(prompt)
-
-                    output = self.generate(prompt, n_predict=ctx_size // 4, streaming_callback=callback).strip()
-                    code = self.extract_code_blocks(output)
-                    memory = code[0]["content"] if code else output
-
-                    if debug:
-                        print("----- Updated Memory ------")
-                        print(memory)
-                        print("---------------------------")
-
-                    start_token_idx = end_token_idx
-                    chunk_id += 1
-
-            # Aggregate findings if requested
-            if aggregation_prompt:
-                final_prompt = f"""{self.system_full_header}
-You are a search results aggregator.
+    def deep_analyze(
+        self,
+        query: str,
+        text: str = None,
+        files: list = None,
+        aggregation_prompt: str = None,
+        output_format: str = "markdown",
+        ctx_size: int = None,
+        chunk_size: int = None,
+        bootstrap_chunk_size: int = None,
+        bootstrap_steps: int = None,
+        callback=None,
+        debug: bool = False
+    ):
+        """
+        Searches for specific information related to a query in a long text or a list of files.
+        Processes each file separately in chunks, updates a shared markdown memory with relevant findings, and optionally aggregates them.
+
+        Parameters:
+        - query (str): The query to search for.
+        - text (str, optional): The input text to search in. Defaults to None.
+        - files (list, optional): List of file paths to search in. Defaults to None.
+        - task_prompt (str, optional): Prompt for processing each chunk. Defaults to a standard markdown extraction prompt.
+        - aggregation_prompt (str, optional): Prompt for aggregating findings. Defaults to None.
+        - output_format (str, optional): Output format. Defaults to "markdown".
+        - ctx_size (int, optional): Context size for the model. Defaults to None (uses self.ctx_size).
+        - chunk_size (int, optional): Size of each chunk. Defaults to None (ctx_size // 4). Smaller chunk sizes yield better results but are slower.
+        - bootstrap_chunk_size (int, optional): Size for initial chunks. Defaults to None.
+        - bootstrap_steps (int, optional): Number of initial chunks using bootstrap size. Defaults to None.
+        - callback (callable, optional): Function called after each chunk. Defaults to None.
+        - debug (bool, optional): Enable debug output. Defaults to False.
+
+        Returns:
+        - str: The search findings or aggregated output in the specified format.
+        """
+        # Set defaults
+        if ctx_size is None:
+            ctx_size = self.default_ctx_size
+        if chunk_size is None:
+            chunk_size = ctx_size // 4
+
+        # Prepare input
+        if files:
+            all_texts = [(file, open(file, 'r', encoding='utf-8').read()) for file in files]
+        elif text:
+            all_texts = [("input_text", text)]
+        else:
+            raise ValueError("Either text or files must be provided.")
+
+        # Set default memory template for article analysis if none provided
+        memory = ""
 
+        # Initialize global chunk counter
+        global_chunk_id = 0
+        
+        # Calculate static prompt tokens
+        example_prompt = self.update_memory_from_file_chunk_prompt_markdown("example.txt","0", "0", "", "", query)
+        static_tokens = len(self.tokenize(example_prompt))
+
+        # Process each file separately
+        for file_name, file_text in all_texts:
+            file_tokens = self.tokenize(file_text)
+            start_token_idx = 0
+            file_chunk_id = 0  # Reset chunk counter for each file
+
+            while start_token_idx < len(file_tokens):
+                # Calculate available tokens
+                current_memory_tokens = len(self.tokenize(memory))
+                available_tokens = ctx_size - static_tokens - current_memory_tokens
+                if available_tokens <= 0:
+                    raise ValueError("Memory too large - consider reducing chunk size or increasing context window")
+
+                # Adjust chunk size
+                actual_chunk_size = (
+                    min(bootstrap_chunk_size, available_tokens)
+                    if bootstrap_chunk_size is not None and bootstrap_steps is not None and global_chunk_id < bootstrap_steps
+                    else min(chunk_size, available_tokens)
+                )
+                
+                end_token_idx = min(start_token_idx + actual_chunk_size, len(file_tokens))
+                chunk_tokens = file_tokens[start_token_idx:end_token_idx]
+                chunk = self.detokenize(chunk_tokens)
+
+                # Generate updated memory
+                prompt = self.update_memory_from_file_chunk_prompt_markdown(
+                                                file_name=file_name,
+                                                file_chunk_id=file_chunk_id,
+                                                global_chunk_id=global_chunk_id,
+                                                chunk=chunk,
+                                                memory=memory,
+                                                query=query) 
+                if debug:
+                    print(f"----- Chunk {file_chunk_id} (Global {global_chunk_id}) from {file_name} ------")
+                    print(prompt)
+
+                output = self.generate_text(prompt, n_predict=ctx_size // 4, streaming_callback=callback).strip()
+                code = self.extract_code_blocks(output)
+                if code:
+                    memory = code[0]["content"]
+                else:
+                    memory = output
+
+                if debug:
+                    ASCIIColors.red("----- Updated Memory ------")
+                    ASCIIColors.white(memory)
+                    ASCIIColors.red("---------------------------")
+
+                start_token_idx = end_token_idx
+                file_chunk_id += 1
+                global_chunk_id += 1
+
+        # Aggregate findings if requested
+        if aggregation_prompt:
+            final_prompt = f"""{self.system_full_header}
+You are a search results aggregator.
 {self.user_full_header}
 {aggregation_prompt}
-
-Collected findings:
+Collected findings (across all files):
 ```markdown
 {memory}
 ```
-
 Provide the final output in {output_format} format.
 {self.ai_full_header}
 """
-                final_output = self.generate(final_prompt, streaming_callback=callback)
-                code = self.extract_code_blocks(final_output)
-                return code[0]["content"] if code else final_output
-            return memory
+            final_output = self.generate_text(final_prompt, streaming_callback=callback)
+            code = self.extract_code_blocks(final_output)
+            return code[0]["content"] if code else final_output
+        return memory
+
 def error(self, content, duration:int=4, client_id=None, verbose:bool=True):
     ASCIIColors.error(content)
 
 
 
 if __name__=="__main__":
-    #lc = LollmsClient("http://localhost:9600")
+    lc = LollmsClient("ollama", model_name="mistral-nemo:latest")
     #lc = LollmsClient("http://localhost:11434", model_name="mistral-nemo:latest", default_generation_mode=ELF_GENERATION_FORMAT.OLLAMA)
-    lc = LollmsClient(model_name="gpt-3.5-turbo-0125", default_generation_mode=ELF_GENERATION_FORMAT.OPENAI)
+    #lc = LollmsClient(model_name="gpt-3.5-turbo-0125", default_generation_mode=ELF_GENERATION_FORMAT.OPENAI)
     print(lc.listModels())
     code = lc.generate_code("Build a simple json that containes name and age. put the output inside a json markdown tag")
     print(code)