lollms-client 0.20.3__py3-none-any.whl → 0.20.6__py3-none-any.whl

lollms_client/mcp_bindings/remote_mcp/__init__.py

@@ -1,68 +1,95 @@
-# Conceptual: lollms_client/mcp_bindings/remote_mcp/__init__.py
-
 import asyncio
 from contextlib import AsyncExitStack
 from typing import Optional, List, Dict, Any, Tuple
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding
 from ascii_colors import ASCIIColors, trace_exception
 import threading
+import json
+
 try:
     from mcp import ClientSession, types
-    # Import the specific network client from MCP SDK
     from mcp.client.streamable_http import streamablehttp_client
-    # If supporting OAuth, you'd import auth components:
-    # from mcp.client.auth import OAuthClientProvider, TokenStorage
-    # from mcp.shared.auth import OAuthClientMetadata, OAuthToken
     MCP_LIBRARY_AVAILABLE = True
 except ImportError:
-    # ... (error handling as in StandardMCPBinding) ...
     MCP_LIBRARY_AVAILABLE = False
-    ClientSession = None # etc.
+    ClientSession = None
     streamablehttp_client = None
 
 
 BindingName = "RemoteMCPBinding"
-# No TOOL_NAME_SEPARATOR needed if connecting to one remote server per instance,
-# or if server aliases are handled differently (e.g. part of URL or config)
 TOOL_NAME_SEPARATOR  = "::"
 
 class RemoteMCPBinding(LollmsMCPBinding):
+    """
+    This binding allows the connection to one or more remote MCP servers.
+    Tools from all connected servers are aggregated and prefixed with the server's alias.
+    """
     def __init__(self,
-                 server_url: str, # e.g., "http://localhost:8000/mcp"
-                 alias: str = "remote_server", # An alias for this connection
-                 auth_config: Optional[Dict[str, Any]] = None, # For API keys, OAuth, etc.
+                 servers_infos: Dict[str, Dict[str, Any]],
                  **other_config_params: Any):
+        """
+        Initializes the binding to connect to multiple MCP servers.
+
+        Args:
+            servers_infos (Dict[str, Dict[str, Any]]): A dictionary where each key is a unique
+                alias for a server, and the value is another dictionary containing connection
+                details for that server.
+                Example:
+                {
+                    "main_server": {"server_url": "http://localhost:8787", "auth_config": {}},
+                    "experimental_server": {"server_url": "http://test.server:9000"}
+                }
+            **other_config_params (Any): Additional configuration parameters.
+        """
         super().__init__(binding_name="remote_mcp")
         
         if not MCP_LIBRARY_AVAILABLE:
-            ASCIIColors.error(f"{self.binding_name}: MCP library not available.")
+            ASCIIColors.error(f"{self.binding_name}: MCP library not available. This binding will be disabled.")
             return
 
-        if not server_url:
-            ASCIIColors.error(f"{self.binding_name}: server_url is required.")
-            # Or raise ValueError
+        if not servers_infos or not isinstance(servers_infos, dict):
+            ASCIIColors.error(f"{self.binding_name}: `servers_infos` dictionary is required and cannot be empty.")
             return
 
-        self.server_url = server_url
-        self.alias = alias # Could be used to prefix tool names if managing multiple remotes
-        self.auth_config = auth_config or {}
+        ### NEW: Store the overall configuration
         self.config = {
-            "server_url": server_url,
-            "alias": alias,
-            "auth_config": self.auth_config
+            "servers_infos": servers_infos,
+            **other_config_params
         }
-        self.config.update(other_config_params)
 
-        self._mcp_session: Optional[ClientSession] = None
-        self._exit_stack: Optional[AsyncExitStack] = None
+        ### NEW: State management for multiple servers.
+        # The key is the server alias. The value is a dictionary holding the state for that server.
+        self.servers: Dict[str, Dict[str, Any]] = {}
+        for alias, info in servers_infos.items():
+            if "server_url" not in info:
+                ASCIIColors.warning(f"{self.binding_name}: Skipping server '{alias}' due to missing 'server_url'.")
+                continue
+            
+            self.servers[alias] = {
+                "url": info["server_url"],
+                "auth_config": info.get("auth_config", {}),
+                "session": None,        # Will hold the ClientSession
+                "exit_stack": None,     # Will hold the AsyncExitStack
+                "initialized": False,
+                "initializing_lock": threading.Lock() # Prevents race conditions on initialization
+            }
+
         self._discovered_tools_cache: List[Dict[str, Any]] = []
-        self._is_initialized = False
+
+        ### MODIFIED: These are now shared across all connections
         self._loop: Optional[asyncio.AbstractEventLoop] = None
         self._thread: Optional[threading.Thread] = None
+        self._loop_started_event = threading.Event()
 
-        self._start_event_loop_thread() # Similar to StandardMCPBinding
+        if self.servers:
+            self._start_event_loop_thread()
+        else:
+            ASCIIColors.warning(f"{self.binding_name}: No valid servers configured.")
 
-    def _start_event_loop_thread(self): # Simplified from StandardMCPBinding
+    # _start_event_loop_thread, _run_loop_forever, _wait_for_loop, _run_async
+    # are utility methods for the shared event loop and do not need to be changed.
+    # They manage the async infrastructure for the entire binding instance.
+    def _start_event_loop_thread(self):
         if self._loop and self._loop.is_running(): return
         self._loop = asyncio.new_event_loop()
         self._thread = threading.Thread(target=self._run_loop_forever, daemon=True)
@@ -71,83 +98,115 @@ class RemoteMCPBinding(LollmsMCPBinding):
     def _run_loop_forever(self):
         if not self._loop: return
         asyncio.set_event_loop(self._loop)
-        try: self._loop.run_forever()
+        try:
+            self._loop_started_event.set()
+            self._loop.run_forever()
         finally:
-            # ... (loop cleanup as in StandardMCPBinding) ...
             if not self._loop.is_closed(): self._loop.close()
 
-    def _run_async(self, coro, timeout=None): # Simplified
-        if not self._loop or not self._loop.is_running(): raise RuntimeError("Event loop not running.")
+    def _wait_for_loop(self, timeout=5.0):
+        if not self._loop_started_event.wait(timeout=timeout):
+            raise RuntimeError(f"{self.binding_name}: Event loop thread failed to start in time.")
+        if not self._loop or not self._loop.is_running():
+            raise RuntimeError(f"{self.binding_name}: Event loop is not running after start signal.")
+
+    def _run_async(self, coro, timeout=None):
+        if not self._loop or not self._loop.is_running(): 
+            raise RuntimeError("Event loop not running. This should have been caught earlier.")
         future = asyncio.run_coroutine_threadsafe(coro, self._loop)
         return future.result(timeout)
 
-    async def _initialize_connection_async(self) -> bool:
-        if self._is_initialized: return True
-        ASCIIColors.info(f"{self.binding_name}: Initializing connection to {self.server_url}...")
-        try:
-            self._exit_stack = AsyncExitStack()
-            
-            # --- Authentication Setup (Conceptual) ---
-            # oauth_provider = None
-            # if self.auth_config.get("type") == "oauth":
-            #     # oauth_provider = OAuthClientProvider(...) # Setup based on auth_config
-            #     pass
-            # http_headers = {}
-            # if self.auth_config.get("type") == "api_key":
-            #     key = self.auth_config.get("key")
-            #     header_name = self.auth_config.get("header_name", "X-API-Key")
-            #     if key: http_headers[header_name] = key
+    ### MODIFIED: Now operates on a specific server identified by alias
+    async def _initialize_connection_async(self, alias: str) -> bool:
+        server_info = self.servers[alias]
+        if server_info["initialized"]:
+            return True
             
-            # Use streamablehttp_client from MCP SDK
-            # The `auth` parameter of streamablehttp_client takes an OAuthClientProvider
-            # For simple API key headers, you might need to use `httpx` directly
-            # or see if streamablehttp_client allows passing custom headers.
-            # The MCP client example for streamable HTTP doesn't show custom headers directly,
-            # it focuses on OAuth.
-            # If `streamablehttp_client` takes `**kwargs` that are passed to `httpx.AsyncClient`,
-            # then `headers=http_headers` might work.
+        server_url = server_info["url"]
+        ASCIIColors.info(f"{self.binding_name}: Initializing connection to '{alias}' ({server_url})...")
+        try:
+            exit_stack = AsyncExitStack()
             
-            # Assuming streamablehttp_client can take headers if needed, or auth provider
-            # For now, let's assume no auth for simplicity or that it's handled by underlying httpx if passed via kwargs
-            client_streams = await self._exit_stack.enter_async_context(
-                streamablehttp_client(self.server_url) # Add auth=oauth_provider or headers=http_headers if supported
+            client_streams = await exit_stack.enter_async_context(
+                streamablehttp_client(server_url)
             )
-            read_stream, write_stream, _http_client_instance = client_streams # http_client_instance might be useful
+            read_stream, write_stream, _ = client_streams
 
-            self._mcp_session = await self._exit_stack.enter_async_context(
+            session = await exit_stack.enter_async_context(
                 ClientSession(read_stream, write_stream)
             )
-            await self._mcp_session.initialize()
-            self._is_initialized = True
-            ASCIIColors.green(f"{self.binding_name}: Connected to {self.server_url}")
-            await self._refresh_tools_cache_async()
+            await session.initialize()
+
+            # Update the state for this specific server
+            server_info["session"] = session
+            server_info["exit_stack"] = exit_stack
+            server_info["initialized"] = True
+
+            ASCIIColors.green(f"{self.binding_name}: Connected to '{alias}' ({server_url})")
             return True
         except Exception as e:
             trace_exception(e)
-            ASCIIColors.error(f"{self.binding_name}: Failed to connect to {self.server_url}: {e}")
-            if self._exit_stack: await self._exit_stack.aclose() # Cleanup on failure
-            self._exit_stack = None
-            self._mcp_session = None
-            self._is_initialized = False
+            ASCIIColors.error(f"{self.binding_name}: Failed to connect to '{alias}' ({server_url}): {e}")
+            if 'exit_stack' in locals() and exit_stack:
+                await exit_stack.aclose()
+            
+            # Reset state for this server on failure
+            server_info["session"] = None
+            server_info["exit_stack"] = None
+            server_info["initialized"] = False
             return False
 
-    def _ensure_initialized_sync(self, timeout=30.0):
-        if not self._is_initialized:
-            success = self._run_async(self._initialize_connection_async(), timeout=timeout)
-            if not success: raise ConnectionError(f"Failed to initialize remote MCP connection to {self.server_url}")
-        if not self._mcp_session: # Double check
-             raise ConnectionError(f"MCP Session not valid after init attempt for {self.server_url}")
+    ### MODIFIED: Ensures a specific server is initialized
+    def _ensure_initialized_sync(self, alias: str, timeout=30.0):
+        self._wait_for_loop() 
+        
+        server_info = self.servers.get(alias)
+        if not server_info:
+            raise ValueError(f"Unknown server alias: '{alias}'")
 
+        # Use a lock to prevent multiple threads trying to initialize the same server
+        with server_info["initializing_lock"]:
+            if not server_info["initialized"]:
+                success = self._run_async(self._initialize_connection_async(alias), timeout=timeout)
+                if not success:
+                    raise ConnectionError(f"Failed to initialize remote MCP connection to '{alias}' ({server_info['url']})")
+        
+        if not server_info.get("session"):
+             raise ConnectionError(f"MCP Session not valid after init attempt for '{alias}' ({server_info['url']})")
 
-    async def _refresh_tools_cache_async(self):
-        if not self._is_initialized or not self._mcp_session: return
-        ASCIIColors.info(f"{self.binding_name}: Refreshing tools from {self.server_url}...")
+    ### MODIFIED: Refreshes tools from ALL connected servers and aggregates them
+    async def _refresh_all_tools_cache_async(self):
+        ASCIIColors.info(f"{self.binding_name}: Refreshing tools from all servers...")
+        all_tools = []
+        # Create a list of tasks to run concurrently
+        refresh_tasks = [
+            self._fetch_tools_from_server_async(alias) for alias in self.servers.keys()
+        ]
+        
+        # Gather results from all tasks
+        results = await asyncio.gather(*refresh_tasks, return_exceptions=True)
+        
+        for result in results:
+            if isinstance(result, Exception):
+                # Error already logged inside the fetch function
+                continue
+            if result:
+                all_tools.extend(result)
+        
+        self._discovered_tools_cache = all_tools
+        ASCIIColors.green(f"{self.binding_name}: Tool refresh complete. Found {len(all_tools)} tools across all servers.")
+
+    ### NEW: Helper async function to fetch tools from a single server
+    async def _fetch_tools_from_server_async(self, alias: str) -> List[Dict[str, Any]]:
+        server_info = self.servers[alias]
+        if not server_info["initialized"] or not server_info["session"]:
+            ASCIIColors.debug(f"{self.binding_name}: Skipping tool refresh for non-initialized server '{alias}'.")
+            return []
+        
         try:
-            list_tools_result = await self._mcp_session.list_tools()
-            current_tools = []
-            # ... (tool parsing logic similar to StandardMCPBinding, but no server alias prefix needed if one server per binding instance)
+            list_tools_result = await server_info["session"].list_tools()
+            server_tools = []
             for tool_obj in list_tools_result.tools:
-                # ...
                 input_schema_dict = {}
                 tool_input_schema = getattr(tool_obj, 'inputSchema', getattr(tool_obj, 'input_schema', None))
                 if tool_input_schema:
@@ -156,86 +215,128 @@ class RemoteMCPBinding(LollmsMCPBinding):
                     elif isinstance(tool_input_schema, dict):
                         input_schema_dict = tool_input_schema
                 
-                tool_name_for_client = f"{self.alias}{TOOL_NAME_SEPARATOR}{tool_obj.name}" if TOOL_NAME_SEPARATOR else tool_obj.name
+                tool_name_for_client = f"{alias}{TOOL_NAME_SEPARATOR}{tool_obj.name}"
 
-                current_tools.append({
-                    "name": tool_name_for_client, # Use self.alias to prefix
+                server_tools.append({
+                    "name": tool_name_for_client,
                     "description": tool_obj.description or "",
                     "input_schema": input_schema_dict
                 })
-            self._discovered_tools_cache = current_tools
-            ASCIIColors.green(f"{self.binding_name}: Tools refreshed for {self.server_url}. Found {len(current_tools)} tools.")
+            ASCIIColors.info(f"{self.binding_name}: Found {len(server_tools)} tools on server '{alias}'.")
+            return server_tools
         except Exception as e:
             trace_exception(e)
-            ASCIIColors.error(f"{self.binding_name}: Error refreshing tools from {self.server_url}: {e}")
+            ASCIIColors.error(f"{self.binding_name}: Error refreshing tools from '{alias}': {e}")
+            return []
+
 
-    def discover_tools(self, force_refresh: bool = False, timeout_per_server: float = 10.0, **kwargs) -> List[Dict[str, Any]]:
-        # This binding instance connects to ONE server, so timeout_per_server is just 'timeout'
+    ### MODIFIED: Discovers tools from all configured servers
+    def discover_tools(self, force_refresh: bool = False, timeout_per_server: float = 30.0, **kwargs) -> List[Dict[str, Any]]:
+        if not self.servers:
+            return []
+
+        # Initialize all servers that are not yet initialized.
+        for alias in self.servers.keys():
+            try:
+                # _ensure_initialized_sync is internally locked and idempotent
+                self._ensure_initialized_sync(alias, timeout=timeout_per_server)
+            except Exception as e:
+                # One server failing to connect shouldn't stop discovery on others.
+                ASCIIColors.warning(f"{self.binding_name}: Could not ensure connection to '{alias}' for discovery: {e}")
+        
         try:
-            self._ensure_initialized_sync(timeout=timeout_per_server)
             if force_refresh or not self._discovered_tools_cache:
-                self._run_async(self._refresh_tools_cache_async(), timeout=timeout_per_server)
+                # The timeout for refreshing all tools should be longer
+                self._run_async(self._refresh_all_tools_cache_async(), timeout=timeout_per_server * len(self.servers))
             return self._discovered_tools_cache
         except Exception as e:
-            ASCIIColors.error(f"{self.binding_name}: Problem during tool discovery for {self.server_url}: {e}")
+            trace_exception(e)
+            ASCIIColors.error(f"{self.binding_name}: Problem during tool discovery: {e}")
             return []
             
-    async def _execute_tool_async(self, actual_tool_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
-        if not self._is_initialized or not self._mcp_session:
-            return {"error": f"Not connected to {self.server_url}", "status_code": 503}
+    ### MODIFIED: Now operates on a specific server identified by alias
+    async def _execute_tool_async(self, alias: str, actual_tool_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        server_info = self.servers[alias]
+        server_url = server_info["url"]
         
-        ASCIIColors.info(f"{self.binding_name}: Executing remote tool '{actual_tool_name}' on {self.server_url} with params: {json.dumps(params)}")
+        if not server_info["initialized"] or not server_info["session"]:
+            return {"error": f"Not connected to server '{alias}' ({server_url})", "status_code": 503}
+        
+        ASCIIColors.info(f"{self.binding_name}: Executing remote tool '{actual_tool_name}' on '{alias}' ({server_url}) with params: {json.dumps(params)}")
         try:
-            mcp_call_result = await self._mcp_session.call_tool(name=actual_tool_name, arguments=params)
-            # ... (result parsing as in StandardMCPBinding) ...
+            mcp_call_result = await server_info["session"].call_tool(name=actual_tool_name, arguments=params)
             output_parts = [p.text for p in mcp_call_result.content if isinstance(p, types.TextContent) and p.text is not None] if mcp_call_result.content else []
             if not output_parts: return {"output": {"message": "Tool executed but returned no textual content."}, "status_code": 200}
+            
             combined_output_str = "\n".join(output_parts)
-            try: return {"output": json.loads(combined_output_str), "status_code": 200}
-            except json.JSONDecodeError: return {"output": combined_output_str, "status_code": 200}
+            try:
+                return {"output": json.loads(combined_output_str), "status_code": 200}
+            except json.JSONDecodeError:
+                return {"output": combined_output_str, "status_code": 200}
         except Exception as e:
             trace_exception(e)
-            return {"error": f"Error executing remote tool '{actual_tool_name}': {str(e)}", "status_code": 500}
-
+            return {"error": f"Error executing remote tool '{actual_tool_name}' on '{alias}': {str(e)}", "status_code": 500}
 
+    ### MODIFIED: Parses alias from tool name and routes the call
     def execute_tool(self, tool_name_with_alias: str, params: Dict[str, Any], **kwargs) -> Dict[str, Any]:
         timeout = float(kwargs.get('timeout', 60.0))
         
-        # If using alias prefixing (self.alias + TOOL_NAME_SEPARATOR + actual_name)
-        expected_prefix = f"{self.alias}{TOOL_NAME_SEPARATOR}"
-        if TOOL_NAME_SEPARATOR and tool_name_with_alias.startswith(expected_prefix):
-            actual_tool_name = tool_name_with_alias[len(expected_prefix):]
-        elif not TOOL_NAME_SEPARATOR and tool_name_with_alias: # No prefixing, tool_name is actual_tool_name
-             actual_tool_name = tool_name_with_alias
-        else:
-            return {"error": f"Tool name '{tool_name_with_alias}' does not match expected alias '{self.alias}'.", "status_code": 400}
+        if TOOL_NAME_SEPARATOR not in tool_name_with_alias:
+            return {"error": f"Invalid tool name format. Expected 'alias{TOOL_NAME_SEPARATOR}tool_name', but got '{tool_name_with_alias}'.", "status_code": 400}
+
+        alias, actual_tool_name = tool_name_with_alias.split(TOOL_NAME_SEPARATOR, 1)
+
+        if alias not in self.servers:
+            return {"error": f"Tool name '{tool_name_with_alias}' has an unknown server alias '{alias}'.", "status_code": 400}
 
         try:
-            self._ensure_initialized_sync(timeout=min(timeout, 30.0))
-            return self._run_async(self._execute_tool_async(actual_tool_name, params), timeout=timeout)
-        # ... (error handling as in StandardMCPBinding) ...
-        except ConnectionError as e: return {"error": f"{self.binding_name}: Connection issue for '{self.server_url}': {e}", "status_code": 503}
-        except TimeoutError: return {"error": f"{self.binding_name}: Remote tool '{actual_tool_name}' on '{self.server_url}' timed out.", "status_code": 504}
+            # Ensure this specific server is connected before executing
+            self._ensure_initialized_sync(alias, timeout=min(timeout, 30.0))
+            return self._run_async(self._execute_tool_async(alias, actual_tool_name, params), timeout=timeout)
+        except (ConnectionError, RuntimeError) as e:
+            return {"error": f"{self.binding_name}: Connection issue for server '{alias}': {e}", "status_code": 503}
+        except TimeoutError:
+            return {"error": f"{self.binding_name}: Remote tool '{actual_tool_name}' on '{alias}' timed out.", "status_code": 504}
         except Exception as e:
             trace_exception(e)
-            return {"error": f"{self.binding_name}: Failed to run remote MCP tool '{actual_tool_name}': {e}", "status_code": 500}
+            return {"error": f"{self.binding_name}: Failed to run remote MCP tool '{actual_tool_name}' on '{alias}': {e}", "status_code": 500}
 
+    ### MODIFIED: Closes all connections
     def close(self):
-        ASCIIColors.info(f"{self.binding_name}: Closing connection to {self.server_url}...")
-        if self._exit_stack:
+        ASCIIColors.info(f"{self.binding_name}: Closing all remote connections...")
+        
+        async def _close_all_connections():
+            close_tasks = []
+            for alias, server_info in self.servers.items():
+                if server_info.get("exit_stack"):
+                    ASCIIColors.info(f"{self.binding_name}: Closing connection to '{alias}'...")
+                    close_tasks.append(server_info["exit_stack"].aclose())
+            
+            if close_tasks:
+                await asyncio.gather(*close_tasks, return_exceptions=True)
+
+        # Check if loop is running before trying to schedule work on it
+        if self._loop and self._loop.is_running():
             try:
-                # The anyio task error might also occur here if not careful
-                self._run_async(self._exit_stack.aclose(), timeout=10.0)
+                self._run_async(_close_all_connections(), timeout=10.0)
             except Exception as e:
-                ASCIIColors.error(f"{self.binding_name}: Error during async close for {self.server_url}: {e}")
-        self._exit_stack = None
-        self._mcp_session = None
-        self._is_initialized = False
+                ASCIIColors.error(f"{self.binding_name}: Error during async close: {e}")
+        
+        # Reset all server states
+        for alias in self.servers:
+            self.servers[alias].update({
+                "exit_stack": None,
+                "session": None,
+                "initialized": False
+            })
         
-        # Stop event loop thread
-        if self._loop and self._loop.is_running(): self._loop.call_soon_threadsafe(self._loop.stop)
-        if self._thread and self._thread.is_alive(): self._thread.join(timeout=5.0)
+        if self._loop and self._loop.is_running():
+            self._loop.call_soon_threadsafe(self._loop.stop)
+        
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5.0)
+
         ASCIIColors.info(f"{self.binding_name}: Remote connection binding closed.")
 
-    def get_binding_config(self) -> Dict[str, Any]: # LollmsMCPBinding might expect this
+    def get_binding_config(self) -> Dict[str, Any]:
         return self.config

{lollms_client-0.20.3.dist-info → lollms_client-0.20.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.20.3
+Version: 0.20.6
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License

{lollms_client-0.20.3.dist-info → lollms_client-0.20.6.dist-info}/RECORD

@@ -2,9 +2,11 @@ examples/external_mcp.py,sha256=swx1KCOz6jk8jGTAycq-xu7GXPAhRMDe1x--SKocugE,1337
 examples/function_calling_with_local_custom_mcp.py,sha256=g6wOFRB8-p9Cv7hKmQaGzPvtMX3H77gas01QVNEOduM,12407
 examples/generate_a_benchmark_for_safe_store.py,sha256=bkSt0mrpNsN0krZAUShm0jgVM1ukrPpjI7VwSgcNdSA,3974
 examples/generate_text_with_multihop_rag_example.py,sha256=riEyVYo97r6ZYdySL-NJkRhE4MnpwbZku1sN8RNvbvs,11519
-examples/internet_search_with_rag.py,sha256=cbUoGgY3rxZpQ5INoaA0Nhm0cutii-2AQ9WCz71Ch3o,12369
+examples/gradio_chat_app.py,sha256=ZZ_D1U0wvvwE9THmAPXUvNKkFG2gi7tQq1f2pQx_2ug,15315
+examples/internet_search_with_rag.py,sha256=ioTb_WI2M6kFeh1Dg-EGcKjccphnCsIGD_e9PZgZshw,12314
 examples/local_mcp.py,sha256=w40dgayvHYe01yvekEE0LjcbkpwKjWwJ-9v4_wGYsUk,9113
 examples/openai_mcp.py,sha256=7IEnPGPXZgYZyiES_VaUbQ6viQjenpcUxGiHE-pGeFY,11060
+examples/run_remote_mcp_example copy.py,sha256=pGT8A5iXK9oHtjGNEUCm8fnj9DQ37gcznjLYqAEI20o,10075
 examples/run_standard_mcp_example.py,sha256=GSZpaACPf3mDPsjA8esBQVUsIi7owI39ca5avsmvCxA,9419
 examples/simple_text_gen_test.py,sha256=RoX9ZKJjGMujeep60wh5WT_GoBn0O9YKJY6WOy-ZmOc,8710
 examples/simple_text_gen_with_image_test.py,sha256=rR1O5Prcb52UHtJ3c6bv7VuTd1cvbkr5aNZU-v-Rs3Y,9263
@@ -23,12 +25,12 @@ examples/personality_test/chat_test.py,sha256=o2jlpoddFc-T592iqAiA29xk3x27KsdK5D
 examples/personality_test/chat_with_aristotle.py,sha256=4X_fwubMpd0Eq2rCReS2bgVlUoAqJprjkLXk2Jz6pXU,1774
 examples/personality_test/tesks_test.py,sha256=7LIiwrEbva9WWZOLi34fsmCBN__RZbPpxoUOKA_AtYk,1924
 examples/test_local_models/local_chat.py,sha256=slakja2zaHOEAUsn2tn_VmI4kLx6luLBrPqAeaNsix8,456
-lollms_client/__init__.py,sha256=wRi23qidXTyMK09HNTzeoYEMKhB_7ZImWScltfYgntE,910
+lollms_client/__init__.py,sha256=Q12uBDAS5nze6N8vwIoOrzdr5UQC1wogoKmgO31q2uk,912
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=iKvH20tckzdYLlIpp-srWswdI4lb0vo5po7xo3Ogsgk,114865
-lollms_client/lollms_discussion.py,sha256=EV90dIgw8a-f-82vB2GspR60RniYz7WnBmAWSIg5mW0,2158
+lollms_client/lollms_core.py,sha256=Jr9VQCvyxtsdy3VstNjOOoMCx4uS50VHSzaFuyu754o,118714
+lollms_client/lollms_discussion.py,sha256=9QcmDIlzozgBWWuZK2EF0VlK6l3JYCxDfeXaf_KxkBA,20974
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
-lollms_client/lollms_llm_binding.py,sha256=bdElz_IBx0zZ-85YTT1fyY_mSoHo46tKIMiHYJlKCkM,9809
+lollms_client/lollms_llm_binding.py,sha256=E81g4yBlQn76WTSLicnTETJuQhf_WZUMZaxotgRnOcA,12096
 lollms_client/lollms_mcp_binding.py,sha256=0rK9HQCBEGryNc8ApBmtOlhKE1Yfn7X7xIQssXxS2Zc,8933
 lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_KonOMsADASxc,10246
 lollms_client/lollms_stt_binding.py,sha256=jAUhLouEhh2hmm1bK76ianfw_6B59EHfY3FmLv6DU-g,5111
@@ -39,10 +41,10 @@ lollms_client/lollms_ttv_binding.py,sha256=KkTaHLBhEEdt4sSVBlbwr5i_g_TlhcrwrT-7D
 lollms_client/lollms_types.py,sha256=CLiodudFgTbuXTGgupDt6IgMvJkrfiOHdw1clx_5UjA,2863
 lollms_client/lollms_utilities.py,sha256=WiG-HHMdo86j3LBndcBQ-PbMqQ8kGKLp1e9WuLDzRVU,7048
 lollms_client/llm_bindings/__init__.py,sha256=9sWGpmWSSj6KQ8H4lKGCjpLYwhnVdL_2N7gXCphPqh4,14
-lollms_client/llm_bindings/llamacpp/__init__.py,sha256=tUdCh00Tcg2VtavM5uRNsAoEkdeHI4p3nFsF9YUcYuk,58402
-lollms_client/llm_bindings/lollms/__init__.py,sha256=poGr9H3UshRUqmiAiiRW8_1Q8rBj3Q-mhBacdnp7C7Y,13157
-lollms_client/llm_bindings/ollama/__init__.py,sha256=8Kn8OI0PcT8QWVv5w7NDcsP99AvQ9TKMj-1VL3DZLfU,27770
-lollms_client/llm_bindings/openai/__init__.py,sha256=IGvsWbI0uw6x04IQ7u4GAM1AaVFSendLjkbKvjQ6-AM,13993
+lollms_client/llm_bindings/llamacpp/__init__.py,sha256=Qj5RvsgPeHGNfb5AEwZSzFwAp4BOWjyxmm9qBNtstrc,63716
+lollms_client/llm_bindings/lollms/__init__.py,sha256=17TwGMDJMxRPjZjZZSysR8AwjMXZeRfDBy8RqWWuaIY,17769
+lollms_client/llm_bindings/ollama/__init__.py,sha256=fno1UEcXIy37Z3-bZAwOMuCfbAYOzztcO4oBfLqK_JA,32538
+lollms_client/llm_bindings/openai/__init__.py,sha256=ay_2JJi4La258Eg3alUhnh6Y5IRyOWnHaFLXqvN_4ao,19144
 lollms_client/llm_bindings/openllm/__init__.py,sha256=xv2XDhJNCYe6NPnWBboDs24AQ1VJBOzsTuMcmuQ6xYY,29864
 lollms_client/llm_bindings/pythonllamacpp/__init__.py,sha256=7dM42TCGKh0eV0njNL1tc9cInhyvBRIXzN3dcy12Gl0,33551
 lollms_client/llm_bindings/tensor_rt/__init__.py,sha256=nPaNhGRd-bsG0UlYwcEqjd_UagCMEf5VEbBUW-GWu6A,32203
@@ -53,7 +55,7 @@ lollms_client/mcp_bindings/local_mcp/default_tools/file_writer/file_writer.py,sh
 lollms_client/mcp_bindings/local_mcp/default_tools/generate_image_from_prompt/generate_image_from_prompt.py,sha256=THtZsMxNnXZiBdkwoBlfbWY2C5hhDdmPtnM-8cSKN6s,9488
 lollms_client/mcp_bindings/local_mcp/default_tools/internet_search/internet_search.py,sha256=PLC31-D04QKTOTb1uuCHnrAlpysQjsk89yIJngK0VGc,4586
 lollms_client/mcp_bindings/local_mcp/default_tools/python_interpreter/python_interpreter.py,sha256=McDCBVoVrMDYgU7EYtyOY7mCk1uEeTea0PSD69QqDsQ,6228
-lollms_client/mcp_bindings/remote_mcp/__init__.py,sha256=L7J_CvpF5ydu_eBVNuxUPViedDgI5jbSqPSy8rQTtYU,13170
+lollms_client/mcp_bindings/remote_mcp/__init__.py,sha256=2oSVcOvW6XkAIfZvCNmwc1dSwrZ4hTZF8mntauM7YnU,16482
 lollms_client/mcp_bindings/standard_mcp/__init__.py,sha256=zpF4h8cTUxoERI-xcVjmS_V772LK0V4jegjz2k1PK98,31658
 lollms_client/stt_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/stt_bindings/lollms/__init__.py,sha256=jBz3285atdPRqQe9ZRrb-AvjqKRB4f8tjLXjma0DLfE,6082
@@ -75,8 +77,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.20.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.20.3.dist-info/METADATA,sha256=ShF3nPm1Y3KT9UkJ_3zkA8BudOb8O-zNn9iuo3KxCe4,13374
-lollms_client-0.20.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.20.3.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.20.3.dist-info/RECORD,,
+lollms_client-0.20.6.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.20.6.dist-info/METADATA,sha256=NG_lJ-ZX3YXxjvMYclHkNPI4aKvheU8CvcDR9gkqY6I,13374
+lollms_client-0.20.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.20.6.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.20.6.dist-info/RECORD,,