lollms-client 0.25.1__py3-none-any.whl → 0.25.6__py3-none-any.whl

lollms_client/__init__.py

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

lollms_client/llm_bindings/gemini/__init__.py

@@ -0,0 +1,501 @@
+# bindings/gemini/binding.py
+import base64
+import os
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, Callable, List, Union, Dict
+
+from lollms_client.lollms_discussion import LollmsDiscussion, LollmsMessage
+from lollms_client.lollms_llm_binding import LollmsLLMBinding
+from lollms_client.lollms_types import MSG_TYPE
+from ascii_colors import ASCIIColors, trace_exception
+
+import pipmaster as pm
+
+# Ensure the required packages are installed
+pm.ensure_packages(["google-generativeai", "pillow", "tiktoken", "protobuf"])
+
+import google.generativeai as genai
+from PIL import Image, ImageDraw # ImageDraw is used in the test script below
+import tiktoken
+
+BindingName = "GeminiBinding"
+
+# Helper to check if a string is a valid path to an image
+def is_image_path(path_str: str) -> bool:
+    try:
+        p = Path(path_str)
+        return p.is_file() and p.suffix.lower() in ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp']
+    except Exception:
+        return False
+
+class GeminiBinding(LollmsLLMBinding):
+    """Google Gemini-specific binding implementation."""
+
+    def __init__(self,
+                 host_address: str = None,  # Ignored, for compatibility
+                 model_name: str = "gemini-1.5-pro-latest",
+                 service_key: str = None,
+                 verify_ssl_certificate: bool = True, # Ignored, for compatibility
+                 **kwargs
+                 ):
+        """
+        Initialize the Gemini binding.
+
+        Args:
+            model_name (str): Name of the Gemini model to use.
+            service_key (str): Google AI Studio API key.
+        """
+        super().__init__(binding_name=BindingName)
+        self.model_name = model_name
+        self.service_key = service_key
+
+        if not self.service_key:
+            self.service_key = os.getenv("GOOGLE_API_KEY")
+        
+        if not self.service_key:
+            raise ValueError("Google API key is required. Please set it via the 'service_key' parameter or the GOOGLE_API_KEY environment variable.")
+
+        try:
+            genai.configure(api_key=self.service_key)
+            self.client = genai # Alias for consistency
+        except Exception as e:
+            ASCIIColors.error(f"Failed to configure Gemini client: {e}")
+            self.client = None
+            raise ConnectionError(f"Could not configure Gemini client: {e}") from e
+
+    def get_generation_config(self, 
+                              temperature: float, 
+                              top_p: float, 
+                              top_k: int, 
+                              n_predict: int) -> genai.types.GenerationConfig:
+        """Builds a GenerationConfig object from parameters."""
+        config = {}
+        if temperature is not None: config['temperature'] = float(temperature)
+        if top_p is not None: config['top_p'] = top_p
+        if top_k is not None: config['top_k'] = top_k
+        if n_predict is not None: config['max_output_tokens'] = n_predict
+        return genai.types.GenerationConfig(**config)
+
+    def generate_text(self,
+                     prompt: str,
+                     images: Optional[List[str]] = None,
+                     system_prompt: str = "",
+                     n_predict: Optional[int] = 2048,
+                     stream: Optional[bool] = False,
+                     temperature: float = 0.7,
+                     top_k: int = 40,
+                     top_p: float = 0.9,
+                     repeat_penalty: float = 1.1, # Not directly supported by Gemini API
+                     repeat_last_n: int = 64,   # Not directly supported
+                     seed: Optional[int] = None,      # Not directly supported
+                     n_threads: Optional[int] = None, # Not applicable
+                     ctx_size: int | None = None,     # Determined by model, not settable per-call
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     split:Optional[bool]=False, 
+                     user_keyword:Optional[str]="!@>user:",
+                     ai_keyword:Optional[str]="!@>assistant:",
+                     ) -> Union[str, dict]:
+        """
+        Generate text using the Gemini model.
+
+        Args:
+            prompt (str): The input prompt for text generation.
+            images (Optional[List[str]]): List of image file paths or base64 strings.
+            system_prompt (str): The system prompt to guide the model.
+            ... other LollmsLLMBinding parameters ...
+
+        Returns:
+            Union[str, dict]: Generated text or error dictionary.
+        """
+        if not self.client:
+            return {"status": False, "error": "Gemini client not initialized."}
+
+        # Gemini uses 'system_instruction' for GenerativeModel, not part of the regular message list.
+        model = self.client.GenerativeModel(
+            model_name=self.model_name,
+            system_instruction=system_prompt if system_prompt else None
+        )
+
+        generation_config = self.get_generation_config(temperature, top_p, top_k, n_predict)
+
+        # Prepare content for the API call
+        content_parts = []
+        if split:
+            # Note: The 'split' logic for Gemini should ideally build a multi-turn history,
+            # but for `generate_text`, we'll treat the last user part as the main prompt.
+            discussion_messages = self.split_discussion(prompt, user_keyword, ai_keyword)
+            if discussion_messages:
+                last_message = discussion_messages[-1]['content']
+                content_parts.append(last_message)
+            else:
+                content_parts.append(prompt)
+        else:
+            content_parts.append(prompt)
+
+        if images:
+            for image_data in images:
+                try:
+                    if is_image_path(image_data):
+                        img = Image.open(image_data)
+                    else: # Assume base64
+                        img = Image.open(BytesIO(base64.b64decode(image_data)))
+                    content_parts.append(img)
+                except Exception as e:
+                    error_msg = f"Failed to process image: {e}"
+                    ASCIIColors.error(error_msg)
+                    return {"status": False, "error": error_msg}
+
+        full_response_text = ""
+        try:
+            response = model.generate_content(
+                contents=content_parts,
+                generation_config=generation_config,
+                stream=stream
+            )
+
+            if stream:
+                for chunk in response:
+                    try:
+                        chunk_text = chunk.text
+                    except ValueError:
+                        # Handle potential empty parts in the stream
+                        chunk_text = ""
+
+                    if chunk_text:
+                        full_response_text += chunk_text
+                        if streaming_callback:
+                            if not streaming_callback(chunk_text, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break # Callback requested stop
+                return full_response_text
+            else:
+                # Check for safety blocks
+                if response.prompt_feedback.block_reason:
+                    error_msg = f"Content blocked due to: {response.prompt_feedback.block_reason.name}"
+                    ASCIIColors.warning(error_msg)
+                    return {"status": False, "error": error_msg}
+                return response.text
+
+        except Exception as ex:
+            error_message = f"An unexpected error occurred with Gemini API: {str(ex)}"
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
+
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             n_predict: Optional[int] = 2048,
+             stream: Optional[bool] = False,
+             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: Optional[int] = None,
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with the Gemini model using a LollmsDiscussion object.
+        """
+        if not self.client:
+             return {"status": "error", "message": "Gemini client not initialized."}
+
+        # 1. Manually export discussion to Gemini's format.
+        # Gemini uses 'user' and 'model' roles.
+        # The system prompt is handled separately at model initialization.
+        system_prompt = discussion.system_prompt
+        messages = discussion.get_messages(branch_tip_id)
+        
+        history = []
+        for msg in messages:
+            role = 'user' if msg.sender_type == "user" else 'assistant'
+            
+            # Handle multimodal content in the message
+            content_parts = []
+            if msg.content:
+                content_parts.append(msg.content)
+            
+            # Check for images associated with this message
+            if msg.images:
+                for file_path in msg.images:
+                     if is_image_path(file_path):
+                         try:
+                            content_parts.append(Image.open(file_path))
+                         except Exception as e:
+                            ASCIIColors.warning(f"Could not load image {file_path}: {e}")
+
+            if content_parts:
+                history.append({'role': role, 'parts': content_parts})
+        
+        model = self.client.GenerativeModel(
+            model_name=self.model_name,
+            system_instruction=system_prompt
+        )
+        
+        # History must not be empty and should not contain consecutive roles of the same type.
+        # We also need to separate the final prompt from the history.
+        if not history:
+            return {"status": "error", "message": "Cannot start chat with an empty discussion."}
+
+        chat_history = history[:-1] if len(history) > 1 else []
+        last_prompt_parts = history[-1]['parts']
+
+        # Ensure history is valid (no consecutive same roles)
+        valid_history = []
+        if chat_history:
+            valid_history.append(chat_history[0])
+            for i in range(1, len(chat_history)):
+                if chat_history[i]['role'] != chat_history[i-1]['role']:
+                    valid_history.append(chat_history[i])
+        
+        chat_session = model.start_chat(history=valid_history)
+        
+        generation_config = self.get_generation_config(temperature, top_p, top_k, n_predict)
+        
+        full_response_text = ""
+        try:
+            response = chat_session.send_message(
+                content=last_prompt_parts,
+                generation_config=generation_config,
+                stream=stream
+            )
+            
+            if stream:
+                for chunk in response:
+                    try:
+                        chunk_text = chunk.text
+                    except ValueError:
+                        chunk_text = ""
+                        
+                    if chunk_text:
+                        full_response_text += chunk_text
+                        if streaming_callback:
+                            if not streaming_callback(chunk_text, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break
+                return full_response_text
+            else:
+                if response.prompt_feedback.block_reason:
+                    error_msg = f"Content blocked due to: {response.prompt_feedback.block_reason.name}"
+                    ASCIIColors.warning(error_msg)
+                    return {"status": "error", "message": error_msg}
+                return response.text
+
+        except Exception as ex:
+            error_message = f"An unexpected error occurred with Gemini API: {str(ex)}"
+            trace_exception(ex)
+            return {"status": "error", "message": error_message}
+            
+    def tokenize(self, text: str) -> list:
+        """
+        Tokenize the input text.
+        Note: Gemini doesn't expose a public tokenizer API.
+        Using tiktoken for a rough estimate, NOT accurate for Gemini.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.encode(text)
+        except:
+            return list(text.encode('utf-8'))
+
+    def detokenize(self, tokens: list) -> str:
+        """
+        Detokenize a list of tokens.
+        Note: Based on the placeholder tokenizer.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.decode(tokens)
+        except:
+            return bytes(tokens).decode('utf-8', errors='ignore')
+
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text using the Gemini API.
+        """
+        if not self.client or not self.model_name:
+            ASCIIColors.warning("Cannot count tokens, Gemini client or model_name not set.")
+            return -1
+        try:
+            model = self.client.GenerativeModel(self.model_name)
+            return model.count_tokens(text).total_tokens
+        except Exception as e:
+            ASCIIColors.error(f"Failed to count tokens with Gemini API: {e}")
+            # Fallback to tiktoken for a rough estimate
+            return len(self.tokenize(text))
+
+    def embed(self, text: str, **kwargs) -> List[float]:
+        """
+        Get embeddings for the input text using Gemini API.
+        """
+        if not self.client:
+             raise Exception("Gemini client not initialized.")
+        
+        # Default to a known Gemini embedding model
+        model_to_use = kwargs.get("model", "models/embedding-001")
+        
+        try:
+            response = self.client.embed_content(
+                model=model_to_use,
+                content=text,
+                task_type="retrieval_document" # or "semantic_similarity", etc.
+            )
+            return response['embedding']
+        except Exception as ex:
+            trace_exception(ex)
+            raise Exception(f"Gemini embedding failed: {str(ex)}") from ex
+
+    def get_model_info(self) -> dict:
+        """Return information about the current Gemini model setup."""
+        return {
+            "name": self.binding_name,
+            "version": genai.__version__,
+            "host_address": "https://generativelanguage.googleapis.com",
+            "model_name": self.model_name,
+            "supports_structured_output": False,
+            "supports_vision": "vision" in self.model_name or "gemini-1.5" in self.model_name,
+        }
+
+    def listModels(self) -> List[Dict[str, str]]:
+        """Lists available generative models from the Gemini service."""
+        if not self.client:
+            ASCIIColors.error("Gemini client not initialized. Cannot list models.")
+            return []
+        try:
+            ASCIIColors.debug("Listing Gemini models...")
+            model_info_list = []
+            for m in self.client.list_models():
+                # We are interested in models that can generate content.
+                if 'generateContent' in m.supported_generation_methods:
+                    model_info_list.append({
+                        'model_name': m.name,
+                        'display_name': m.display_name,
+                        'description': m.description,
+                        'owned_by': 'Google' 
+                    })
+            return model_info_list
+        except Exception as ex:
+            trace_exception(ex)
+            return []
+
+    def load_model(self, model_name: str) -> bool:
+        """Set the model name for subsequent operations."""
+        self.model_name = model_name
+        ASCIIColors.info(f"Gemini model set to: {model_name}. It will be used on the next API call.")
+        return True
+
+if __name__ == '__main__':
+    # Example Usage (requires GOOGLE_API_KEY environment variable)
+    if 'GOOGLE_API_KEY' not in os.environ:
+        ASCIIColors.red("Error: GOOGLE_API_KEY environment variable not set.")
+        print("Please get your key from Google AI Studio and set it.")
+        exit(1)
+
+    ASCIIColors.yellow("--- Testing GeminiBinding ---")
+
+    # --- Configuration ---
+    test_model_name = "gemini-1.5-pro-latest"
+    test_vision_model_name = "gemini-1.5-pro-latest" # or gemini-pro-vision
+    test_embedding_model = "models/embedding-001"
+    
+    # This variable is global to the script's execution
+    full_streamed_text = ""
+
+    try:
+        # --- Initialization ---
+        ASCIIColors.cyan("\n--- Initializing Binding ---")
+        binding = GeminiBinding(model_name=test_model_name)
+        ASCIIColors.green("Binding initialized successfully.")
+        ASCIIColors.info(f"Using google-generativeai version: {genai.__version__}")
+
+        # --- List Models ---
+        ASCIIColors.cyan("\n--- Listing Models ---")
+        models = binding.listModels()
+        if models:
+            ASCIIColors.green(f"Found {len(models)} generative models. First 5:")
+            for m in models[:5]:
+                print(m['model_name'])
+        else:
+            ASCIIColors.warning("No models found or failed to list models.")
+
+        # --- Count Tokens ---
+        ASCIIColors.cyan("\n--- Counting Tokens ---")
+        sample_text = "Hello, world! This is a test."
+        token_count = binding.count_tokens(sample_text)
+        ASCIIColors.green(f"Token count for '{sample_text}': {token_count}")
+
+        # --- Text Generation (Non-Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Non-Streaming) ---")
+        prompt_text = "Explain the importance of bees in one paragraph."
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        generated_text = binding.generate_text(prompt_text, n_predict=100, stream=False)
+        if isinstance(generated_text, str):
+            ASCIIColors.green(f"Generated text:\n{generated_text}")
+        else:
+            ASCIIColors.error(f"Generation failed: {generated_text}")
+
+        # --- Text Generation (Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Streaming) ---")
+        
+        def stream_callback(chunk: str, msg_type: int):
+            # FIX: Use 'global' to modify the variable in the module's scope
+            global full_streamed_text
+            ASCIIColors.green(chunk, end="", flush=True)
+            full_streamed_text += chunk
+            return True
+        
+        # Reset for this test
+        full_streamed_text = ""
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        result = binding.generate_text(prompt_text, n_predict=150, stream=True, streaming_callback=stream_callback)
+        print("\n--- End of Stream ---")
+        # 'result' is the full text after streaming, which should match our captured text.
+        ASCIIColors.green(f"Full streamed text (for verification): {result}")
+
+        # --- Embeddings ---
+        ASCIIColors.cyan("\n--- Embeddings ---")
+        try:
+            embedding_text = "Lollms is a cool project."
+            embedding_vector = binding.embed(embedding_text, model=test_embedding_model)
+            ASCIIColors.green(f"Embedding for '{embedding_text}' (first 5 dims): {embedding_vector[:5]}...")
+            ASCIIColors.info(f"Embedding vector dimension: {len(embedding_vector)}")
+        except Exception as e:
+            ASCIIColors.warning(f"Could not get embedding: {e}")
+
+        # --- Vision Model Test ---
+        dummy_image_path = "gemini_dummy_test_image.png"
+        try:
+            img = Image.new('RGB', (200, 50), color = ('blue'))
+            d = ImageDraw.Draw(img)
+            d.text((10,10), "Test Image", fill=('yellow'))
+            img.save(dummy_image_path)
+            ASCIIColors.info(f"Created dummy image: {dummy_image_path}")
+
+            ASCIIColors.cyan(f"\n--- Vision Generation (using {test_vision_model_name}) ---")
+            binding.load_model(test_vision_model_name)
+            vision_prompt = "What color is the text and what does it say?"
+            ASCIIColors.info(f"Vision Prompt: {vision_prompt} with image {dummy_image_path}")
+            
+            vision_response = binding.generate_text(
+                prompt=vision_prompt,
+                images=[dummy_image_path],
+                n_predict=50,
+                stream=False
+            )
+            if isinstance(vision_response, str):
+                ASCIIColors.green(f"Vision model response: {vision_response}")
+            else:
+                ASCIIColors.error(f"Vision generation failed: {vision_response}")
+        except Exception as e:
+            ASCIIColors.error(f"Error during vision test: {e}")
+            trace_exception(e)
+        finally:
+            if os.path.exists(dummy_image_path):
+                os.remove(dummy_image_path)
+
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during testing: {e}")
+        trace_exception(e)
+
+    ASCIIColors.yellow("\nGeminiBinding test finished.")

lollms_client/llm_bindings/litellm/__init__.py

@@ -0,0 +1,201 @@
+# bindings/LiteLLM/binding.py
+import requests
+import json
+from lollms_client.lollms_llm_binding import LollmsLLMBinding
+from lollms_client.lollms_types import MSG_TYPE
+from lollms_client.lollms_discussion import LollmsDiscussion
+from lollms_client.lollms_utilities import encode_image
+from typing import Optional, Callable, List, Union, Dict
+from ascii_colors import ASCIIColors, trace_exception
+
+# Use pipmaster to ensure required packages are installed
+try:
+    import pipmaster as pm
+except ImportError:
+    print("Pipmaster not found. Please install it using 'pip install pipmaster'")
+    raise
+
+# Ensure requests and tiktoken are installed
+pm.ensure_packages(["requests", "tiktoken"])
+
+import tiktoken
+
+BindingName = "LiteLLMBinding"
+
+def get_icon_path(model_name: str) -> str:
+    model_name = model_name.lower()
+    if 'gpt' in model_name: return '/bindings/openai/logo.png'
+    if 'mistral' in model_name or 'mixtral' in model_name: return '/bindings/mistral/logo.png'
+    if 'claude' in model_name: return '/bindings/anthropic/logo.png'
+    return '/bindings/litellm/logo.png'
+
+class LiteLLMBinding(LollmsLLMBinding):
+    """
+    A binding for the LiteLLM proxy using direct HTTP requests.
+    This version includes detailed logging, a fallback for listing models,
+    and correct payload formatting for both streaming and non-streaming modes.
+    """
+    
+    def __init__(self, host_address: str, model_name: str, service_key: str = "anything", verify_ssl_certificate: bool = True, **kwargs):
+        super().__init__(binding_name="litellm")
+        self.host_address = host_address.rstrip('/')
+        self.model_name = model_name
+        self.service_key = service_key
+        self.verify_ssl_certificate = verify_ssl_certificate
+
+    def _perform_generation(self, messages: List[Dict], n_predict: Optional[int], stream: bool, temperature: float, top_p: float, repeat_penalty: float, seed: Optional[int], streaming_callback: Optional[Callable[[str, MSG_TYPE], None]]) -> Union[str, dict]:
+        url = f'{self.host_address}/v1/chat/completions'
+        headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {self.service_key}'}
+        payload = {
+            "model": self.model_name, "messages": messages, "max_tokens": n_predict,
+            "temperature": temperature, "top_p": top_p, "frequency_penalty": repeat_penalty,
+            "stream": stream
+        }
+        if seed is not None: payload["seed"] = seed
+        
+        payload = {k: v for k, v in payload.items() if v is not None}
+        output = ""
+        try:
+            response = requests.post(url, headers=headers, data=json.dumps(payload), stream=stream, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+
+            if stream:
+                for line in response.iter_lines():
+                    if line:
+                        decoded_line = line.decode('utf-8')
+                        if decoded_line.startswith('data: '):
+                            if '[DONE]' in decoded_line: break
+                            json_data_string = decoded_line[6:]
+                            try:
+                                chunk_data = json.loads(json_data_string)
+                                delta = chunk_data.get('choices', [{}])[0].get('delta', {})
+                                if 'content' in delta and delta['content'] is not None:
+                                    word = delta['content']
+                                    if streaming_callback and not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                                        return output
+                                    output += word
+                            except json.JSONDecodeError: continue
+            else:
+                full_response = response.json()
+                output = full_response['choices'][0]['message']['content']
+                if streaming_callback:
+                    streaming_callback(output, MSG_TYPE.MSG_TYPE_CHUNK)
+        except Exception as e:
+            error_message = f"An error occurred: {e}\nResponse: {response.text if 'response' in locals() else 'No response'}"
+            trace_exception(e)
+            if streaming_callback: streaming_callback(error_message, MSG_TYPE.MSG_TYPE_EXCEPTION)
+            return {"status": "error", "message": error_message}
+        return output
+
+    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_p: float = 0.9, repeat_penalty: float = 1.1, seed: Optional[int] = None, streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None, **kwargs) -> Union[str, dict]:
+        """Generates text from a prompt, correctly formatting for text-only and multi-modal cases."""
+        is_streaming = stream if stream is not None else (streaming_callback is not None)
+        
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        # --- THIS IS THE CRITICAL FIX ---
+        if images:
+            # If images are present, use the multi-modal list format for content
+            user_content = [{"type": "text", "text": prompt}]
+            for image_path in images:
+                base64_image = encode_image(image_path)
+                user_content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}})
+            messages.append({"role": "user", "content": user_content})
+        else:
+            # If no images, use a simple string for content to avoid the API error
+            messages.append({"role": "user", "content": prompt})
+        # --- END OF FIX ---
+
+        return self._perform_generation(messages, n_predict, is_streaming, temperature, top_p, repeat_penalty, seed, streaming_callback)
+
+    def chat(self, discussion: LollmsDiscussion, branch_tip_id: Optional[str] = None, n_predict: Optional[int] = None, stream: Optional[bool] = None, temperature: float = 0.7, top_p: float = 0.9, repeat_penalty: float = 1.1, seed: Optional[int] = None, streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None, **kwargs) -> Union[str, dict]:
+        is_streaming = stream if stream is not None else (streaming_callback is not None)
+        messages = discussion.export("openai_chat", branch_tip_id)
+        return self._perform_generation(messages, n_predict, is_streaming, temperature, top_p, repeat_penalty, seed, streaming_callback)
+
+    def embed(self, text: str, **kwargs) -> List[float]:
+        url = f'{self.host_address}/v1/embeddings'
+        headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {self.service_key}'}
+        payload = {"model": self.model_name, "input": text}
+        try:
+            response = requests.post(url, headers=headers, data=json.dumps(payload), verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+            return response.json()['data'][0]['embedding']
+        except Exception as e:
+            trace_exception(e)
+            return []
+
+    def tokenize(self, text: str) -> list:
+        return tiktoken.model.encoding_for_model("gpt-3.5-turbo").encode(text)
+            
+    def detokenize(self, tokens: list) -> str:
+        return tiktoken.model.encoding_for_model("gpt-3.5-turbo").decode(tokens)
+
+    def count_tokens(self, text: str) -> int:
+        return len(self.tokenize(text))
+    
+    def _list_models_openai_fallback(self) -> List[Dict]:
+        ASCIIColors.warning("--- [LiteLLM Binding] Falling back to /v1/models endpoint. Rich metadata will be unavailable.")
+        url = f'{self.host_address}/v1/models'
+        headers = {'Authorization': f'Bearer {self.service_key}'}
+        entries = []
+        try:
+            response = requests.get(url, headers=headers, verify=self.verify_ssl_certificate)
+            response.raise_for_status()
+            models_data = response.json().get('data', [])
+            for model in models_data:
+                model_name = model.get('id')
+                entries.append({
+                    "category": "api", "datasets": "unknown", "icon": get_icon_path(model_name),
+                    "license": "unknown", "model_creator": model.get('owned_by', 'unknown'),
+                    "name": model_name, "provider": "litellm", "rank": "1.0", "type": "api",
+                    "variants": [{"name": model_name, "size": -1}]
+                })
+        except Exception as e:
+            ASCIIColors.error(f"--- [LiteLLM Binding] Fallback method failed: {e}")
+        return entries
+
+    def listModels(self) -> List[Dict]:
+        url = f'{self.host_address}/model/info'
+        headers = {'Authorization': f'Bearer {self.service_key}'}
+        entries = []
+        ASCIIColors.yellow(f"--- [LiteLLM Binding] Attempting to list models from: {url}")
+        try:
+            response = requests.get(url, headers=headers, verify=self.verify_ssl_certificate)
+            if response.status_code == 404:
+                ASCIIColors.warning("--- [LiteLLM Binding] /model/info endpoint not found (404).")
+                return self._list_models_openai_fallback()
+            response.raise_for_status()
+            models_data = response.json().get('data', [])
+            ASCIIColors.info(f"--- [LiteLLM Binding] Successfully parsed {len(models_data)} models from primary endpoint.")
+            for model in models_data:
+                model_name = model.get('model_name')
+                if not model_name: continue
+                model_info = model.get('model_info', {})
+                context_size = model_info.get('max_tokens', model_info.get('max_input_tokens', 4096))
+                entries.append({
+                    "category": "api", "datasets": "unknown", "icon": get_icon_path(model_name),
+                    "license": "unknown", "model_creator": model_info.get('owned_by', 'unknown'),
+                    "name": model_name, "provider": "litellm", "rank": "1.0", "type": "api",
+                    "variants": [{
+                        "name": model_name, "size": context_size,
+                        "input_cost_per_token": model_info.get('input_cost_per_token', 0),
+                        "output_cost_per_token": model_info.get('output_cost_per_token', 0),
+                        "max_output_tokens": model_info.get('max_output_tokens', 0),
+                    }]
+                })
+        except requests.exceptions.RequestException as e:
+            ASCIIColors.error(f"--- [LiteLLM Binding] Network error when trying to list models: {e}")
+            if "404" in str(e): return self._list_models_openai_fallback()
+        except Exception as e:
+            ASCIIColors.error(f"--- [LiteLLM Binding] An unexpected error occurred while listing models: {e}")
+        return entries
+
+    def get_model_info(self) -> dict:
+        return {"name": "LiteLLM", "host_address": self.host_address, "model_name": self.model_name}
+
+    def load_model(self, model_name: str) -> bool:
+        self.model_name = model_name
+        return True

lollms_client/lollms_core.py

@@ -1562,7 +1562,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     else:
                         _substitute_code_uuids_recursive(item, code_store)
 
-        discovery_step_id = log_event("Discovering tools",MSG_TYPE.MSG_TYPE_STEP_START)
+        discovery_step_id = log_event("**Discovering tools**",MSG_TYPE.MSG_TYPE_STEP_START)
         # --- 1. Discover Available Tools ---
         available_tools = []
         if use_mcps and self.mcp:
@@ -1595,12 +1595,12 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         formatted_tools_list += "\n**request_clarification**:\nUse if the user's request is ambiguous and you can not infer a clear idea of his intent. this tool has no parameters."
         formatted_tools_list += "\n**final_answer**:\nUse when you are ready to respond to the user. this tool has no parameters."
 
-        if discovery_step_id: log_event("Discovering tools",MSG_TYPE.MSG_TYPE_STEP_END, event_id=discovery_step_id)
+        if discovery_step_id: log_event("**Discovering tools**",MSG_TYPE.MSG_TYPE_STEP_END, event_id=discovery_step_id)
 
         # --- 2. Dynamic Reasoning Loop ---
         for i in range(max_reasoning_steps):
             try:
-                reasoning_step_id = log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_START)
+                reasoning_step_id = log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_START)
                 user_context = f'Original User Request: "{original_user_prompt}"'
                 if images: user_context += f'\n(Note: {len(images)} image(s) were provided with this request.)'
                 
@@ -1636,6 +1636,9 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     system_prompt=reasoning_system_prompt, temperature=decision_temperature,
                     images=images if i == 0 else None
                 )
+                if structured_action_response is None:
+                    log_event("**Error generating thought.** Retrying..", MSG_TYPE.MSG_TYPE_EXCEPTION)
+                    continue
                 if debug: log_prompt(structured_action_response, f"RAW REASONING RESPONSE (Step {i+1})")
 
                 try:
@@ -1651,11 +1654,11 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                 except (json.JSONDecodeError, TypeError) as e:
                     current_scratchpad += f"\n\n### Step {i+1} Failure\n- **Error:** Failed to generate a valid JSON action: {e}"
                     log_event(f"Step Failure: Invalid JSON action.", MSG_TYPE.MSG_TYPE_EXCEPTION, metadata={"details": str(e)})
-                    if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_END, metadata={"error": str(e)}, event_id=reasoning_step_id)
+                    if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_END, metadata={"error": str(e)}, event_id=reasoning_step_id)
                     
 
                 current_scratchpad += f"\n\n### Step {i+1}: Thought\n{thought}"
-                log_event(f"Thought: {thought}", MSG_TYPE.MSG_TYPE_THOUGHT_CONTENT)
+                log_event(f"**Thought**: {thought}", MSG_TYPE.MSG_TYPE_THOUGHT_CONTENT)
 
                 if not tool_name:
                     # Handle error...
@@ -1668,8 +1671,8 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
 
                 if tool_name == "final_answer":
                     current_scratchpad += f"\n\n### Step {i+1}: Action\n- **Action:** Decided to formulate the final answer."
-                    log_event("Action: Formulate final answer.", MSG_TYPE.MSG_TYPE_THOUGHT_CHUNK)
-                    if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}",MSG_TYPE.MSG_TYPE_STEP_END, event_id=reasoning_step_id)
+                    log_event("**Action**: Formulate final answer.", MSG_TYPE.MSG_TYPE_THOUGHT_CHUNK)
+                    if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**",MSG_TYPE.MSG_TYPE_STEP_END, event_id=reasoning_step_id)
                     break
 
                 # --- Handle the `put_code_in_buffer` tool specifically ---
@@ -1688,9 +1691,9 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     tool_calls_this_turn.append({"name": "put_code_in_buffer", "params": tool_params, "result": tool_result})
                     observation_text = f"```json\n{json.dumps(tool_result, indent=2)}\n```"
                     current_scratchpad += f"\n\n### Step {i+1}: Observation\n- **Action:** Called `{tool_name}`\n- **Result:**\n{observation_text}"
-                    log_event(f"Observation: Code generated with ID: {code_uuid}", MSG_TYPE.MSG_TYPE_OBSERVATION)
+                    log_event(f"**Observation**:Code generated with ID: {code_uuid}", MSG_TYPE.MSG_TYPE_OBSERVATION)
                     if code_gen_id: log_event(f"Generating code...", MSG_TYPE.MSG_TYPE_TOOL_CALL, metadata={"id": code_gen_id, "result": tool_result})
-                    if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_END, event_id= reasoning_step_id)
+                    if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_END, event_id= reasoning_step_id)
                     continue # Go to the next reasoning step immediately
                 if tool_name == 'refactor_scratchpad':
                     scratchpad_cleaning_prompt = f"""Enhance this scratchpad content to be more organized and comprehensive. Keep relevant experience information and remove any useless redundancies. Try to log learned things from the context so that you won't make the same mistakes again. Do not remove the main objective information or any crucial information that may be useful for the next iterations. Answer directly with the new scratchpad content without any comments.
@@ -1698,13 +1701,13 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
 {current_scratchpad}
 --- END OF SCRATCHPAD ---"""
                     current_scratchpad = self.generate_text(scratchpad_cleaning_prompt)
-                    log_event(f"New scratchpad:\n{current_scratchpad}")
+                    log_event(f"**New scratchpad**:\n{current_scratchpad}", MSG_TYPE.MSG_TYPE_SCRATCHPAD)
                     
                 # --- Substitute UUIDs and Execute Standard Tools ---
-                log_event(f"Calling tool: `{tool_name}` with params:\n{dict_to_markdown(tool_params)}", MSG_TYPE.MSG_TYPE_STEP)
+                log_event(f"**Calling tool**: `{tool_name}` with params:\n{dict_to_markdown(tool_params)}", MSG_TYPE.MSG_TYPE_TOOL_CALL)
                 _substitute_code_uuids_recursive(tool_params, generated_code_store)
                 
-                tool_call_id = log_event(f"Executing tool: {tool_name}",MSG_TYPE.MSG_TYPE_STEP_START, metadata={"name": tool_name, "parameters": tool_params, "id":"executing tool"})
+                tool_call_id = log_event(f"**Executing tool**: {tool_name}",MSG_TYPE.MSG_TYPE_STEP_START, metadata={"name": tool_name, "parameters": tool_params, "id":"executing tool"})
                 tool_result = None
                 try:
                     if tool_name.startswith("research::") and use_data_store:
@@ -1726,7 +1729,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     trace_exception(e)
                     tool_result = {"status": "failure", "error": f"Exception executing tool: {str(e)}"}
                 
-                if tool_call_id: log_event(f"Executing tool: {tool_name}", MSG_TYPE.MSG_TYPE_STEP_END, metadata={"result": tool_result}, event_id= tool_call_id)
+                if tool_call_id: log_event(f"**Executing tool**: {tool_name}", MSG_TYPE.MSG_TYPE_STEP_END, metadata={"result": tool_result}, event_id= tool_call_id)
 
                 observation_text = ""
                 sanitized_result = {}
@@ -1752,13 +1755,13 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                 
                 tool_calls_this_turn.append({"name": tool_name, "params": tool_params, "result": tool_result})
                 current_scratchpad += f"\n\n### Step {i+1}: Observation\n- **Action:** Called `{tool_name}`\n- **Result:**\n{observation_text}"
-                log_event(f"Observation: Result from `{tool_name}`:\n{dict_to_markdown(sanitized_result)}", MSG_TYPE.MSG_TYPE_OBSERVATION)
+                log_event(f"**Observation**: Result from `{tool_name}`:\n{dict_to_markdown(sanitized_result)}", MSG_TYPE.MSG_TYPE_OBSERVATION)
                 
-                if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_END, event_id = reasoning_step_id)
+                if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_END, event_id = reasoning_step_id)
             except Exception as ex:
                 trace_exception(ex)
                 current_scratchpad += f"\n\n### Error : {ex}"
-                if reasoning_step_id: log_event(f"Reasoning Step {i+1}/{max_reasoning_steps}", MSG_TYPE.MSG_TYPE_STEP_END, event_id = reasoning_step_id)
+                if reasoning_step_id: log_event(f"**Reasoning Step {i+1}/{max_reasoning_steps}**", MSG_TYPE.MSG_TYPE_STEP_END, event_id = reasoning_step_id)
                 
         # --- Final Answer Synthesis ---
         synthesis_id = log_event("Synthesizing final answer...", MSG_TYPE.MSG_TYPE_STEP_START)
@@ -1777,6 +1780,17 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
 
             
         final_answer_text = self.generate_text(prompt=final_answer_prompt, system_prompt=system_prompt, images=images, stream=streaming_callback is not None, streaming_callback=streaming_callback, temperature=final_answer_temperature, **llm_generation_kwargs)
+        if type(final_answer_text) is dict:
+            if streaming_callback:
+                streaming_callback(final_answer_text["error"], MSG_TYPE.MSG_TYPE_EXCEPTION)
+            return {
+            "final_answer": "",
+            "final_scratchpad": current_scratchpad,
+            "tool_calls": tool_calls_this_turn,
+            "sources": sources_this_turn,
+            "clarification_required": False,
+            "error": final_answer_text["error"]
+        }
         final_answer = self.remove_thinking_blocks(final_answer_text)
         if debug: log_prompt(final_answer_text, "FINAL ANSWER RESPONSE")
 

lollms_client/lollms_discussion.py

@@ -423,9 +423,34 @@ class LollmsDiscussion:
         else:
             return cls(lollmsClient=lollms_client, discussion_id=kwargs.get('id'), **init_args)
 
-    def get_messages(self):
-        """Returns the list of messages"""
-        return self._db_discussion.messages
+    def get_messages(self, branch_id: Optional[str] = None) -> Union[List[LollmsMessage], Optional[LollmsMessage]]:
+        """
+        Returns messages from the discussion with branch-aware logic.
+
+        - If no branch_id is provided, it returns a list of all messages
+          in the currently active branch, ordered from root to leaf.
+        - If a branch_id is provided, it returns the single message object
+          (the "leaf") corresponding to that ID.
+
+        Args:
+            branch_id: The ID of the leaf message. If provided, only this
+                       message is returned. If None, the full active branch is returned.
+
+        Returns:
+            A list of LollmsMessage objects for the active branch, or a single
+            LollmsMessage if a branch_id is specified, or None if the ID is not found.
+        """
+        if branch_id is None:
+            # Case 1: No ID, return the current active branch as a list of messages
+            leaf_id = self.active_branch_id
+            return self.get_branch(leaf_id)
+        else:
+            # Case 2: ID provided, return just the single leaf message
+            if branch_id in self._message_index:
+                return LollmsMessage(self, self._message_index[branch_id])
+            else:
+                return None
+
 
     def __getattr__(self, name: str) -> Any:
         """Proxies attribute getting to the underlying discussion object."""

{lollms_client-0.25.1.dist-info → lollms_client-0.25.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.25.1
+Version: 0.25.6
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License
@@ -169,6 +169,107 @@ except Exception as e:
 ```
 For a comprehensive guide on function calling and setting up tools, please refer to the [Usage Guide (DOC_USE.md)](DOC_USE.md).
 
+### 🤖 Advanced Agentic Generation with RAG: `generate_with_mcp_rag`
+
+For more complex tasks, `generate_with_mcp_rag` provides a powerful, built-in agent that uses a ReAct-style (Reason, Act) loop. This agent can reason about a user's request, use tools (MCP), retrieve information from knowledge bases (RAG), and adapt its plan based on the results of its actions.
+
+**Key Agent Capabilities:**
+
+*   **Observe-Think-Act Loop:** The agent iteratively reviews its progress, thinks about the next logical step, and takes an action (like calling a tool).
+*   **Tool Integration (MCP):** Can use any available MCP tools, such as searching the web or executing code.
+*   **Retrieval-Augmented Generation (RAG):** You can provide one or more "data stores" (knowledge bases). The agent gains a `research::{store_name}` tool to query these stores for relevant information.
+*   **In-Memory Code Generation:** The agent has a special `generate_code` tool. This allows it to first write a piece of code (e.g., a complex Python script) and then pass that code to another tool (e.g., `python_code_interpreter`) in a subsequent step.
+*   **Stateful Progress Tracking:** Designed for rich UI experiences, it emits `step_start` and `step_end` events with unique IDs via the streaming callback. This allows an application to track the agent's individual thoughts and long-running tool calls in real-time.
+*   **Self-Correction:** Includes a `refactor_scratchpad` tool for the agent to clean up its own thought process if it becomes cluttered.
+
+Here is an example of using the agent to answer a question by first performing RAG on a custom knowledge base and then using the retrieved information to generate and execute code.
+
+```python
+import json
+from lollms_client import LollmsClient, MSG_TYPE
+from ascii_colors import ASCIIColors
+
+# 1. Define a mock RAG data store and retrieval function
+project_notes = {
+    "project_phoenix_details": "Project Phoenix has a current budget of $500,000 and an expected quarterly growth rate of 15%."
+}
+
+def retrieve_from_notes(query: str, top_k: int = 1, min_similarity: float = 0.5):
+    """A simple keyword-based retriever for our mock data store."""
+    results = []
+    for key, text in project_notes.items():
+        if query.lower() in text.lower():
+            results.append({"source": key, "content": text})
+    return results[:top_k]
+
+# 2. Define a detailed streaming callback to visualize the agent's process
+def agent_streaming_callback(chunk: str, msg_type: MSG_TYPE, params: dict = None, metadata: list = None) -> bool:
+    if not params: params = {}
+    msg_id = params.get("id", "")
+    
+    if msg_type == MSG_TYPE.MSG_TYPE_STEP_START:
+        ASCIIColors.yellow(f"\n>> Agent Step Start [ID: {msg_id}]: {chunk}")
+    elif msg_type == MSG_TYPE.MSG_TYPE_STEP_END:
+        ASCIIColors.green(f"<< Agent Step End [ID: {msg_id}]: {chunk}")
+        if params.get('result'):
+            ASCIIColors.cyan(f"   Result: {json.dumps(params['result'], indent=2)}")
+    elif msg_type == MSG_TYPE.MSG_TYPE_THOUGHT_CONTENT:
+        ASCIIColors.magenta(f"\n🤔 Agent Thought: {chunk}")
+    elif msg_type == MSG_TYPE.MSG_TYPE_TOOL_CALL:
+        ASCIIColors.blue(f"\n🛠️  Agent Action: {chunk}")
+    elif msg_type == MSG_TYPE.MSG_TYPE_OBSERVATION:
+        ASCIIColors.cyan(f"\n👀 Agent Observation: {chunk}")
+    elif msg_type == MSG_TYPE.MSG_TYPE_CHUNK:
+        print(chunk, end="", flush=True) # Final answer stream
+    return True
+
+try:
+    # 3. Initialize LollmsClient with an LLM and local tools enabled
+    lc = LollmsClient(
+        binding_name="ollama",          # Use Ollama
+        model_name="llama3",            # Or any capable model like mistral, gemma, etc.
+        mcp_binding_name="local_mcp"    # Enable local tools like python_code_interpreter
+    )
+
+    # 4. Define the user prompt and the RAG data store
+    prompt = "Based on my notes about Project Phoenix, write and run a Python script to calculate its projected budget after two quarters."
+    
+    rag_data_store = {
+        "project_notes": {"callable": retrieve_from_notes}
+    }
+
+    ASCIIColors.yellow(f"User Prompt: {prompt}")
+    print("\n" + "="*50 + "\nAgent is now running...\n" + "="*50)
+
+    # 5. Run the agent
+    agent_output = lc.generate_with_mcp_rag(
+        prompt=prompt,
+        use_data_store=rag_data_store,
+        use_mcps=["python_code_interpreter"], # Make specific tools available
+        streaming_callback=agent_streaming_callback,
+        max_reasoning_steps=5
+    )
+
+    print("\n" + "="*50 + "\nAgent finished.\n" + "="*50)
+
+    # 6. Print the final results
+    if agent_output.get("error"):
+        ASCIIColors.error(f"\nAgent Error: {agent_output['error']}")
+    else:
+        ASCIIColors.green("\n--- Final Answer ---")
+        print(agent_output.get("final_answer"))
+        
+        ASCIIColors.magenta("\n--- Tool Calls ---")
+        print(json.dumps(agent_output.get("tool_calls", []), indent=2))
+
+        ASCIIColors.cyan("\n--- RAG Sources ---")
+        print(json.dumps(agent_output.get("sources", []), indent=2))
+
+except Exception as e:
+    ASCIIColors.red(f"\nAn unexpected error occurred: {e}")
+
+```
+
 ## Documentation
 
 For more in-depth information, please refer to:
@@ -186,7 +287,7 @@ graph LR
         LC -- Manages --> LLB[LLM Binding];
         LC -- Manages --> MCPB[MCP Binding];
         LC -- Orchestrates --> MCP_Interaction[generate_with_mcp];
-        LC -- Provides --> HighLevelOps[High-Level Ops<br>(summarize, deep_analyze etc.)];
+        LC -- Provides --> HighLevelOps["High-Level Ops(summarize, deep_analyze etc.)"];
         LC -- Provides Access To --> DM[DiscussionManager];
         LC -- Provides Access To --> ModalityBindings[TTS, TTI, STT etc.];
     end
@@ -195,16 +296,16 @@ graph LR
         LLB --> LollmsServer[LoLLMs Server];
         LLB --> OllamaServer[Ollama];
         LLB --> OpenAPIServer[OpenAI API];
-        LLB --> LocalGGUF[Local GGUF<br>(pythonllamacpp / llamacpp server)];
-        LLB --> LocalHF[Local HuggingFace<br>(transformers / vLLM)];
+        LLB --> LocalGGUF["Local GGUF<br>(pythonllamacpp / llamacpp server)"];
+        LLB --> LocalHF["Local HuggingFace<br>(transformers / vLLM)"];
     end
 
     MCP_Interaction --> MCPB;
-    MCPB --> LocalTools[Local Python Tools<br>(via local_mcp)];
-    MCPB --> RemoteTools[Remote MCP Tool Servers<br>(Future Potential)];
+    MCPB --> LocalTools["Local Python Tools<br>(via local_mcp)"];
+    MCPB --> RemoteTools["Remote MCP Tool Servers<br>(Future Potential)"];
 
 
-    ModalityBindings --> ModalityServices[Modality Services<br>(e.g., LoLLMs Server TTS/TTI, local Bark/XTTS)];
+    ModalityBindings --> ModalityServices["Modality Services<br>(e.g., LoLLMs Server TTS/TTI, local Bark/XTTS)"];
 ```
 
 *   **`LollmsClient`**: The central class for all interactions. It holds the currently active LLM binding, an optional MCP binding, and provides access to modality bindings and high-level operations.

{lollms_client-0.25.1.dist-info → lollms_client-0.25.6.dist-info}/RECORD

@@ -26,10 +26,10 @@ examples/mcp_examples/openai_mcp.py,sha256=7IEnPGPXZgYZyiES_VaUbQ6viQjenpcUxGiHE
 examples/mcp_examples/run_remote_mcp_example_v2.py,sha256=bbNn93NO_lKcFzfIsdvJJijGx2ePFTYfknofqZxMuRM,14626
 examples/mcp_examples/run_standard_mcp_example.py,sha256=GSZpaACPf3mDPsjA8esBQVUsIi7owI39ca5avsmvCxA,9419
 examples/test_local_models/local_chat.py,sha256=slakja2zaHOEAUsn2tn_VmI4kLx6luLBrPqAeaNsix8,456
-lollms_client/__init__.py,sha256=Vt2zeJ4Ekn2UWxfSKbn_pjE-QGL7uwoTnbTFuFIOyUk,1047
+lollms_client/__init__.py,sha256=pXsP6DSu8Afm4PZN5PmsBipV-ZOKCS81s7bngvYCcgU,1047
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=m_qfzybasY61KgAPVa84tdkqJWIog9iuIZc88pQQ-vw,158842
-lollms_client/lollms_discussion.py,sha256=JqKx--a6YMzL6ec6N9OD0B9oRlmkSV_KDKXjqP8291Y,47636
+lollms_client/lollms_core.py,sha256=TujAapwba9gDe6EEY4olVSP-lZrLftY4LOSex-D-IPs,159610
+lollms_client/lollms_discussion.py,sha256=By_dN3GJ7AtInkOUdcrXuVhKliBirKd3ZxFkaRmt1yM,48843
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=Kpzhs5Jx8eAlaaUacYnKV7qIq2wbME5lOEtKSfJKbpg,12161
 lollms_client/lollms_mcp_binding.py,sha256=0rK9HQCBEGryNc8ApBmtOlhKE1Yfn7X7xIQssXxS2Zc,8933
@@ -43,6 +43,8 @@ lollms_client/lollms_ttv_binding.py,sha256=KkTaHLBhEEdt4sSVBlbwr5i_g_TlhcrwrT-7D
 lollms_client/lollms_types.py,sha256=0iSH1QHRRD-ddBqoL9EEKJ8wWCuwDUlN_FrfbCdg7Lw,3522
 lollms_client/lollms_utilities.py,sha256=zx1X4lAXQ2eCUM4jDpu_1QV5oMGdFkpaSEdTASmaiqE,13545
 lollms_client/llm_bindings/__init__.py,sha256=9sWGpmWSSj6KQ8H4lKGCjpLYwhnVdL_2N7gXCphPqh4,14
+lollms_client/llm_bindings/gemini/__init__.py,sha256=ZflZVwAkAa-GfctuehOWIav977oTCdXUisQy253PFsk,21611
+lollms_client/llm_bindings/litellm/__init__.py,sha256=xlTaKosxK1tKz1YJ6witK6wAJHIENTV6O7ZbfpUOdB4,11289
 lollms_client/llm_bindings/llamacpp/__init__.py,sha256=Qj5RvsgPeHGNfb5AEwZSzFwAp4BOWjyxmm9qBNtstrc,63716
 lollms_client/llm_bindings/lollms/__init__.py,sha256=jfiCGJqMensJ7RymeGDDJOsdokEdlORpw9ND_Q30GYc,17831
 lollms_client/llm_bindings/ollama/__init__.py,sha256=QufsYqak2VlA2XGbzks8u55yNJFeDH2V35NGeZABkm8,32554
@@ -79,8 +81,8 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=0IEWG4zH3_sOkSb9WbZzkeV5
 lollms_client/tts_bindings/xtts/__init__.py,sha256=FgcdUH06X6ZR806WQe5ixaYx0QoxtAcOgYo87a2qxYc,18266
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-0.25.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.25.1.dist-info/METADATA,sha256=4yR9ohOc_JjNnJeDRTdbzfYbKkmMpl0wbw0Y9D2P0gc,13401
-lollms_client-0.25.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.25.1.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.25.1.dist-info/RECORD,,
+lollms_client-0.25.6.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.25.6.dist-info/METADATA,sha256=dqV9ITu1ABd8rtnvPb4N7K3qUTCD6stQJhys08xoUJs,18659
+lollms_client-0.25.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.25.6.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.25.6.dist-info/RECORD,,