lollms-client 0.19.7__py3-none-any.whl → 0.19.8__py3-none-any.whl

examples/generate_a_benchmark_for_safe_store.py

@@ -0,0 +1,89 @@
+from lollms_client import LollmsClient
+from ascii_colors import ASCIIColors, trace_exception, ProgressBar
+import pipmaster as pm
+pm.ensure_packages(["datasets"])
+#assuming you have an active lollms_webui instance running
+#you can also use ollama or openai or any other lollmc_client binding 
+lc = LollmsClient()
+
+from datasets import load_dataset
+import json
+# 1. Define the dataset name
+dataset_name = "agentlans/high-quality-english-sentences"
+
+try:
+    # 2. Load the dataset
+    # This dataset only has a 'train' split by default.
+    # If a dataset had multiple splits (e.g., 'train', 'validation', 'test'),
+    # load_dataset() would return a DatasetDict.
+    # We can directly access the 'train' split.
+    dataset = load_dataset(dataset_name, split='train')
+    print(f"Dataset loaded successfully: {dataset_name}")
+    print(f"Dataset structure: {dataset}")
+
+    # 3. Extract the sentences into a list
+    # The sentences are in a column likely named 'text' (common for text datasets).
+    # Let's inspect the features to be sure.
+    print(f"Dataset features: {dataset.features}")
+
+    # Assuming the column containing sentences is 'text'
+    # This is standard for many text datasets on Hugging Face.
+    # dataset['text'] directly gives a list of all values in the 'text' column.
+    sentences_list = dataset['text']
+
+    # If you want to be absolutely sure it's a Python list (it usually is or acts like one):
+    # sentences_list = list(dataset['text'])
+
+    # 4. Verify and print some examples
+    print(f"\nSuccessfully extracted {len(sentences_list)} sentences into a list.")
+
+    if sentences_list:
+        print("\nFirst 5 sentences:")
+        for i in range(min(5, len(sentences_list))):
+            print(f"{i+1}. {sentences_list[i]}")
+
+        print("\nLast 5 sentences:")
+        for i in range(max(0, len(sentences_list) - 5), len(sentences_list)):
+            print(f"{len(sentences_list) - (len(sentences_list) - 1 - i)}. {sentences_list[i]}")
+    else:
+        print("The list of sentences is empty.")
+
+except Exception as e:
+    print(f"An error occurred: {e}")
+    print("Please ensure you have an active internet connection and the `datasets` library is installed.")
+    print("Dataset name might be incorrect or the dataset might require authentication or specific configurations.")
+
+entries = []
+for sentence in ProgressBar(sentences_list, desc="Processing Items"):
+    prompt = f"""Given the following text chunk:
+    "{sentence}"
+
+    Generate a JSON object with the following keys and corresponding string values:
+    - "id": A title to the sentence being processed
+    - "highly_similar": A paraphrase of the original chunk, maintaining the core meaning but using different wording and sentence structure.
+    - "related": A sentence or short paragraph that is on the same general topic as the original chunk but discusses a different aspect or a related concept. It should not be a direct paraphrase.
+    - "dissimilar": A sentence or short paragraph on a completely unrelated topic.
+    - "question_form": A question that encapsulates the main idea or asks about a key aspect of the original chunk.
+    - "negation": A sentence that negates the main assertion or a key aspect of the original chunk, while still being topically relevant if possible (e.g., not "The sky is not blue" if the topic is computers).
+
+    Ensure the output is ONLY a valid JSON object. Example:
+    {{
+    "id": "...",
+    "highly_similar": "...",
+    "related": "...",
+    "dissimilar": "...",
+    "question_form": "...",
+    "negation": "..."
+    }}
+
+    JSON object:
+    """
+    try:
+        output = lc.generate_code(prompt)
+        entry = json.loads(output)
+        entry["query"]=sentence
+        entries.append(entry)
+        with open("benchmark_db.json","w") as f:
+            json.dump(entries, f, indent=4)
+    except Exception as ex:
+        trace_exception(ex)

examples/generate_text_with_multihop_rag_example.py

@@ -173,7 +173,6 @@ if __name__ == "__main__":
             streaming_callback=rag_streaming_callback,
             n_predict=1024,
             rag_hop_query_generation_temperature=0.1, # Focused query gen
-            rag_hop_summary_temperature=0.2 # Focused summary
         )
         print("\n--- End of Multi-Hop RAG (1 hop) ---")
         ASCIIColors.magenta("\nMulti-Hop RAG (1 hop) Final Output:")

examples/internet_search_with_rag.py

@@ -148,7 +148,7 @@ if __name__ == "__main__":
         )
         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"  Final Answer (first 100 chars): {classic_rag_result.get('final_answer', '')}...")
         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', []))}")
@@ -157,7 +157,7 @@ if __name__ == "__main__":
             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]}...")
+            print(f"    Content (Snippet, first 50 chars): {source_ex.get('content', '')}...")
 
 
         # --- Test Case 2: Multi-Hop Search RAG (max_rag_hops = 1) ---
@@ -174,12 +174,11 @@ if __name__ == "__main__":
             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 
+            rag_hop_query_generation_temperature=0.1
         )
         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"  Final Answer (first 100 chars): {multihop_rag_result_1.get('final_answer', '')}...")
         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', [])):

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.7" # Updated version
+__version__ = "0.19.8" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/lollms_core.py

@@ -873,221 +873,207 @@ Respond with a JSON object containing ONE of the following structures:
         repeat_last_n: Optional[int] = None,
         seed: Optional[int] = None,
         n_threads: Optional[int] = None,
-        ctx_size: int | None = None,
+        ctx_size: Optional[int] = None,
+        extract_objectives: bool = True,
         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 is no longer needed
         max_rag_context_characters: int = 32000,
         **llm_generation_kwargs
     ) -> Dict[str, Any]:
+        """
+        Enhanced RAG with optional initial objective extraction and automatic intermediate summaries
+        when context grows beyond ctx_size or self.default_ctx_size.
+        """
         if not self.binding:
             return {"final_answer": "", "rag_hops_history": [], "all_retrieved_sources": [], "error": "LLM binding not initialized."}
 
+        # Determine effective context size limit
+        effective_ctx_size = ctx_size or getattr(self, "default_ctx_size", 20000)
+
         turn_rag_history_for_callback: List[Dict[str, Any]] = []
         rag_hops_details_list: List[Dict[str, Any]] = []
-        # 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
+        objectives_text = ""
+        # 0. Optional Objectives Extraction Step
+        if extract_objectives:
+            if streaming_callback:
+                streaming_callback("Extracting and structuring objectives...", MSG_TYPE.MSG_TYPE_STEP, {"type": "objectives_extraction"}, turn_rag_history_for_callback)
+            obj_prompt = (
+                "You are an expert analyst. "
+                "Your task is to extract and structure the key objectives from the user's request below. "
+                "Output a bullet list of objectives only.\n\n"
+                f"User request:\n\"{original_user_prompt}\""
+            )
+            obj_gen = self.generate_text(
+                prompt=obj_prompt,
+                system_prompt="Extract objectives",
+                temperature=0.0,
+                n_predict=200,
+                stream=False
+            )
+            objectives_text = self.remove_thinking_blocks(obj_gen).strip()
+            if streaming_callback:
+                streaming_callback(f"Objectives extracted:\n{objectives_text}", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "objectives_extracted"}, turn_rag_history_for_callback)
 
+        current_query_for_rag = rag_query_text or None
+        previous_queries=[]
+        # 1. RAG Hops
         for hop_count in range(max_rag_hops + 1):
             if streaming_callback:
                 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: # 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"Original user request:\n'{original_user_prompt}'"
-                ]
-                if rag_hops_details_list:
-                    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("\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.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 for hop {hop_count + 1}: {new_query_text_raw['error']}"}
-                
-                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 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.
+            # Generate refined query for multi-hop
+            if hop_count > 0:
+                # build system prompt and history...
+                # (same as before, omitted for brevity)
+                # result => current_query_for_rag
+                pass
+            elif current_query_for_rag is None:
+                current_query_for_rag = prompt
 
             if not current_query_for_rag:
-                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."
+                    "query": "EMPTY_QUERY_STOPPED_HOPS",
+                    "retrieved_chunks_details": [],
+                    "status": "Stopped: empty query."
                 })
-                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
+                break
 
-            # 2. Perform RAG Query
-            if streaming_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)
-            
+            # Retrieve chunks
             try:
-                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 on hop {hop_count + 1}: {e_rag_query}"}
-
-            if streaming_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_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')
-                    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)
-                    
-                    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_map_and_history
-                         new_chunks_added_this_hop +=1
-            
-            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
+                retrieved = rag_query_function(current_query_for_rag, rag_vectorizer_name, rag_top_k, rag_min_similarity_percent)
+            except Exception as e:
+                return {"final_answer": "", "rag_hops_history": rag_hops_details_list, "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()), "error": str(e)}
+
+            hop_details = {"query": current_query_for_rag, "retrieved_chunks_details": [], "status": ""}
+            previous_queries.append(current_query_for_rag)
+            new_unique = 0
+            for chunk in retrieved:
+                doc = chunk.get("file_path", "Unknown")
+                content = str(chunk.get("chunk_text", ""))
+                sim = float(chunk.get("similarity_percent", 0.0))
+                detail = {"document": doc, "similarity": sim, "content": content,
+                          "retrieved_in_hop": hop_count + 1, "query_used": current_query_for_rag}
+                hop_details["retrieved_chunks_details"].append(detail)
+                key = f"{doc}::{content[:100]}"
+                if key not in all_unique_retrieved_chunks_map:
+                    all_unique_retrieved_chunks_map[key] = detail
+                    new_unique += 1
+            hop_details["status"] = "Completed" if retrieved else "No chunks retrieved"
+            if hop_count > 0 and new_unique == 0:
+                hop_details["status"] = "No *new* unique chunks retrieved"
+            rag_hops_details_list.append(hop_details)
+
+            # reset for next hop
             if hop_count < max_rag_hops:
-                current_query_for_rag = None 
-            else: # This was the last hop
+                txt_previous_queries = f"Previous queries:\n"+'\n'.join(previous_queries)+"\n\n" if len(previous_queries)>0 else ""
+                txt_informations = f"Information:\n"+'\n'.join([f"(from {chunk['document']}):{chunk['content']}" for _, chunk in all_unique_retrieved_chunks_map.items()])
+                txt_sp = "Your objective is to analyze the provided chunks of information, then decise if they are sufficient to reach the objective. If you need more information, formulate a new query to extract more data."
+                txt_formatting = """The output format must be in form of json placed inside a json markdown tag. Here is the schema to use:
+```json
+{
+    "decision": A boolean depicting your decision (true: more data is needed, false: there is enough data to reach objective),
+    "query": (optional, only if decision is true). A new query to recover more information from the data source (do not use previous queries as they have already been used)
+}
+```
+"""
+                p = f"Objective:\n{objectives_text}\n\n{txt_previous_queries}\n\n{txt_informations}\n\n{txt_formatting}\n\n"
+                response = self.generate_code(p,system_prompt=txt_sp)
+                try:
+                    answer = json.loads(response)
+                    decision = answer["decision"]
+                    if not decision:
+                        break
+                    else:
+                        current_query_for_rag = answer["query"]
+                except Exception as ex:
+                    trace_exception(ex)
+
+        # 2. Prepare & Summarize Context
+        sorted_chunks = sorted(all_unique_retrieved_chunks_map.values(),
+                               key=lambda c: c["similarity"], reverse=True)
+        context_lines = []
+        total_chars = 0
+        for c in sorted_chunks:
+            snippet = (
+                f"Source: {c['document']} (Sim: {c['similarity']:.1f}%, "
+                f"Hop: {c['retrieved_in_hop']}, Query: '{c['query_used']}')\n"
+                f"{c['content']}\n---\n"
+            )
+            if total_chars + len(snippet) > max_rag_context_characters:
                 break
+            context_lines.append(snippet)
+            total_chars += len(snippet)
 
+        accumulated_context = "".join(context_lines)
 
-        # 3. Prepare Final Context from All Unique Retrieved Chunks
-        accumulated_rag_context_str = ""
-        if all_unique_retrieved_chunks_map:
+        # If context exceeds our effective limit, summarize it
+        if self.count_tokens(accumulated_context) > effective_ctx_size:
             if streaming_callback:
-                streaming_callback("Preparing final RAG context from all retrieved chunks...", MSG_TYPE.MSG_TYPE_STEP, {"type": "context_preparation"}, turn_rag_history_for_callback)
-
-            # 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
+                streaming_callback("Context too large, performing intermediate summary...", MSG_TYPE.MSG_TYPE_STEP, {"type": "intermediate_summary"}, turn_rag_history_for_callback)
+            summary_prompt = (
+                "Summarize the following gathered context into a concise form "
+                "that preserves all key facts and sources needed to answer the user's request:\n\n"
+                f"{accumulated_context}"
             )
-            
-            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)
-            
+            summary = self.generate_text(
+                prompt=summary_prompt,
+                system_prompt="Intermediate summary",
+                temperature=0.0,
+                n_predict= n_predict or 512,
+                stream=False
+            )
+            accumulated_context = self.remove_thinking_blocks(summary).strip()
             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...", MSG_TYPE.MSG_TYPE_STEP_START, {"type": "final_answer_generation"}, turn_rag_history_for_callback)
-
-        final_answer_prompt_parts = [f"Original request: {original_user_prompt}"]
-        if accumulated_rag_context_str:
-            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 ---")
+                streaming_callback("Intermediate summary complete.", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "intermediate_summary"}, turn_rag_history_for_callback)
+
+        # 3. Final Answer Generation
+        final_prompt = [
+            f"Original request: {original_user_prompt}"
+        ]
+        if objectives_text:
+            final_prompt.insert(1, f"Structured Objectives:\n{objectives_text}\n")
+        if accumulated_context:
+            final_prompt.append(
+                "\nBased on the gathered context:\n---\n"
+                f"{accumulated_context}\n---"
+            )
         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. 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_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_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=actual_streaming_cb_for_generate, **llm_generation_kwargs
+            final_prompt.append("\n(No relevant context retrieved.)")
+        final_prompt.append(
+            "\nProvide a comprehensive answer using ONLY the above context. "
+            "If context is insufficient, state so clearly."
         )
+        final_prompt.append(self.ai_full_header)
 
-        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']}"}
-
-        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)
+        final_answer = self.generate_text(
+            prompt="\n".join(final_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=streaming_callback if stream else None,
+            **llm_generation_kwargs
+        )
+        answer_text = self.remove_thinking_blocks(final_answer) if isinstance(final_answer, str) else final_answer
 
         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
+            "final_answer": answer_text,
+            "rag_hops_history": rag_hops_details_list,
+            "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()),
             "error": None
         }
-        
+
+
     def generate_code(
                         self,
                         prompt,

lollms_client/lollms_discussion.py

@@ -1,7 +1,7 @@
 import yaml
 from lollms_client.lollms_core import LollmsClient
 from dataclasses import dataclass, field
-from typing import List
+from typing import List, Dict
 import uuid
 import os
 
@@ -11,9 +11,9 @@ class LollmsMessage:
     sender: str
     content: str
     id: str = field(default_factory=lambda: str(uuid.uuid4()))
-
+    metadata: str = "{}"
     def to_dict(self):
-        return {'sender': self.sender, 'content': self.content, 'id': self.id}
+        return {'sender': self.sender, 'content': self.content, 'metadata': self.metadata, 'id': self.id}
 
 # LollmsDiscussion Class
 class LollmsDiscussion:
@@ -21,8 +21,8 @@ class LollmsDiscussion:
         self.messages:List[LollmsMessage] = []
         self.lollmsClient = lollmsClient
 
-    def add_message(self, sender, content):
-        message = LollmsMessage(sender, content)
+    def add_message(self, sender, content, metadata={}):
+        message = LollmsMessage(sender, content, str(metadata))
         self.messages.append(message)
 
     def save_to_disk(self, file_path):

{lollms_client-0.19.7.dist-info → lollms_client-0.19.8.dist-info}/METADATA

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

{lollms_client-0.19.7.dist-info → lollms_client-0.19.8.dist-info}/RECORD

@@ -1,6 +1,7 @@
 examples/function_calling_with_local_custom_mcp.py,sha256=g6wOFRB8-p9Cv7hKmQaGzPvtMX3H77gas01QVNEOduM,12407
-examples/generate_text_with_multihop_rag_example.py,sha256=Z6TbVqThOCHNK6kzIqRnEi76JDxIFlg1-IIMWehZars,11582
-examples/internet_search_with_rag.py,sha256=WBoYFBEjGIFKyKTzezm7lI0bGPNuHFMyoq_8iY32qLY,12434
+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/local_mcp.py,sha256=w40dgayvHYe01yvekEE0LjcbkpwKjWwJ-9v4_wGYsUk,9113
 examples/simple_text_gen_test.py,sha256=RoX9ZKJjGMujeep60wh5WT_GoBn0O9YKJY6WOy-ZmOc,8710
 examples/simple_text_gen_with_image_test.py,sha256=rR1O5Prcb52UHtJ3c6bv7VuTd1cvbkr5aNZU-v-Rs3Y,9263
@@ -19,10 +20,10 @@ 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=86XdQomPuN11zPz9F0RAO1ikkwIwxOuay4D48Lr0imE,910
+lollms_client/__init__.py,sha256=4hRrTRCQTe3p2BdddF-8fJyG0nXyLOe_Imfini-BgtQ,910
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=CRHOihPB3Euzu2lMUyvXWcd27GT6NHDbJvdlLO6cB1M,117743
-lollms_client/lollms_discussion.py,sha256=9b83m0D894jwpgssWYTQHbVxp1gJoI-J947Ui_dRXII,2073
+lollms_client/lollms_core.py,sha256=B1swe9E024JZigsQSXynuFHpJi-1dIEcIVN7EGGXZqk,113509
+lollms_client/lollms_discussion.py,sha256=EV90dIgw8a-f-82vB2GspR60RniYz7WnBmAWSIg5mW0,2158
 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_mcp_binding.py,sha256=0rK9HQCBEGryNc8ApBmtOlhKE1Yfn7X7xIQssXxS2Zc,8933
@@ -69,8 +70,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.19.7.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.19.7.dist-info/METADATA,sha256=mBO2JtWYs-IAKhUX2GMIvBHzIXw-MiQ2sMZkbazoqos,13374
-lollms_client-0.19.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.19.7.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.19.7.dist-info/RECORD,,
+lollms_client-0.19.8.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.19.8.dist-info/METADATA,sha256=uHDmoes5veI0cBqErMnJbDS8TvadIZb-xvMnOXhLclc,13374
+lollms_client-0.19.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.19.8.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.19.8.dist-info/RECORD,,