lollms-client 0.15.2__py3-none-any.whl → 0.17.0__py3-none-any.whl

lollms_client/llm_bindings/lollms/__init__.py

@@ -46,43 +46,50 @@ class LollmsLLMBinding(LollmsLLMBinding):
         self.personality = personality
         self.model = None
     
-    def generate_text(self, 
+    def generate_text(self,
                      prompt: str,
                      images: Optional[List[str]] = None,
                      system_prompt: str = "",
                      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,
+                     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: int = 8,
+                     n_threads: Optional[int] = None,
                      ctx_size: int | None = None,
-                     streaming_callback: Optional[Callable[[str, str], None]] = None) -> Union[str, dict]:
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
+                     ) -> Union[str, dict]:
         """
-        Generate text using the LOLLMS service, with optional image support.
+        Generate text using the active LLM binding, using instance defaults if parameters are not provided.
 
         Args:
             prompt (str): The input prompt for text generation.
             images (Optional[List[str]]): List of image file paths for multimodal generation.
-                If provided, uses the /lollms_generate_with_images endpoint.
-            n_predict (Optional[int]): Maximum number of tokens to generate.
-            stream (bool): Whether to stream the output. Defaults to False.
-            temperature (float): Sampling temperature. Defaults to 0.1.
-            top_k (int): Top-k sampling parameter. Defaults to 50.
-            top_p (float): Top-p sampling parameter. Defaults to 0.95.
-            repeat_penalty (float): Penalty for repeated tokens. Defaults to 0.8.
-            repeat_last_n (int): Number of previous tokens to consider for repeat penalty. Defaults to 40.
-            seed (Optional[int]): Random seed for generation.
-            n_threads (int): Number of threads to use. Defaults to 8.
-            streaming_callback (Optional[Callable[[str, str], None]]): Callback for streaming output.
-                - First parameter (str): The chunk of text received from the stream.
-                - Second parameter (str): The message type (typically MSG_TYPE.MSG_TYPE_CHUNK).
+            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.
+            ctx_size (int | None): Context size override for this generation.
+            streaming_callback (Optional[Callable[[str, str], None]]): Callback function for streaming output.
+                - First parameter (str): The chunk of text received.
+                - Second parameter (str): The message type (e.g., MSG_TYPE.MSG_TYPE_CHUNK).
+            split:Optional[bool]: put to true if the prompt is a discussion
+            user_keyword:Optional[str]: when splitting we use this to extract user prompt 
+            ai_keyword:Optional[str]": when splitting we use this to extract ai prompt
 
         Returns:
-            Union[str, dict]: Generated text if successful, or a dictionary with status and error if failed.
+            Union[str, dict]: Generated text or error dictionary if failed.
         """
         # Determine endpoint based on presence of images
         endpoint = "/lollms_generate_with_images" if images else "/lollms_generate"

lollms_client/llm_bindings/ollama/__init__.py

@@ -109,47 +109,53 @@ class OllamaBinding(LollmsLLMBinding):
             self.ollama_client = None # Ensure it's None if initialization fails
             # Optionally re-raise or handle so the binding is clearly unusable
             raise ConnectionError(f"Could not connect or initialize Ollama client at {self.host_address}: {e}") from e
-    
-    def generate_text(self, 
+
+    def generate_text(self,
                      prompt: str,
-                     images: Optional[List[str]] = None, # List of image file paths
+                     images: Optional[List[str]] = None,
                      system_prompt: str = "",
                      n_predict: Optional[int] = None,
-                     stream: bool = False,
+                     stream: Optional[bool] = None,
                      temperature: float = 0.7, # Ollama default is 0.8, common default 0.7
                      top_k: int = 40,          # Ollama default is 40
                      top_p: float = 0.9,       # Ollama default is 0.9
                      repeat_penalty: float = 1.1, # Ollama default is 1.1
                      repeat_last_n: int = 64,  # Ollama default is 64
                      seed: Optional[int] = None,
-                     n_threads: Optional[int] = None, # Ollama calls this num_thread
-                     ctx_size: Optional[int] = None,  # Ollama calls this num_ctx
-                     streaming_callback: Optional[Callable[[str, int], bool]] = None
-                     ) -> Union[str, Dict[str, any]]:
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
+                     ) -> Union[str, dict]:
         """
-        Generate text using the Ollama service, with optional image support.
+        Generate text using the active LLM binding, using instance defaults if parameters are not provided.
 
         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 (num_predict).
-            stream (bool): Whether to stream the output. Defaults to False.
-            temperature (float): Sampling temperature.
-            top_k (int): Top-k sampling parameter.
-            top_p (float): Top-p sampling parameter.
-            repeat_penalty (float): Penalty for repeated tokens.
-            repeat_last_n (int): Number of previous tokens to consider for repeat penalty.
-            seed (Optional[int]): Random seed for generation.
-            n_threads (Optional[int]): Number of threads to use (num_thread).
-            ctx_size (Optional[int]): Context window size (num_ctx).
-            streaming_callback (Optional[Callable[[str, int], bool]]): Callback for streaming output.
-                - First parameter (str): The chunk of text received from the stream.
-                - Second parameter (int): The message type (typically MSG_TYPE.MSG_TYPE_CHUNK).
-                Return False to stop streaming.
+            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.
+            ctx_size (int | None): Context size override for this generation.
+            streaming_callback (Optional[Callable[[str, str], None]]): Callback function for streaming output.
+                - First parameter (str): The chunk of text received.
+                - Second parameter (str): The message type (e.g., MSG_TYPE.MSG_TYPE_CHUNK).
+            split:Optional[bool]: put to true if the prompt is a discussion
+            user_keyword:Optional[str]: when splitting we use this to extract user prompt 
+            ai_keyword:Optional[str]": when splitting we use this to extract ai prompt
 
         Returns:
-            Union[str, Dict[str, any]]: Generated text if successful, or a dictionary with status and error if failed.
+            Union[str, dict]: Generated text or error dictionary if failed.
         """
+
         if not self.ollama_client:
              return {"status": False, "error": "Ollama client not initialized."}
 
@@ -175,8 +181,15 @@ class OllamaBinding(LollmsLLMBinding):
                     # If images were base64 strings, they would need decoding to bytes first.
                     processed_images.append(img_path)
 
-                messages = [{'role': 'system', 'content':system_prompt},{'role': 'user', 'content': prompt, 'images': processed_images if processed_images else None}]
-                
+                messages = [
+                            {'role': 'system', 'content':system_prompt},
+                        ]
+                if split:
+                    messages += self.split_discussion(prompt,user_keyword=user_keyword, ai_keyword=ai_keyword)
+                    if processed_images:
+                        messages[-1]["images"]=processed_images
+                else:
+                    messages.append({'role': 'user', 'content': prompt, 'images': processed_images if processed_images else None})
                 if stream:
                     response_stream = self.ollama_client.chat(
                         model=self.model_name,
@@ -201,7 +214,14 @@ class OllamaBinding(LollmsLLMBinding):
                     )
                     return response_dict.get('message', {}).get('content', '')
             else: # Text-only
-                messages = [{'role': 'system', 'content':system_prompt},{'role': 'user', 'content': prompt}]
+                messages = [
+                            {'role': 'system', 'content':system_prompt},
+                        ]
+                if split:
+                    messages += self.split_discussion(prompt,user_keyword=user_keyword, ai_keyword=ai_keyword)
+                else:
+                    messages.append({'role': 'user', 'content': prompt})
+
                 if stream:
                     response_stream = self.ollama_client.chat(
                         model=self.model_name,

lollms_client/llm_bindings/openai/__init__.py

@@ -55,42 +55,50 @@ class OpenAIBinding(LollmsLLMBinding):
         self.completion_format = ELF_COMPLETION_FORMAT.Chat
 
     
-    def generate_text(self, 
-                    prompt: str,
-                    images: Optional[List[str]] = None,
-                    system_prompt: str = "",
-                    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,
-                    ctx_size: int | None = None,
-                    streaming_callback: Optional[Callable[[str, str], None]] = None) -> str:
+    def generate_text(self,
+                     prompt: str,
+                     images: Optional[List[str]] = None,
+                     system_prompt: str = "",
+                     n_predict: Optional[int] = None,
+                     stream: Optional[bool] = None,
+                     temperature: float = 0.7, 
+                     top_k: int = 40,          
+                     top_p: float = 0.9,       
+                     repeat_penalty: float = 1.1, 
+                     repeat_last_n: int = 64, 
+                     seed: Optional[int] = None,
+                     n_threads: Optional[int] = None,
+                     ctx_size: int | None = None,
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
+                     ) -> Union[str, dict]:
         """
-        Generate text based on the provided prompt and parameters.
+        Generate text using the active LLM binding, using instance defaults if parameters are not provided.
 
         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.
-            stream (bool): Whether to stream the output. Defaults to False.
-            temperature (float): Sampling temperature. Defaults to 0.1.
-            top_k (int): Top-k sampling parameter. Defaults to 50.
-            top_p (float): Top-p sampling parameter. Defaults to 0.95.
-            repeat_penalty (float): Penalty for repeated tokens. Defaults to 0.8.
-            repeat_last_n (int): Number of previous tokens to consider for repeat penalty. Defaults to 40.
-            seed (Optional[int]): Random seed for generation.
-            n_threads (int): Number of threads to use. Defaults to 8.
+            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.
+            ctx_size (int | None): Context size override for this generation.
             streaming_callback (Optional[Callable[[str, str], None]]): Callback function for streaming output.
                 - First parameter (str): The chunk of text received.
                 - Second parameter (str): The message type (e.g., MSG_TYPE.MSG_TYPE_CHUNK).
+            split:Optional[bool]: put to true if the prompt is a discussion
+            user_keyword:Optional[str]: when splitting we use this to extract user prompt 
+            ai_keyword:Optional[str]": when splitting we use this to extract ai prompt
 
         Returns:
-            str: Generated text or error dictionary if failed.
+            Union[str, dict]: Generated text or error dictionary if failed.
         """
         count = 0
         output = ""
@@ -101,16 +109,17 @@ class OpenAIBinding(LollmsLLMBinding):
                 {
                     "role": "system",
                     "content": system_prompt,
-                },
-
-                {                    
-                    "role": "user", 
-                    "content": [
+                }
+            ]
+            if split:
+                messages += self.split_discussion(prompt,user_keyword=user_keyword, ai_keyword=ai_keyword)
+                if images:
+                    messages[-1]["content"] = [
                         {
                             "type": "text",
-                            "text": prompt
+                            "text": messages[-1]["content"]
                         }
-                    ] + [
+                    ]+[
                         {
                             "type": "image_url",
                             "image_url": {
@@ -119,8 +128,26 @@ class OpenAIBinding(LollmsLLMBinding):
                         }
                         for image_path in images
                     ]
-                }
-            ]
+            else:
+                messages.append({
+                        'role': 'user', 
+                        'content': [
+                                        {
+                                            "type": "text",
+                                            "text": prompt
+                                        }
+                                    ] + [
+                                        {
+                                            "type": "image_url",
+                                            "image_url": {
+                                                "url": f"data:image/jpeg;base64,{encode_image(image_path)}"
+                                            }
+                                        }
+                                        for image_path in images
+                                    ]
+                    }
+                )
+            
         else:
             messages = [{"role": "user", "content": prompt}]
 

lollms_client/llm_bindings/openllm/__init__.py

@@ -154,7 +154,10 @@ class OpenLLMBinding(LollmsLLMBinding):
                      seed: Optional[int] = None,
                      # n_threads: Optional[int] = None, # Server-side config for OpenLLM
                      # ctx_size: Optional[int] = None,  # Server-side config, though some models might allow via llm_config
-                     streaming_callback: Optional[Callable[[str, int], bool]] = None
+                     streaming_callback: Optional[Callable[[str, int], bool]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",                     
                      ) -> Union[str, Dict[str, any]]:
         
         if not self.openllm_client:

lollms_client/llm_bindings/pythonllamacpp/__init__.py

@@ -216,6 +216,9 @@ class PythonLlamaCppBinding(LollmsLLMBinding):
                      streaming_callback: Optional[Callable[[str, int], bool]] = None,
                      use_chat_format: bool = True, 
                      grammar: Optional[Union[str, LlamaGrammar]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
                      **generation_kwargs 
                      ) -> Union[str, Dict[str, any]]:
         

lollms_client/llm_bindings/tensor_rt/__init__.py

@@ -341,7 +341,10 @@ class VLLMBinding(LollmsLLMBinding):
                      repeat_last_n: int = 64, # Note: vLLM applies penalty to full context
                      seed: Optional[int] = None,
                      n_threads: int = 8, # Note: vLLM manages its own threading/parallelism
-                     streaming_callback: Optional[Callable[[str, int], bool]] = None
+                     streaming_callback: Optional[Callable[[str, int], bool]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
                      ) -> Union[str, Dict[str, any]]:
         if not self.llm_engine: return {"status": False, "error": "Engine not loaded."}
 

lollms_client/llm_bindings/transformers/__init__.py

@@ -312,6 +312,9 @@ class HuggingFaceHubBinding(LollmsLLMBinding):
                      seed: Optional[int] = None,
                      stop_words: Optional[List[str]] = None, # Added custom stop_words
                      streaming_callback: Optional[Callable[[str, int], bool]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
                      use_chat_format_override: Optional[bool] = None,
                      **generation_kwargs 
                      ) -> Union[str, Dict[str, Any]]:

lollms_client/llm_bindings/vllm/__init__.py

@@ -341,7 +341,10 @@ class VLLMBinding(LollmsLLMBinding):
                      repeat_last_n: int = 64, # Note: vLLM applies penalty to full context
                      seed: Optional[int] = None,
                      n_threads: int = 8, # Note: vLLM manages its own threading/parallelism
-                     streaming_callback: Optional[Callable[[str, int], bool]] = None
+                     streaming_callback: Optional[Callable[[str, int], bool]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
                      ) -> Union[str, Dict[str, any]]:
         if not self.llm_engine: return {"status": False, "error": "Engine not loaded."}
 

lollms_client/lollms_core.py

@@ -11,7 +11,7 @@ from lollms_client.lollms_stt_binding import LollmsSTTBinding, LollmsSTTBindingM
 from lollms_client.lollms_ttv_binding import LollmsTTVBinding, LollmsTTVBindingManager
 from lollms_client.lollms_ttm_binding import LollmsTTMBinding, LollmsTTMBindingManager
 
-import json
+import re
 from enum import Enum
 import base64
 import requests
@@ -48,6 +48,13 @@ class LollmsClient():
                  ttv_bindings_dir: Path = Path(__file__).parent / "ttv_bindings",
                  ttm_bindings_dir: Path = Path(__file__).parent / "ttm_bindings",
 
+                 # Configurations
+                 tts_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+                 tti_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+                 stt_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+                 ttv_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+                 ttm_binding_config: Optional[Dict[str, any]] = None, # Renamed for clarity
+
                  # General Parameters (mostly defaults for LLM generation)
                  service_key: Optional[str] = None, # Shared service key/client_id
                  verify_ssl_certificate: bool = True,
@@ -84,6 +91,11 @@ class LollmsClient():
             stt_bindings_dir (Path): Directory for STT bindings.
             ttv_bindings_dir (Path): Directory for TTV bindings.
             ttm_bindings_dir (Path): Directory for TTM bindings.
+            tts_binding_config (Optional[Dict]): Additional config for the TTS binding.
+            tti_binding_config (Optional[Dict]): Additional config for the TTI binding.
+            stt_binding_config (Optional[Dict]): Additional config for the STT binding.
+            ttv_binding_config (Optional[Dict]): Additional config for the TTV binding.
+            ttm_binding_config (Optional[Dict]): Additional config for the TTM binding.
             service_key (Optional[str]): Shared authentication key or client_id.
             verify_ssl_certificate (bool): Whether to verify SSL certificates.
             ctx_size (Optional[int]): Default context size for LLM.
@@ -144,54 +156,62 @@ class LollmsClient():
         if tts_binding_name:
             self.tts = self.tts_binding_manager.create_binding(
                 binding_name=tts_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key,
-                verify_ssl_certificate=self.verify_ssl_certificate
+                **tts_binding_config
             )
             if self.tts is None:
                 ASCIIColors.warning(f"Failed to create TTS binding: {tts_binding_name}. Available: {self.tts_binding_manager.get_available_bindings()}")
 
         if tti_binding_name:
-            self.tti = self.tti_binding_manager.create_binding(
-                binding_name=tti_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key, # Passed as service_key, used as client_id by lollms TTI binding
-                verify_ssl_certificate=self.verify_ssl_certificate
-            )
+            if tti_binding_config:
+                self.tti = self.tti_binding_manager.create_binding(
+                    binding_name=tti_binding_name,
+                    **tti_binding_config
+                )
+            else:
+                self.tti = self.tti_binding_manager.create_binding(
+                    binding_name=tti_binding_name
+                )
             if self.tti is None:
                 ASCIIColors.warning(f"Failed to create TTI binding: {tti_binding_name}. Available: {self.tti_binding_manager.get_available_bindings()}")
 
         if stt_binding_name:
-            self.stt = self.stt_binding_manager.create_binding(
-                binding_name=stt_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key,
-                verify_ssl_certificate=self.verify_ssl_certificate
-            )
+            if stt_binding_config:
+                self.stt = self.stt_binding_manager.create_binding(
+                    binding_name=stt_binding_name,
+                    **stt_binding_config
+                )
+            else:
+                self.stt = self.stt_binding_manager.create_binding(
+                    binding_name=stt_binding_name,
+                )
             if self.stt is None:
                 ASCIIColors.warning(f"Failed to create STT binding: {stt_binding_name}. Available: {self.stt_binding_manager.get_available_bindings()}")
-
         if ttv_binding_name:
-            self.ttv = self.ttv_binding_manager.create_binding(
-                binding_name=ttv_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key,
-                verify_ssl_certificate=self.verify_ssl_certificate
-            )
+            if ttv_binding_config:
+                self.ttv = self.ttv_binding_manager.create_binding(
+                    binding_name=ttv_binding_name,
+                    **ttv_binding_config
+                )
+            else:
+                self.ttv = self.ttv_binding_manager.create_binding(
+                    binding_name=ttv_binding_name
+                )
             if self.ttv is None:
                 ASCIIColors.warning(f"Failed to create TTV binding: {ttv_binding_name}. Available: {self.ttv_binding_manager.get_available_bindings()}")
 
         if ttm_binding_name:
-            self.ttm = self.ttm_binding_manager.create_binding(
-                binding_name=ttm_binding_name,
-                host_address=effective_host_address,
-                service_key=self.service_key,
-                verify_ssl_certificate=self.verify_ssl_certificate
-            )
+            if ttm_binding_config:
+                self.ttm = self.ttm_binding_manager.create_binding(
+                    binding_name=ttm_binding_name,
+                    **ttm_binding_config
+                )
+            else:
+                self.ttm = self.ttm_binding_manager.create_binding(
+                    binding_name=ttm_binding_name
+                )
             if self.ttm is None:
                 ASCIIColors.warning(f"Failed to create TTM binding: {ttm_binding_name}. Available: {self.ttm_binding_manager.get_available_bindings()}")
 
-
         # --- Store Default Generation Parameters ---
         self.default_ctx_size = ctx_size
         self.default_n_predict = n_predict
@@ -342,7 +362,11 @@ class LollmsClient():
                      seed: Optional[int] = None,
                      n_threads: Optional[int] = None,
                      ctx_size: int | None = None,
-                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None) -> Union[str, dict]:
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     split:Optional[bool]=False, # put to true if the prompt is a discussion
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
+                     ) -> Union[str, dict]:
         """
         Generate text using the active LLM binding, using instance defaults if parameters are not provided.
 
@@ -360,6 +384,9 @@ class LollmsClient():
             n_threads (Optional[int]): Number of threads to use. Uses instance default if None.
             ctx_size (int | None): Context size override for this generation.
             streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+            split:Optional[bool]: put to true if the prompt is a discussion
+            user_keyword:Optional[str]: when splitting we use this to extract user prompt 
+            ai_keyword:Optional[str]": when splitting we use this to extract ai prompt
 
         Returns:
             Union[str, dict]: Generated text or error dictionary if failed.
@@ -379,7 +406,10 @@ class LollmsClient():
                 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
+                streaming_callback=streaming_callback if streaming_callback is not None else self.default_streaming_callback,
+                split= split,
+                user_keyword=user_keyword,
+                ai_keyword=ai_keyword
             )
         raise RuntimeError("LLM binding not initialized.")
 
@@ -961,7 +991,6 @@ Do not split the code in multiple tags.
         Ranks answers for a question from best to worst using LLM JSON generation.
         (Implementation requires self.generate_code which uses self.generate_text)
         """
-        # ... (Implementation as provided before, relies on self.generate_code) ...
         if not callback:
             callback = self.sink
 
@@ -1547,6 +1576,7 @@ Provide the final aggregated answer in {output_format} format, directly addressi
         callback("Deep analysis complete.", MSG_TYPE.MSG_TYPE_STEP_END)
         return final_output
 
+
 def chunk_text(text, tokenizer, detokenizer, chunk_size, overlap, use_separators=True):
     """
     Chunks text based on token count.
@@ -1626,3 +1656,5 @@ def chunk_text(text, tokenizer, detokenizer, chunk_size, overlap, use_separators
                 break
 
     return chunks
+
+