lollms-client 0.19.5__tar.gz → 0.19.7__tar.gz

{lollms_client-0.19.5/lollms_client.egg-info → lollms_client-0.19.7}/PKG-INFO

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

lollms_client-0.19.7/examples/internet_search_with_rag.py

@@ -0,0 +1,228 @@
+from lollms_client import LollmsClient, MSG_TYPE
+from ascii_colors import ASCIIColors, trace_exception
+from typing import List, Dict, Any, Optional, Callable
+import json
+from pathlib import Path
+
+# --- Internet Search RAG Implementation ---
+_duckduckgo_search_installed = False
+_search_installation_error_message = ""
+try:
+    import pipmaster as pm
+    # ensure_packages should be called by the binding init ideally,
+    # but we call it here for the example's standalone execution.
+    pm.ensure_packages(["duckduckgo_search"]) 
+    from duckduckgo_search import DDGS
+    _duckduckgo_search_installed = True
+except Exception as e:
+    _search_installation_error_message = str(e)
+    DDGS = None
+    ASCIIColors.error(f"Failed to import duckduckgo_search: {_search_installation_error_message}")
+    ASCIIColors.info("Please install it: pip install duckduckgo-search")
+
+
+def perform_internet_search_rag(
+    query_text: str,
+    vectorizer_name: Optional[str] = None, # Not used for search
+    top_k: int = 5,
+    min_similarity_percent: float = 0.0 # Not used directly for search filter, but can influence result quality/rank
+) -> List[Dict[str, Any]]:
+    """
+    Performs an internet search using DuckDuckGo and formats results for RAG.
+    Similarity is simulated based on rank.
+    """
+    if not _duckduckgo_search_installed or DDGS is None:
+         ASCIIColors.error("duckduckgo_search is not available. Cannot perform internet search.")
+         return []
+
+    ASCIIColors.magenta(f"  [INTERNET SEARCH] Querying DuckDuckGo for: '{query_text}', max_results={top_k}")
+    search_results_raw = []
+    try:
+        # DDGS().text returns a generator, max_results limits it.
+        # Note: The DDGS library might sometimes return fewer results than max_results.
+        with DDGS() as ddgs:
+            search_results_raw = list(ddgs.text(keywords=query_text, max_results=top_k))
+            
+    except Exception as e:
+        ASCIIColors.error(f"  [INTERNET SEARCH] Search failed: {e}")
+        trace_exception(e)
+        return []
+
+    formatted_results: List[Dict[str, Any]] = []
+    if search_results_raw:
+        for i, r in enumerate(search_results_raw):
+            # Simulate similarity based on rank (rank 1 is highest sim)
+            # Max similarity is 100% for rank 1, decreases linearly or non-linearly.
+            # Simple linear decrease: 100 - (rank * (100 / top_k+1))
+            # Let's use rank-based score: 100% for rank 1, 90% for rank 2, ... 50% for rank 5 etc.
+            # Ensure similarity is above min_similarity_percent if that param was intended as a filter here
+            
+            simulated_similarity = max(0.0, 100.0 - i * (100.0 / (top_k + 1))) # Higher rank = lower sim
+            simulated_similarity = round(simulated_similarity, 2)
+
+            if simulated_similarity >= min_similarity_percent:
+                formatted_results.append({
+                    "file_path": r.get("href", "# Unknown URL"), # Use URL as document identifier
+                    "chunk_text": f"Title: {r.get('title', 'N/A')}\nSnippet: {r.get('body', 'N/A')}", # Combine title and snippet
+                    "similarity_percent": simulated_similarity,
+                })
+            else:
+                 ASCIIColors.debug(f"  [INTERNET SEARCH] Skipping result {i+1} due to low simulated similarity ({simulated_similarity}%)")
+
+    ASCIIColors.magenta(f"  [INTERNET SEARCH] Formatted {len(formatted_results)} results for RAG.")
+    if not formatted_results: ASCIIColors.yellow(f"  [INTERNET SEARCH] No results found for query: '{query_text}' or none met min_similarity_percent.")
+    return formatted_results
+
+# --- Streaming Callback for RAG and LLM ---
+def rag_streaming_callback(
+    chunk: str, 
+    msg_type: MSG_TYPE, 
+    metadata: Optional[Dict] = None, 
+    turn_history: Optional[List] = None
+) -> bool:
+    metadata = metadata or {}
+    hop = metadata.get("hop", "")
+    type_info = metadata.get("type", "N/A")
+
+    if msg_type == MSG_TYPE.MSG_TYPE_CHUNK: # Final answer chunks
+        ASCIIColors.success(chunk, end="", flush=True)
+    elif msg_type == MSG_TYPE.MSG_TYPE_STEP_START:
+        info = metadata.get("query", chunk) if type_info in ["rag_query_generation", "rag_retrieval"] else chunk
+        ASCIIColors.yellow(f"\n>> RAG Hop {hop} | START | {type_info.upper()} | Info: {str(info)[:100]}...", flush=True)
+    elif msg_type == MSG_TYPE.MSG_TYPE_STEP_END:
+        num_chunks = metadata.get("num_chunks")
+        query = metadata.get("query")
+        decision = metadata.get("decision")
+        
+        end_info = []
+        if query: end_info.append(f"Query: '{str(query)[:50]}...'")
+        if num_chunks is not None: end_info.append(f"Results: {num_chunks}")
+        if decision: end_info.append(f"LLM Decision: NeedMore={decision.get('need_more_data')}, Summary: '{str(decision.get('new_information_summary'))[:50]}...'")
+        
+        ASCIIColors.green(f"\n<< RAG Hop {hop} | END   | {type_info.upper()} | {' | '.join(end_info) if end_info else chunk}", flush=True)
+    elif msg_type == MSG_TYPE.MSG_TYPE_EXCEPTION:
+        ASCIIColors.error(f"\nError in RAG stream: {chunk}", flush=True)
+    
+    return True
+
+# --- Main Example ---
+if __name__ == "__main__":
+    ASCIIColors.red("--- Multi-Hop Internet Search Example with LollmsClient ---")
+
+    # LLM Configuration (use a model good at instruction following and JSON)
+    # Ensure your Ollama server is running and has this model pulled.
+    LLM_BINDING_NAME = "ollama"
+    LLM_MODEL_NAME = "mistral:latest" # or llama3, phi3 etc.
+
+    # You could also enable the internet_search tool via MCP,
+    # but this example specifically uses it directly via generate_text_with_rag.
+    # For MCP example, see examples/local_mcp.py
+
+    try:
+        lc = LollmsClient(
+            binding_name=LLM_BINDING_NAME,
+            model_name=LLM_MODEL_NAME,
+            temperature=0.1,
+            ctx_size=4096 
+        )
+        ASCIIColors.green(f"LollmsClient initialized with LLM: {LLM_BINDING_NAME}/{LLM_MODEL_NAME}")
+
+        if not _duckduckgo_search_installed or DDGS is None:
+             ASCIIColors.error("duckduckgo_search is not installed. Cannot run search examples.")
+             exit()
+
+
+        # --- Test Case 1: Classic Search RAG (max_rag_hops = 0) ---
+        ASCIIColors.cyan("\n\n--- Test Case 1: Classic Internet Search RAG (max_rag_hops = 0) ---")
+        classic_search_prompt = "What is the current population of Japan?"
+        ASCIIColors.blue(f"User Prompt: {classic_search_prompt}")
+
+        classic_rag_result = lc.generate_text_with_rag(
+            prompt=classic_search_prompt,
+            rag_query_function=perform_internet_search_rag, # Use the search function
+            max_rag_hops=0,
+            rag_top_k=3, # Get 3 search results
+            rag_min_similarity_percent=50.0, # Only use results with simulated sim >= 50%
+            streaming_callback=rag_streaming_callback,
+            n_predict=250
+        )
+        print("\n--- End of Classic Search RAG ---")
+        ASCIIColors.magenta("\nClassic Search RAG Final Output Structure:")
+        print(f"  Final Answer (first 100 chars): {classic_rag_result.get('final_answer', '')[:100]}...")
+        print(f"  Error: {classic_rag_result.get('error')}")
+        print(f"  Number of Hops: {len(classic_rag_result.get('rag_hops_history', []))}")
+        print(f"  Total Unique Sources Retrieved: {len(classic_rag_result.get('all_retrieved_sources', []))}")
+        if classic_rag_result.get('all_retrieved_sources'):
+            print("  Example Retrieved Source:")
+            source_ex = classic_rag_result['all_retrieved_sources'][0]
+            print(f"    Document (URL): {source_ex.get('document')}")
+            print(f"    Similarity: {source_ex.get('similarity')}%")
+            print(f"    Content (Snippet, first 50 chars): {source_ex.get('content', '')[:50]}...")
+
+
+        # --- Test Case 2: Multi-Hop Search RAG (max_rag_hops = 1) ---
+        ASCIIColors.cyan("\n\n--- Test Case 2: Multi-Hop Internet Search RAG (max_rag_hops = 1) ---")
+        multihop_search_prompt_1 = "Tell me about the latest developments in fusion energy, including any recent news."
+        ASCIIColors.blue(f"User Prompt: {multihop_search_prompt_1}")
+
+        multihop_rag_result_1 = lc.generate_text_with_rag(
+            prompt=multihop_search_prompt_1,
+            rag_query_function=perform_internet_search_rag,
+            rag_query_text=None, # LLM will generate first query
+            max_rag_hops=1, # Allow one refinement hop
+            rag_top_k=2, # Get 2 search results per query
+            rag_min_similarity_percent=50.0,
+            streaming_callback=rag_streaming_callback,
+            n_predict=400,
+            rag_hop_query_generation_temperature=0.1, 
+            rag_hop_summary_temperature=0.2 
+        )
+        print("\n--- End of Multi-Hop Search RAG (1 hop max) ---")
+        ASCIIColors.magenta("\nMulti-Hop Search RAG (1 hop max) Final Output Structure:")
+        print(f"  Final Answer (first 100 chars): {multihop_rag_result_1.get('final_answer', '')[:100]}...")
+        print(f"  Error: {multihop_rag_result_1.get('error')}")
+        print(f"  Number of Hops Made: {len(multihop_rag_result_1.get('rag_hops_history', []))}")
+        for i, hop_info in enumerate(multihop_rag_result_1.get('rag_hops_history', [])):
+            print(f"    Hop {i+1} Query: '{hop_info.get('query')}'")
+            print(f"    Hop {i+1} Results Count: {len(hop_info.get('retrieved_chunks_details',[]))}")
+            print(f"    Hop {i+1} Summary (first 50): '{str(hop_info.get('new_information_summary'))[:50]}...'")
+            print(f"    Hop {i+1} LLM Decision: NeedMoreData={hop_info.get('llm_decision_json',{}).get('need_more_data')}")
+        print(f"  Total Unique Sources Retrieved: {len(multihop_rag_result_1.get('all_retrieved_sources', []))}")
+
+
+        # --- Test Case 3: More complex multi-hop (max_rag_hops = 2) ---
+        ASCIIColors.cyan("\n\n--- Test Case 3: More Complex Multi-Hop Internet Search RAG (max_rag_hops = 2) ---")
+        multihop_search_prompt_2 = "What are the requirements and steps to install the lollms_client python library, and what are some of its key features?"
+        ASCIIColors.blue(f"User Prompt: {multihop_search_prompt_2}")
+
+        multihop_rag_result_2 = lc.generate_text_with_rag(
+            prompt=multihop_search_prompt_2,
+            rag_query_function=perform_internet_search_rag,
+            max_rag_hops=2, # Allow up to two refinement hops
+            rag_top_k=2, # Get 2 results per query
+            rag_min_similarity_percent=40.0, # Lower similarity to maybe get broader initial results
+            streaming_callback=rag_streaming_callback,
+            n_predict=500 # Allow more for the installation steps and features
+        )
+        print("\n--- End of More Complex Multi-Hop Search RAG (up to 2 hops) ---")
+        ASCIIColors.magenta("\nMore Complex Multi-Hop Search RAG (up to 2 hops) Final Output Structure:")
+        print(f"  Final Answer (first 100 chars): {multihop_rag_result_2.get('final_answer', '')[:100]}...")
+        print(f"  Error: {multihop_rag_result_2.get('error')}")
+        print(f"  Number of Hops Made: {len(multihop_rag_result_2.get('rag_hops_history', []))}")
+        for i, hop_info in enumerate(multihop_rag_result_2.get('rag_hops_history', [])):
+            print(f"    Hop {i+1} Query: '{hop_info.get('query')}'")
+            print(f"    Hop {i+1} Results Count: {len(hop_info.get('retrieved_chunks_details',[]))}")
+            print(f"    Hop {i+1} Summary (first 50): '{str(hop_info.get('new_information_summary'))[:50]}...'")
+        print(f"  Total Unique Sources Retrieved: {len(multihop_rag_result_2.get('all_retrieved_sources', []))}")
+
+
+    except ValueError as ve:
+        ASCIIColors.error(f"Initialization or RAG parameter error: {ve}")
+        trace_exception(ve)
+    except ConnectionRefusedError:
+        ASCIIColors.error(f"Connection refused. Is the Ollama server ({LLM_BINDING_NAME}) running?")
+    except Exception as e:
+        ASCIIColors.error(f"An unexpected error occurred: {e}")
+        trace_exception(e)
+
+    ASCIIColors.red("\n--- Multi-Hop Internet Search Example Finished ---")

{lollms_client-0.19.5 → lollms_client-0.19.7}/lollms_client/__init__.py

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

{lollms_client-0.19.5 → lollms_client-0.19.7}/lollms_client/lollms_core.py

@@ -853,8 +853,6 @@ Respond with a JSON object containing ONE of the following structures:
         turn_history.append({"type":"final_answer_generated", "content":final_answer_text})
         return {"final_answer": final_answer_text, "tool_calls": tool_calls_made_this_turn, "error": None}
 
-    # --- RAG ---
-    
     def generate_text_with_rag(
         self,
         prompt: str,
@@ -878,16 +876,17 @@ Respond with a JSON object containing ONE of the following structures:
         ctx_size: int | None = None,
         streaming_callback: Optional[Callable[[str, MSG_TYPE, Optional[Dict], Optional[List]], bool]] = None,
         rag_hop_query_generation_temperature: float = 0.2,
-        rag_hop_summary_temperature: float = 0.3,
+        # rag_hop_summary_temperature is no longer needed
+        max_rag_context_characters: int = 32000,
         **llm_generation_kwargs
     ) -> Dict[str, Any]:
         if not self.binding:
             return {"final_answer": "", "rag_hops_history": [], "all_retrieved_sources": [], "error": "LLM binding not initialized."}
 
         turn_rag_history_for_callback: List[Dict[str, Any]] = []
-        accumulated_rag_context_str = ""
         rag_hops_details_list: List[Dict[str, Any]] = []
-        all_unique_retrieved_chunks_map: Dict[str, Dict[str, Any]] = {} # To store unique chunks by content hash or path+text
+        # Stores all unique chunks with their full details, keyed by a unique identifier (e.g., path + content hash snippet)
+        all_unique_retrieved_chunks_map: Dict[str, Dict[str, Any]] = {}
         current_query_for_rag = rag_query_text
         original_user_prompt = prompt
 
@@ -896,205 +895,204 @@ Respond with a JSON object containing ONE of the following structures:
                 streaming_callback(f"Starting RAG Hop {hop_count + 1}", MSG_TYPE.MSG_TYPE_STEP, {"type": "rag_hop_start", "hop": hop_count + 1}, turn_rag_history_for_callback)
 
             # 1. Determine/Generate RAG Query Text
-            if hop_count > 0 or (current_query_for_rag is None and max_rag_hops > 0):
+            if hop_count > 0: # Query generation for multi-hop (hop 2 onwards)
                 if streaming_callback:
                     streaming_callback("LLM generating refined RAG query...", MSG_TYPE.MSG_TYPE_STEP_START, {"type": "rag_query_generation", "hop": hop_count + 1}, turn_rag_history_for_callback)
                 
+                system_prompt_q_gen = "You are an expert research assistant. Your task is to formulate the best possible *new* search query to find additional information relevant to the user's original request, considering previous search attempts."
                 query_gen_prompt_parts = [
-                    f"{self.system_full_header}You are an expert research assistant. Your task is to formulate the best possible search query to find information relevant to the user's original request, considering the information already gathered.",
-                    f"{self.user_full_header}Original user request: '{original_user_prompt}'"
+                    f"Original user request:\n'{original_user_prompt}'"
                 ]
-                if accumulated_rag_context_str:
-                    query_gen_prompt_parts.append(f"Information gathered so far (summaries):\n{accumulated_rag_context_str}")
                 if rag_hops_details_list:
-                    query_gen_prompt_parts.append("Previous search attempts and their summarized findings:")
-                    for prev_hop in rag_hops_details_list:
-                        query_gen_prompt_parts.append(f"  - Queried for: '{prev_hop['query']}', Summary: '{prev_hop.get('new_information_summary', 'N/A')}'")
+                    query_gen_prompt_parts.append("\nPrevious search queries and number of chunks found:")
+                    for i, prev_hop in enumerate(rag_hops_details_list):
+                        num_chunks_found_in_hop = len(prev_hop.get("retrieved_chunks_details", []))
+                        query_gen_prompt_parts.append(f"  - Query {i+1}: '{prev_hop['query']}' (Found {num_chunks_found_in_hop} chunks)")
                 
-                query_gen_prompt_parts.append("Based on this, what is the most effective and specific search query to perform next to get closer to answering the user's request? Output only the search query text, nothing else.")
+                query_gen_prompt_parts.append("\nBased on the original request and the queries already attempted, what is the most effective and specific *new* search query to perform next to get closer to answering the user's request? The query should aim to find information not likely covered by previous queries. Output only the search query text, nothing else.")
                 query_gen_prompt_parts.append(self.ai_full_header)
 
-                new_query_text_raw = self.remove_thinking_blocks(self.generate_text(prompt="".join(query_gen_prompt_parts), temperature=rag_hop_query_generation_temperature, n_predict=100, stream=False))
+                new_query_text_raw = self.generate_text(
+                    prompt="".join(query_gen_prompt_parts), 
+                    system_prompt=system_prompt_q_gen, 
+                    temperature=rag_hop_query_generation_temperature, 
+                    n_predict=100, 
+                    stream=False
+                )
+                
                 if isinstance(new_query_text_raw, dict) and "error" in new_query_text_raw:
-                    return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": f"Failed to generate RAG query: {new_query_text_raw['error']}"}
+                    return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": f"Failed to generate RAG query for hop {hop_count + 1}: {new_query_text_raw['error']}"}
                 
-                current_query_for_rag = new_query_text_raw.strip().replace("Search query:", "").replace("Query:", "").strip("\"'")
+                current_query_for_rag = self.remove_thinking_blocks(new_query_text_raw).strip().replace("Search query:", "").replace("Query:", "").strip("\"'")
                 
                 if streaming_callback:
-                    streaming_callback(f"Generated RAG query: {current_query_for_rag}", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "rag_query_generation", "hop": hop_count + 1, "query": current_query_for_rag}, turn_rag_history_for_callback)
-            
-            elif current_query_for_rag is None and max_rag_hops == 0:
+                    streaming_callback(f"Generated RAG query for hop {hop_count + 1}: {current_query_for_rag}", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "rag_query_generation", "hop": hop_count + 1, "query": current_query_for_rag}, turn_rag_history_for_callback)
+
+            elif current_query_for_rag is None: # First hop, and no rag_query_text provided
                 current_query_for_rag = original_user_prompt
+            
+            # If current_query_for_rag was provided as an argument, it's used for the first hop.
 
             if not current_query_for_rag:
-                if max_rag_hops > 0 and hop_count < max_rag_hops:
-                    ASCIIColors.warning(f"RAG Hop {hop_count + 1}: Generated query was empty. Skipping hop.")
-                    rag_hops_details_list.append({"query": "EMPTY_QUERY_SKIPPED", "retrieved_chunks_details": [], "new_information_summary": "Skipped due to empty query.", "llm_decision_json": {"need_more_data": True if hop_count < max_rag_hops -1 else False}})
-                    turn_rag_history_for_callback.append({"type":"rag_hop_info", "hop": hop_count + 1, "query": "EMPTY_QUERY_SKIPPED", "summary":"Skipped."})
-                    continue
-                else:
-                    ASCIIColors.warning("RAG query is empty. Proceeding without RAG context.")
-                    break
+                ASCIIColors.warning(f"RAG Hop {hop_count + 1}: Query is empty. Stopping RAG process.")
+                # Add a detail for this aborted hop
+                rag_hops_details_list.append({
+                    "query": "EMPTY_QUERY_STOPPED_HOPS", 
+                    "retrieved_chunks_details": [], 
+                    "status": "Query became empty, RAG stopped."
+                })
+                turn_rag_history_for_callback.append({"type":"rag_hop_info", "hop": hop_count + 1, "query": "EMPTY_QUERY_STOPPED_HOPS", "status":"Stopped."})
+                break # Stop if query is empty
 
             # 2. Perform RAG Query
             if streaming_callback:
-                streaming_callback(f"Querying knowledge base for: '{current_query_for_rag}'...", MSG_TYPE.MSG_TYPE_STEP_START, {"type": "rag_retrieval", "hop": hop_count + 1, "query": current_query_for_rag}, turn_rag_history_for_callback)
+                streaming_callback(f"Querying knowledge base for (Hop {hop_count + 1}): '{current_query_for_rag}'...", MSG_TYPE.MSG_TYPE_STEP_START, {"type": "rag_retrieval", "hop": hop_count + 1, "query": current_query_for_rag}, turn_rag_history_for_callback)
             
             try:
-                retrieved_chunks_raw = rag_query_function(current_query_for_rag, rag_vectorizer_name, rag_top_k, rag_min_similarity_percent)
+                retrieved_chunks_raw_this_hop = rag_query_function(current_query_for_rag, rag_vectorizer_name, rag_top_k, rag_min_similarity_percent)
             except Exception as e_rag_query:
                 trace_exception(e_rag_query)
-                return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": f"RAG query function failed: {e_rag_query}"}
+                return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": f"RAG query function failed on hop {hop_count + 1}: {e_rag_query}"}
 
             if streaming_callback:
-                streaming_callback(f"Retrieved {len(retrieved_chunks_raw)} chunks.", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "rag_retrieval", "hop": hop_count + 1, "num_chunks": len(retrieved_chunks_raw)}, turn_rag_history_for_callback)
+                streaming_callback(f"Retrieved {len(retrieved_chunks_raw_this_hop)} chunks for hop {hop_count + 1}.", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "rag_retrieval", "hop": hop_count + 1, "num_chunks": len(retrieved_chunks_raw_this_hop)}, turn_rag_history_for_callback)
 
-            current_hop_details = {"query": current_query_for_rag, "retrieved_chunks_details": []}
-            
-            formatted_new_chunks_for_llm_summary = ""
-            if retrieved_chunks_raw:
-                for i, chunk in enumerate(retrieved_chunks_raw):
+            current_hop_chunk_details_for_history = []
+            new_chunks_added_this_hop = 0
+            if retrieved_chunks_raw_this_hop:
+                for chunk in retrieved_chunks_raw_this_hop:
                     doc_path = chunk.get('file_path', 'Unknown Document')
-                    similarity = chunk.get('similarity_percent', 'N/A')
                     content = chunk.get('chunk_text', '')
+                    similarity = chunk.get('similarity_percent', 0.0) # Default to 0.0 if not present
+
+                    # Ensure content is string and similarity is float for sorting later
+                    if not isinstance(content, str): content = str(content)
+                    try:
+                        similarity = float(similarity)
+                    except (ValueError, TypeError):
+                        similarity = 0.0 # Default if conversion fails
+
+                    chunk_detail_for_map_and_history = {
+                        "document": doc_path, 
+                        "similarity": similarity, 
+                        "content": content,
+                        "retrieved_in_hop": hop_count + 1,
+                        "query_used": current_query_for_rag
+                    }
+                    current_hop_chunk_details_for_history.append(chunk_detail_for_map_and_history)
                     
-                    chunk_detail_for_history = {"document": doc_path, "similarity": similarity, "content": content}
-                    current_hop_details["retrieved_chunks_details"].append(chunk_detail_for_history)
-                    
-                    # Add to unique list for final output
-                    # Use a combination of path and content to uniquely identify a chunk to avoid duplicates if same content appears from different queries.
-                    # A more robust unique key might involve hashing content if it's very large.
-                    unique_key = f"{doc_path}::{content[:100]}" # Simple key
+                    unique_key = f"{doc_path}::{content[:100]}" # Simple key for uniqueness
                     if unique_key not in all_unique_retrieved_chunks_map:
-                         all_unique_retrieved_chunks_map[unique_key] = chunk_detail_for_history
-
-                    # Format for LLM processing (summary or direct use)
-                    formatted_new_chunks_for_llm_summary += f"Document: {doc_path} (Similarity: {similarity}%)\nContent:\n{content}\n---\n"
+                         all_unique_retrieved_chunks_map[unique_key] = chunk_detail_for_map_and_history
+                         new_chunks_added_this_hop +=1
             
-            if not retrieved_chunks_raw:
-                current_hop_details["new_information_summary"] = "No relevant information found for this query."
-                current_hop_details["llm_decision_json"] = {"need_more_data": True if max_rag_hops > 0 and hop_count < max_rag_hops -1 else False, "reasoning_for_decision":"No new information retrieved."}
-                rag_hops_details_list.append(current_hop_details)
-                turn_rag_history_for_callback.append({"type":"rag_hop_info", **current_hop_details})
-                if max_rag_hops == 0 or hop_count >= max_rag_hops -1 :
-                    break
-                else:
-                    accumulated_rag_context_str += f"\n\n---\nAttempted query: '{current_query_for_rag}' - No new information found.\n---"
-                    continue
-
-            if max_rag_hops == 0: # Classic RAG
-                accumulated_rag_context_str += formatted_new_chunks_for_llm_summary
-                current_hop_details["new_information_summary"] = "Directly used in context (classic RAG)."
-                current_hop_details["llm_decision_json"] = {"need_more_data": False}
-                rag_hops_details_list.append(current_hop_details)
-                turn_rag_history_for_callback.append({"type":"rag_hop_info", **current_hop_details})
-                break
-            
-            # Multi-hop: LLM summarizes and decides
-            if streaming_callback:
-                streaming_callback("LLM processing retrieved data and deciding next step...", MSG_TYPE.MSG_TYPE_STEP_START, {"type": "rag_llm_decision", "hop": hop_count + 1}, turn_rag_history_for_callback)
-
-            decision_prompt_llm_parts = [
-                f"{self.system_full_header}You are an AI research assistant. Analyze newly retrieved information against the user's request and prior knowledge, then decide if more searching is needed.",
-                f"{self.user_full_header}Original user request: '{original_user_prompt}'",
-            ]
-            if accumulated_rag_context_str:
-                decision_prompt_llm_parts.append(f"Current accumulated knowledge summary:\n{accumulated_rag_context_str}")
-            decision_prompt_llm_parts.append(f"You just searched for: '{current_query_for_rag}'")
-            decision_prompt_llm_parts.append(f"And found this new information:\n--- New Information Start ---\n{formatted_new_chunks_for_llm_summary}--- New Information End ---")
-            decision_prompt_llm_parts.append(
-                "Task: Provide a concise summary of ONLY the new information relevant to the original request. "
-                "Then, assess if you now have sufficient information to comprehensively answer the user's original request or if another, more targeted search is necessary. "
-                "Respond STRICTLY in the following JSON format, with no other text before or after the JSON block:"
-            )
-            json_template_for_decision = """
-{
-  "new_information_summary": "<Your concise summary of ONLY the new_information relevant to the original_user_request. Focus on what's new and useful. If nothing new is relevant, state that.>",
-  "need_more_data": <true_or_false>,
-  "reasoning_for_decision": "<Briefly explain why you need more data or why you have enough. If needing more, suggest what kind of information is still missing.>"
-}
-"""
-            decision_prompt_llm_parts.append(f"```json\n{json_template_for_decision}\n```")
-            decision_prompt_llm_parts.append(self.ai_full_header)
-
-            llm_decision_json_str = self.generate_code(prompt="".join(decision_prompt_llm_parts), language="json", template=json_template_for_decision, temperature=rag_hop_summary_temperature, max_size=1024)
-
-            if isinstance(llm_decision_json_str, dict) and "error" in llm_decision_json_str:
-                return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": f"LLM failed to make RAG decision: {llm_decision_json_str['error']}"}
-            if not llm_decision_json_str:
-                 return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": "LLM provided empty decision for RAG hop."}
-
-            try:
-                llm_decision = json.loads(llm_decision_json_str)
-            except json.JSONDecodeError:
-                try:
-                    match = re.search(r"```json\s*(\{.*?\})\s*```", llm_decision_json_str, re.DOTALL)
-                    if match: llm_decision = json.loads(match.group(1))
-                    else: llm_decision = json.loads(self.extract_code_blocks(llm_decision_json_str, format="markdown")[0]["content"])
-                except Exception as e_json_parse:
-                    trace_exception(e_json_parse)
-                    return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": f"Failed to parse LLM RAG decision JSON: {llm_decision_json_str}. Error: {e_json_parse}"}
-
-            new_summary = llm_decision.get("new_information_summary", "Summary not provided by LLM.")
-            need_more_data = llm_decision.get("need_more_data", True)
-
-            current_hop_details["new_information_summary"] = new_summary
-            current_hop_details["llm_decision_json"] = llm_decision
+            hop_status = "Completed"
+            if not retrieved_chunks_raw_this_hop:
+                hop_status = "No chunks retrieved for this query."
+            elif new_chunks_added_this_hop == 0 and hop_count > 0: # Only consider "no new unique chunks" for subsequent hops
+                hop_status = "No *new* unique chunks retrieved."
+                # Optionally, could break here if no new unique chunks are found in a multi-hop scenario
+                # ASCIIColors.warning(f"RAG Hop {hop_count + 1}: No new unique chunks found. Consider stopping if this persists.")
+
+
+            current_hop_details = {
+                "query": current_query_for_rag, 
+                "retrieved_chunks_details": current_hop_chunk_details_for_history, # Chunks from THIS hop
+                "status": hop_status
+            }
             rag_hops_details_list.append(current_hop_details)
             turn_rag_history_for_callback.append({"type":"rag_hop_info", **current_hop_details})
 
+            # Reset for next potential query generation if it's not the last planned hop
+            if hop_count < max_rag_hops:
+                current_query_for_rag = None 
+            else: # This was the last hop
+                break
+
+
+        # 3. Prepare Final Context from All Unique Retrieved Chunks
+        accumulated_rag_context_str = ""
+        if all_unique_retrieved_chunks_map:
             if streaming_callback:
-                streaming_callback(f"LLM decision: Summary='{new_summary[:100]}...', NeedMoreData={need_more_data}", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "rag_llm_decision", "hop": hop_count + 1, "decision": llm_decision}, turn_rag_history_for_callback)
+                streaming_callback("Preparing final RAG context from all retrieved chunks...", MSG_TYPE.MSG_TYPE_STEP, {"type": "context_preparation"}, turn_rag_history_for_callback)
 
-            accumulated_rag_context_str += f"\n\n--- Summary of findings from query '{current_query_for_rag}' (Hop {hop_count + 1}) ---\n{new_summary}\n---"
+            # Sort all unique chunks by similarity (highest first)
+            sorted_unique_chunks = sorted(
+                list(all_unique_retrieved_chunks_map.values()),
+                key=lambda c: c.get('similarity', 0.0),
+                reverse=True
+            )
             
-            if not need_more_data or hop_count >= max_rag_hops -1 : # Subtract 1 because current hop is finishing
-                break
+            current_context_chars = 0
+            chunks_used_in_final_context = 0
+            context_lines = []
+            for chunk in sorted_unique_chunks:
+                chunk_text_to_add = f"Source: {chunk['document']} (Similarity: {chunk['similarity']:.2f}%, Hop: {chunk['retrieved_in_hop']}, Query: '{chunk['query_used']}')\nContent:\n{chunk['content']}\n---\n"
+                if current_context_chars + len(chunk_text_to_add) <= max_rag_context_characters:
+                    context_lines.append(chunk_text_to_add)
+                    current_context_chars += len(chunk_text_to_add)
+                    chunks_used_in_final_context +=1
+                else:
+                    ASCIIColors.warning(f"Reached max RAG context character limit ({max_rag_context_characters}). Used {chunks_used_in_final_context} of {len(sorted_unique_chunks)} unique chunks.")
+                    break
+            accumulated_rag_context_str = "".join(context_lines)
+            
+            if streaming_callback:
+                streaming_callback(f"Final RAG context prepared using {chunks_used_in_final_context} chunks ({current_context_chars} chars).", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "context_preparation", "num_chunks_in_context": chunks_used_in_final_context, "chars_in_context": current_context_chars}, turn_rag_history_for_callback)
+
 
         # 4. Final Answer Generation
         if streaming_callback:
-            streaming_callback("LLM generating final answer using all gathered information...", MSG_TYPE.MSG_TYPE_STEP_START, {"type": "final_answer_generation"}, turn_rag_history_for_callback)
+            streaming_callback("LLM generating final answer...", MSG_TYPE.MSG_TYPE_STEP_START, {"type": "final_answer_generation"}, turn_rag_history_for_callback)
 
-        final_answer_prompt_parts = []
-        if system_prompt:
-            final_answer_prompt_parts.append(f"{self.system_full_header}{system_prompt}")
-        
-        final_answer_prompt_parts.append(f"{self.user_full_header}Original request: {original_user_prompt}")
+        final_answer_prompt_parts = [f"Original request: {original_user_prompt}"]
         if accumulated_rag_context_str:
-            final_answer_prompt_parts.append(f"\nBased on the information I have gathered:\n--- Gathered Context Start ---\n{accumulated_rag_context_str.strip()}\n--- Gathered Context End ---")
+            final_answer_prompt_parts.append(f"\nBased on the following information I have gathered from a knowledge base:\n--- Gathered Context Start ---\n{accumulated_rag_context_str.strip()}\n--- Gathered Context End ---")
         else:
             final_answer_prompt_parts.append("\n(No specific information was retrieved from the knowledge base for this request.)")
         
-        final_answer_prompt_parts.append("\nPlease provide a comprehensive answer to the original request using ONLY the provided gathered context. If the context is insufficient, clearly state that.")
+        final_answer_prompt_parts.append("\nPlease provide a comprehensive answer to the original request using ONLY the provided gathered context. If the context is insufficient, clearly state that. If the context contains code examples, ensure they are accurately reproduced.")
         final_answer_prompt_parts.append(self.ai_full_header)
 
         final_answer_llm_prompt = "\n".join(final_answer_prompt_parts)
         
-        final_answer_streaming_callback = None
-        if streaming_callback:
-            def final_answer_cb_adapter(chunk, msg_type):
-                return streaming_callback(chunk, msg_type, {"type": "final_answer_chunk"}, turn_rag_history_for_callback)
-            final_answer_streaming_callback = final_answer_cb_adapter
+        final_answer_streaming_callback_adapted = None
+        if streaming_callback and stream:
+            def final_answer_cb_adapter(chunk_text, msg_type_llm):
+                return streaming_callback(chunk_text, msg_type_llm, {"type": "final_answer_chunk"}, turn_rag_history_for_callback)
+            final_answer_streaming_callback_adapted = final_answer_cb_adapter
+        
+        actual_streaming_cb_for_generate = final_answer_streaming_callback_adapted if stream else None
 
-        final_answer_text = self.remove_thinking_blocks(self.generate_text(
-            prompt=final_answer_llm_prompt, images=images,
+        final_answer_raw = self.generate_text(
+            prompt=final_answer_llm_prompt, images=images, system_prompt=system_prompt,
             n_predict=n_predict, stream=stream, temperature=temperature, top_k=top_k, top_p=top_p,
             repeat_penalty=repeat_penalty, repeat_last_n=repeat_last_n, seed=seed, n_threads=n_threads,
-            ctx_size=ctx_size, streaming_callback=final_answer_streaming_callback, **llm_generation_kwargs
-        ))
-
-        if streaming_callback:
-            streaming_callback("Final answer generation complete.", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "final_answer_generation"}, turn_rag_history_for_callback)
+            ctx_size=ctx_size, streaming_callback=actual_streaming_cb_for_generate, **llm_generation_kwargs
+        )
 
-        if isinstance(final_answer_text, dict) and "error" in final_answer_text:
-            return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": f"Final answer generation failed: {final_answer_text['error']}"}
+        if isinstance(final_answer_raw, dict) and "error" in final_answer_raw:
+            return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": f"Final answer generation failed: {final_answer_raw['error']}"}
 
-        return {"final_answer": final_answer_text, "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": None}
+        final_answer_text = self.remove_thinking_blocks(final_answer_raw)
 
+        if streaming_callback:
+            streaming_callback("Final answer generation complete.", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "final_answer_generation"}, turn_rag_history_for_callback)
+            if not stream and final_answer_text:
+                 streaming_callback(final_answer_text, MSG_TYPE.MSG_TYPE_CHUNK, {"type": "final_answer_full"}, turn_rag_history_for_callback)
+
+        return {
+            "final_answer": final_answer_text, 
+            "rag_hops_history": rag_hops_details_list, 
+            "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), # All unique chunks found
+            "error": None
+        }
+        
     def generate_code(
                         self,
                         prompt,
                         images=[],
+                        system_prompt=None,
                         template=None,
                         language="json",
                         code_tag_format="markdown", # or "html"
@@ -1111,8 +1109,8 @@ Respond with a JSON object containing ONE of the following structures:
         Uses the underlying LLM binding via `generate_text`.
         Handles potential continuation if the code block is incomplete.
         """
-
-        system_prompt = f"""Act as a code generation assistant that generates code from user prompt."""
+        if not  system_prompt:
+            system_prompt = f"""Act as a code generation assistant that generates code from user prompt."""
 
         if template:
             system_prompt += "Here is a template of the answer:\n"

{lollms_client-0.19.5 → lollms_client-0.19.7/lollms_client.egg-info}/PKG-INFO

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

lollms_client-0.19.5/examples/internet_search_with_rag.py

@@ -1,189 +0,0 @@
-from lollms_client import LollmsClient, MSG_TYPE
-from ascii_colors import ASCIIColors, trace_exception
-from typing import List, Dict, Any, Optional, Callable
-import json
-from pathlib import Path
-
-# --- Dependency Management for the Search Tool ---
-# Ensure the duckduckgo_search library is installed for our RAG query function.
-try:
-    import pipmaster as pm
-    pm.ensure_packages(["duckduckgo_search"])
-    from duckduckgo_search import DDGS
-    _ddgs_installed = True
-except Exception as e_dep:
-    _ddgs_installed = False
-    ASCIIColors.error(f"Could not ensure/import duckduckgo_search: {e_dep}")
-    ASCIIColors.warning("The RAG function in this example will not work.")
-    DDGS = None
-# --- End Dependency Management ---
-
-
-def internet_rag_query_function(
-    query_text: str,
-    vectorizer_name: Optional[str] = None, # Not used for this keyword-based search
-    top_k: int = 5,
-    min_similarity_percent: float = 0.0 # Not used for this keyword-based search
-) -> List[Dict[str, Any]]:
-    """
-    A RAG-compatible query function that performs a live internet search using DuckDuckGo.
-
-    Args:
-        query_text: The search query.
-        vectorizer_name: Ignored by this function.
-        top_k: The maximum number of search results to return.
-        min_similarity_percent: Ignored by this function.
-
-    Returns:
-        A list of dictionaries, each formatted for RAG with 'document', 'content', and 'similarity'.
-    """
-    if not _ddgs_installed:
-        ASCIIColors.error("duckduckgo_search library is not available. Cannot perform internet search.")
-        return []
-
-    ASCIIColors.magenta(f"  [INTERNET RAG] Searching web for: '{query_text}', max_results={top_k}")
-    formatted_results = []
-    try:
-        with DDGS() as ddgs:
-            # Fetch search results from DuckDuckGo
-            search_results = ddgs.text(keywords=query_text, max_results=top_k)
-            
-            if not search_results:
-                ASCIIColors.yellow("  [INTERNET RAG] DuckDuckGo returned no results for this query.")
-                return []
-
-            for i, result in enumerate(search_results):
-                # Format the search result into the structure expected by generate_text_with_rag
-                # 'document' will be the URL.
-                # 'content' will be a combination of title and snippet.
-                # 'similarity' is emulated based on rank, as DDG doesn't provide a score.
-                formatted_results.append({
-                    "document": result.get("href", "#"),
-                    "similarity": round(100.0 - (i * (10.0 / top_k)), 2), # Create a descending score
-                    "content": f"Title: {result.get('title', 'N/A')}\nSnippet: {result.get('body', 'N/A')}"
-                })
-        
-        ASCIIColors.magenta(f"  [INTERNET RAG] Found {len(formatted_results)} results.")
-        return formatted_results
-
-    except Exception as e:
-        trace_exception(e)
-        ASCIIColors.error(f"  [INTERNET RAG] An error occurred during search: {e}")
-        return []
-
-# --- Streaming Callback for RAG and LLM ---
-# (This is the same useful callback from the previous example)
-def rag_streaming_callback(
-    chunk: str, 
-    msg_type: MSG_TYPE, 
-    metadata: Optional[Dict] = None, 
-    turn_history: Optional[List] = None
-) -> bool:
-    metadata = metadata or {}
-    hop = metadata.get("hop", "")
-    type_info = metadata.get("type", "N/A")
-
-    if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:
-        ASCIIColors.success(chunk, end="", flush=True)
-    elif msg_type == MSG_TYPE.MSG_TYPE_STEP_START:
-        info = metadata.get("query", chunk) if type_info in ["rag_query_generation", "rag_retrieval"] else chunk
-        ASCIIColors.yellow(f"\n>> RAG Hop {hop} | START | {type_info.upper()} | Info: {str(info)[:100]}...", flush=True)
-    elif msg_type == MSG_TYPE.MSG_TYPE_STEP_END:
-        num_chunks = metadata.get("num_chunks")
-        query = metadata.get("query")
-        decision = metadata.get("decision")
-        
-        end_info = []
-        if query: end_info.append(f"Query: '{str(query)[:50]}...'")
-        if num_chunks is not None: end_info.append(f"Retrieved: {num_chunks} sources")
-        if decision: end_info.append(f"LLM Decision: NeedMore={decision.get('need_more_data')}, Summary: '{str(decision.get('new_information_summary'))[:40]}...'")
-        
-        ASCIIColors.green(f"\n<< RAG Hop {hop} | END   | {type_info.upper()} | {' | '.join(end_info) if end_info else chunk}", flush=True)
-    elif msg_type == MSG_TYPE.MSG_TYPE_EXCEPTION:
-        ASCIIColors.error(f"\nError in RAG stream: {chunk}", flush=True)
-    
-    return True
-
-# --- Main Example ---
-if __name__ == "__main__":
-    ASCIIColors.red("--- Internet Search with Multi-Hop RAG Example ---")
-
-    LLM_BINDING_NAME = "ollama"
-    LLM_MODEL_NAME = "mistral-nemo:latest" # Nemo is good with JSON and reasoning
-
-    if not _ddgs_installed:
-        ASCIIColors.error("Cannot run this example because the 'duckduckgo-search' library is not installed.")
-        exit(1)
-
-    try:
-        lc = LollmsClient(
-            binding_name=LLM_BINDING_NAME,
-            model_name=LLM_MODEL_NAME,
-            temperature=0.1,
-            ctx_size=4096
-        )
-        ASCIIColors.green(f"LollmsClient initialized with LLM: {LLM_BINDING_NAME}/{LLM_MODEL_NAME}")
-
-        # --- Test Case 1: Classic RAG with Internet Search ---
-        ASCIIColors.cyan("\n\n--- Test Case 1: Classic RAG (max_rag_hops = 0) using Internet Search ---")
-        classic_rag_prompt = "What is the James Webb Space Telescope and what was its launch date?"
-        ASCIIColors.blue(f"User Prompt: {classic_rag_prompt}")
-
-        classic_rag_result = lc.generate_text_with_rag(
-            prompt=classic_rag_prompt,
-            rag_query_function=internet_rag_query_function,
-            max_rag_hops=0,
-            rag_top_k=3,
-            streaming_callback=rag_streaming_callback,
-            n_predict=300
-        )
-        print("\n--- End of Classic RAG ---")
-        ASCIIColors.magenta("\nClassic RAG Final Output Details:")
-        print(f"  Final Answer (first 150 chars): {classic_rag_result.get('final_answer', '')[:150]}...")
-        print(f"  Error: {classic_rag_result.get('error')}")
-        print(f"  Total Unique Sources Retrieved: {len(classic_rag_result.get('all_retrieved_sources', []))}")
-        if classic_rag_result.get('all_retrieved_sources'):
-            print("  Retrieved Sources (URLs):")
-            for source in classic_rag_result['all_retrieved_sources']:
-                print(f"    - {source.get('document')}")
-
-        # --- Test Case 2: Multi-Hop RAG with Internet Search ---
-        ASCIIColors.cyan("\n\n--- Test Case 2: Multi-Hop RAG (max_rag_hops = 2) using Internet Search ---")
-        multihop_prompt = "First, find out what the TRAPPIST-1 system is. Then, search for recent news about its planets from the James Webb Space Telescope."
-        ASCIIColors.blue(f"User Prompt: {multihop_prompt}")
-        
-        multihop_rag_result = lc.generate_text_with_rag(
-            prompt=multihop_prompt,
-            rag_query_function=internet_rag_query_function,
-            rag_query_text=None, # Let the LLM generate the first query
-            max_rag_hops=2, # Allow up to two separate search queries
-            rag_top_k=2,
-            streaming_callback=rag_streaming_callback,
-            n_predict=400,
-        )
-        print("\n--- End of Multi-Hop RAG ---")
-        ASCIIColors.magenta("\nMulti-Hop RAG Final Output Details:")
-        print(f"  Final Answer (first 150 chars): {multihop_rag_result.get('final_answer', '')[:150]}...")
-        print(f"  Error: {multihop_rag_result.get('error')}")
-        print(f"  Number of Hops Made: {len(multihop_rag_result.get('rag_hops_history', []))}")
-        for i, hop_info in enumerate(multihop_rag_result.get('rag_hops_history', [])):
-            print(f"    Hop {i+1} Query: '{hop_info.get('query')}'")
-            print(f"    Hop {i+1} Retrieved Count: {len(hop_info.get('retrieved_chunks_details',[]))}")
-            print(f"    Hop {i+1} LLM Decision: NeedMoreData={hop_info.get('llm_decision_json',{}).get('need_more_data')}")
-        print(f"  Total Unique Sources Retrieved: {len(multihop_rag_result.get('all_retrieved_sources', []))}")
-        if multihop_rag_result.get('all_retrieved_sources'):
-            print("  All Retrieved Sources (URLs):")
-            for source in multihop_rag_result['all_retrieved_sources']:
-                print(f"    - {source.get('document')}")
-
-
-    except ValueError as ve:
-        ASCIIColors.error(f"Initialization or RAG parameter error: {ve}")
-        trace_exception(ve)
-    except ConnectionRefusedError:
-        ASCIIColors.error(f"Connection refused. Is the Ollama server ({LLM_BINDING_NAME}) running?")
-    except Exception as e:
-        ASCIIColors.error(f"An unexpected error occurred: {e}")
-        trace_exception(e)
-
-    ASCIIColors.red("\n--- Internet Search RAG Example Finished ---")