lollms-client 0.19.6__tar.gz → 0.19.8__tar.gz

{lollms_client-0.19.6 → lollms_client-0.19.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.19.6
+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.8/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)

{lollms_client-0.19.6 → lollms_client-0.19.8}/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:")

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

{lollms_client-0.19.6 → lollms_client-0.19.8}/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,
@@ -875,226 +873,212 @@ 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: float = 0.3,
+        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]] = []
-        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
-        current_query_for_rag = rag_query_text
+        all_unique_retrieved_chunks_map: Dict[str, Dict[str, Any]] = {}
+
         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 or (current_query_for_rag is None and max_rag_hops > 0):
-                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)
-                
-                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}'"
-                ]
-                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("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(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))
-                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']}"}
-                
-                current_query_for_rag = 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:
-                current_query_for_rag = original_user_prompt
+            # 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:
-                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
+                rag_hops_details_list.append({
+                    "query": "EMPTY_QUERY_STOPPED_HOPS",
+                    "retrieved_chunks_details": [],
+                    "status": "Stopped: empty query."
+                })
+                break
 
-            # 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)
-            
+            # Retrieve chunks
             try:
-                retrieved_chunks_raw = 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}"}
-
-            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)
-
-            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):
-                    doc_path = chunk.get('file_path', 'Unknown Document')
-                    similarity = chunk.get('similarity_percent', 'N/A')
-                    content = chunk.get('chunk_text', '')
-                    
-                    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
-                    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"
-            
-            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 = """
+                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:
+                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
 {
-  "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": 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)
 }
+```
 """
-            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:
+                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:
-                    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
-            rag_hops_details_list.append(current_hop_details)
-            turn_rag_history_for_callback.append({"type":"rag_hop_info", **current_hop_details})
-
-            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)
-
-            accumulated_rag_context_str += f"\n\n--- Summary of findings from query '{current_query_for_rag}' (Hop {hop_count + 1}) ---\n{new_summary}\n---"
-            
-            if not need_more_data or hop_count >= max_rag_hops -1 : # Subtract 1 because current hop is finishing
+                    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)
 
-        # 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)
+        accumulated_context = "".join(context_lines)
 
-        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}")
-        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 ---")
+        # If context exceeds our effective limit, summarize it
+        if self.count_tokens(accumulated_context) > effective_ctx_size:
+            if streaming_callback:
+                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}"
+            )
+            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("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.")
-        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_text = self.remove_thinking_blocks(self.generate_text(
-            prompt=final_answer_llm_prompt, images=images,
-            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
-        ))
+            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 streaming_callback:
-            streaming_callback("Final answer generation complete.", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "final_answer_generation"}, 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
 
-        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']}"}
+        return {
+            "final_answer": answer_text,
+            "rag_hops_history": rag_hops_details_list,
+            "all_retrieved_sources": list(all_unique_retrieved_chunks_map.values()),
+            "error": None
+        }
 
-        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}
 
     def generate_code(
                         self,
                         prompt,
                         images=[],
+                        system_prompt=None,
                         template=None,
                         language="json",
                         code_tag_format="markdown", # or "html"
@@ -1111,8 +1095,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.6 → lollms_client-0.19.8}/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.6 → lollms_client-0.19.8}/lollms_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.19.6
+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.6 → lollms_client-0.19.8}/lollms_client.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 examples/function_calling_with_local_custom_mcp.py
+examples/generate_a_benchmark_for_safe_store.py
 examples/generate_text_with_multihop_rag_example.py
 examples/internet_search_with_rag.py
 examples/local_mcp.py