lollms-client 0.22.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

examples/{run_remote_mcp_example copy.py → mcp_examples/run_remote_mcp_example_v2.py}

@@ -7,6 +7,26 @@ from pathlib import Path
 import json
 from lollms_client import LollmsClient
 import subprocess
+from typing import Optional, List, Dict, Any
+
+
+MOCK_KNOWLEDGE_BASE = {
+    "python_basics.md": [
+        {"chunk_id": 1, "text": "Python is a high-level, interpreted programming language known for its readability and versatility. It was created by Guido van Rossum and first released in 1991."},
+        {"chunk_id": 2, "text": "Key features of Python include dynamic typing, automatic memory management (garbage collection), and a large standard library. It supports multiple programming paradigms, such as procedural, object-oriented, and functional programming."},
+        {"chunk_id": 3, "text": "Common applications of Python include web development (e.g., Django, Flask), data science (e.g., Pandas, NumPy, Scikit-learn), machine learning, artificial intelligence, automation, and scripting."},
+    ],
+    "javascript_info.js": [
+        {"chunk_id": 1, "text": "JavaScript is a scripting language primarily used for front-end web development to create interactive effects within web browsers. It is also used in back-end development (Node.js), mobile app development, and game development."},
+        {"chunk_id": 2, "text": "JavaScript is dynamically typed, prototype-based, and multi-paradigm. Along with HTML and CSS, it is one of the core technologies of the World Wide Web."},
+        {"chunk_id": 3, "text": "Popular JavaScript frameworks and libraries include React, Angular, Vue.js for front-end, and Express.js for Node.js back-end applications."},
+    ],
+    "ai_concepts.txt": [
+        {"chunk_id": 1, "text": "Artificial Intelligence (AI) refers to the simulation of human intelligence in machines that are programmed to think like humans and mimic their actions. The term may also be applied to any machine that exhibits traits associated with a human mind such as learning and problem-solving."},
+        {"chunk_id": 2, "text": "Machine Learning (ML) is a subset of AI that provides systems the ability to automatically learn and improve from experience without being explicitly programmed. Deep Learning (DL) is a further subset of ML based on artificial neural networks with representation learning."},
+        {"chunk_id": 3, "text": "Retrieval Augmented Generation (RAG) is an AI framework for improving the quality of LLM-generated responses by grounding the model on external sources of knowledge to supplement the LLM’s internal representation of information."},
+    ]
+}
 # --- Dynamically adjust Python path to find lollms_client ---
 # This assumes the example script is in a directory, and 'lollms_client' is
 # in a sibling directory or a known relative path. Adjust as needed.
@@ -180,10 +200,54 @@ def main():
         return True # Continue streaming
 
     # --- 4. Use generate_with_mcp ---
+
+    def mock_rag_query_function(
+        query_text: str,
+        vectorizer_name: Optional[str] = None, # Ignored in mock
+        top_k: int = 3,
+        min_similarity_percent: float = 0.0 # Ignored in mock, simple keyword match
+    ) -> List[Dict[str, Any]]:
+        """
+        A mock RAG query function.
+        Performs a simple keyword search in the MOCK_KNOWLEDGE_BASE.
+        """
+        ASCIIColors.magenta(f"  [MOCK RAG] Querying with: '{query_text}', top_k={top_k}")
+        results = []
+        query_lower = query_text.lower()
+        
+        all_chunks = []
+        for file_path, chunks_in_file in MOCK_KNOWLEDGE_BASE.items():
+            for chunk_data in chunks_in_file:
+                all_chunks.append({"file_path": file_path, **chunk_data})
+
+        # Simple keyword matching and scoring (very basic)
+        scored_chunks = []
+        for chunk_info in all_chunks:
+            score = 0
+            for keyword in query_lower.split():
+                if keyword in chunk_info["text"].lower() and len(keyword)>2: # Basic relevance
+                    score += 1
+            if "python" in query_lower and "python" in chunk_info["file_path"].lower(): score+=5
+            if "javascript" in query_lower and "javascript" in chunk_info["file_path"].lower(): score+=5
+            if "ai" in query_lower and "ai" in chunk_info["file_path"].lower(): score+=3
+
+
+            if score > 0 : # Only include if some keywords match
+                # Simulate similarity percentage (higher score = higher similarity)
+                similarity = min(100.0, score * 20.0 + 40.0) # Arbitrary scaling
+                if similarity >= min_similarity_percent:
+                    scored_chunks.append({
+                        "file_path": chunk_info["file_path"],
+                        "chunk_text": chunk_info["text"],
+                        "similarity_percent": similarity,
+                        "_score_for_ranking": score # Internal score for sorting
+                    })
     ASCIIColors.magenta("\n2. Calling generate_with_mcp to get current time...")
     time_prompt = "Hey assistant, what time is it right now?"
-    time_response = client.generate_with_mcp(
+    time_response = client.generate_with_mcp_rag(
         prompt=time_prompt,
+        use_mcps=True,
+        use_data_store={"coding_store":mock_rag_query_function},
         streaming_callback=mcp_streaming_callback,
         interactive_tool_execution=False # Set to True to test interactive mode
     )

lollms_client/__init__.py

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

lollms_client/lollms_core.py

@@ -526,7 +526,8 @@ class LollmsClient():
              seed: Optional[int] = None,
              n_threads: Optional[int] = None,
              ctx_size: Optional[int] = None,
-             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
+             streaming_callback: Optional[Callable[[str, MSG_TYPE, Dict], bool]] = None,
+             **kwargs
              ) -> Union[str, dict]:
         """
         High-level method to perform a chat generation using a LollmsDiscussion object.
@@ -558,7 +559,7 @@ class LollmsClient():
                 discussion=discussion,
                 branch_tip_id=branch_tip_id,
                 n_predict=n_predict if n_predict is not None else self.default_n_predict,
-                stream=stream if stream is not None else self.default_stream,
+                stream=stream if stream is not None else True if streaming_callback is not None else self.default_stream,
                 temperature=temperature if temperature is not None else self.default_temperature,
                 top_k=top_k if top_k is not None else self.default_top_k,
                 top_p=top_p if top_p is not None else self.default_top_p,
@@ -1283,33 +1284,180 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             "error": None
         }
     
+    # --- Start of modified/added methods ---
+    def _synthesize_knowledge(
+        self,
+        previous_scratchpad: str,
+        tool_name: str,
+        tool_params: dict,
+        tool_result: dict
+    ) -> str:
+        """
+        A dedicated LLM call to interpret a tool's output and update the knowledge scratchpad.
+        """
+        # Sanitize tool_result for LLM to avoid sending large binary/base64 data
+        sanitized_result = tool_result.copy()
+        if 'image_path' in sanitized_result:
+            sanitized_result['summary'] = f"An image was successfully generated and saved to '{sanitized_result['image_path']}'."
+            # Remove keys that might contain large data if they exist
+            sanitized_result.pop('image_base64', None)
+        elif 'file_path' in sanitized_result and 'content' in sanitized_result:
+             sanitized_result['summary'] = f"Content was successfully written to '{sanitized_result['file_path']}'."
+             sanitized_result.pop('content', None)
+
+
+        synthesis_prompt = (
+            "You are a data analyst assistant. Your sole job is to interpret the output of a tool and integrate it into the existing research summary (knowledge scratchpad).\n\n"
+            "--- PREVIOUS KNOWLEDGE SCRATCHPAD ---\n"
+            f"{previous_scratchpad}\n\n"
+            "--- ACTION JUST TAKEN ---\n"
+            f"Tool Called: `{tool_name}`\n"
+            f"Parameters: {json.dumps(tool_params)}\n\n"
+            "--- RAW TOOL OUTPUT ---\n"
+            f"```json\n{json.dumps(sanitized_result, indent=2)}\n```\n\n"
+            "--- YOUR TASK ---\n"
+            "Read the 'RAW TOOL OUTPUT' and explain what it means in plain language. Then, integrate this new information with the 'PREVIOUS KNOWLEDGE SCRATCHPAD' to create a new, complete, and self-contained summary.\n"
+            "Your output should be ONLY the text of the new scratchpad, with no extra commentary or formatting.\n\n"
+            "--- NEW KNOWLEDGE SCRATCHPAD ---\n"
+        )
+        new_scratchpad_text = self.generate_text(prompt=synthesis_prompt, n_predict=1024, temperature=0.0)
+        return self.remove_thinking_blocks(new_scratchpad_text).strip()
+    def generate_structured_content(
+        self,
+        prompt: str,
+        template: Union[dict, list],
+        system_prompt: Optional[str] = None,
+        images: Optional[List[str]] = None,
+        max_retries: int = 3,
+        **kwargs
+    ) -> Union[dict, list, None]:
+        """
+        Generates structured content (JSON) from a prompt, ensuring it matches a given template.
+
+        This method repeatedly calls the LLM until a valid JSON object that can be parsed
+        and somewhat matches the template is returned, or until max_retries is reached.
+
+        Args:
+            prompt (str): The main prompt to guide the LLM.
+            template (Union[dict, list]): A Python dict or list representing the desired JSON structure.
+            system_prompt (Optional[str], optional): An optional system prompt. Defaults to None.
+            images (Optional[List[str]], optional): A list of image paths for multimodal prompts. Defaults to None.
+            max_retries (int, optional): The maximum number of times to retry generation if parsing fails. Defaults to 3.
+            **kwargs: Additional keyword arguments to pass to the underlying generate_text method.
+
+        Returns:
+            Union[dict, list, None]: The parsed JSON object (as a Python dict or list), or None if it fails after all retries.
+        """
+        template_str = json.dumps(template, indent=4)
+        
+        if not system_prompt:
+            system_prompt = "You are a highly intelligent AI assistant that excels at generating structured data in JSON format."
+        
+        final_system_prompt = (
+            f"{system_prompt}\n\n"
+            "You MUST generate a response that is a single, valid JSON object matching the structure of the template provided by the user. "
+            "Your entire response should be enclosed in a single ```json markdown code block. "
+            "Do not include any other text, explanations, or apologies outside of the JSON code block.\n"
+            f"Here is the JSON template you must follow:\n{template_str}"
+        )
+
+        current_prompt = prompt
+        for attempt in range(max_retries):
+            raw_llm_output = self.generate_text(
+                prompt=current_prompt,
+                system_prompt=final_system_prompt,
+                images=images,
+                **kwargs
+            )
+            
+            if not raw_llm_output:
+                ASCIIColors.warning(f"Structured content generation failed (Attempt {attempt + 1}/{max_retries}): LLM returned an empty response.")
+                current_prompt = f"You previously returned an empty response. Please try again and adhere strictly to the JSON format. \nOriginal prompt was: {prompt}"
+                continue
+
+            try:
+                # Use robust_json_parser which handles cleanup of markdown tags, comments, etc.
+                parsed_json = robust_json_parser(raw_llm_output)
+                # Optional: Add validation against the template's structure here if needed
+                return parsed_json
+            except (ValueError, json.JSONDecodeError) as e:
+                ASCIIColors.warning(f"Structured content parsing failed (Attempt {attempt + 1}/{max_retries}). Error: {e}")
+                trace_exception(e)
+                # Prepare for retry with more explicit instructions
+                current_prompt = (
+                    "Your previous response could not be parsed as valid JSON. Please review the error and the required template and try again. "
+                    "Ensure your entire output is a single, clean JSON object inside a ```json code block.\n\n"
+                    f"--- PARSING ERROR ---\n{str(e)}\n\n"
+                    f"--- YOUR PREVIOUS INVALID RESPONSE ---\n{raw_llm_output}\n\n"
+                    f"--- REQUIRED JSON TEMPLATE ---\n{template_str}\n\n"
+                    f"--- ORIGINAL PROMPT ---\n{prompt}"
+                )
+
+        ASCIIColors.error("Failed to generate valid structured content after multiple retries.")
+        return None
+
+    def _synthesize_knowledge(
+        self,
+        previous_scratchpad: str,
+        tool_name: str,
+        tool_params: dict,
+        tool_result: dict
+    ) -> str:
+        """
+        A dedicated LLM call to interpret a tool's output and update the knowledge scratchpad.
+        """
+        # Sanitize tool_result for LLM to avoid sending large binary/base64 data
+        sanitized_result = tool_result.copy()
+        if 'image_path' in sanitized_result:
+            sanitized_result['summary'] = f"An image was successfully generated and saved to '{sanitized_result['image_path']}'."
+            # Remove keys that might contain large data if they exist
+            sanitized_result.pop('image_base64', None)
+        elif 'file_path' in sanitized_result and 'content' in sanitized_result:
+             sanitized_result['summary'] = f"Content was successfully written to '{sanitized_result['file_path']}'."
+             sanitized_result.pop('content', None)
+
+
+        synthesis_prompt = (
+            "You are a data analyst assistant. Your sole job is to interpret the output of a tool and integrate it into the existing research summary (knowledge scratchpad).\n\n"
+            "--- PREVIOUS KNOWLEDGE SCRATCHPAD ---\n"
+            f"{previous_scratchpad}\n\n"
+            "--- ACTION JUST TAKEN ---\n"
+            f"Tool Called: `{tool_name}`\n"
+            f"Parameters: {json.dumps(tool_params)}\n\n"
+            "--- RAW TOOL OUTPUT ---\n"
+            f"```json\n{json.dumps(sanitized_result, indent=2)}\n```\n\n"
+            "--- YOUR TASK ---\n"
+            "Read the 'RAW TOOL OUTPUT' and explain what it means in plain language. Then, integrate this new information with the 'PREVIOUS KNOWLEDGE SCRATCHPAD' to create a new, complete, and self-contained summary.\n"
+            "Your output should be ONLY the text of the new scratchpad, with no extra commentary or formatting.\n\n"
+            "--- NEW KNOWLEDGE SCRATCHPAD ---\n"
+        )
+        new_scratchpad_text = self.generate_text(prompt=synthesis_prompt, n_predict=1024, temperature=0.0)
+        return self.remove_thinking_blocks(new_scratchpad_text).strip()
+
     def generate_with_mcp_rag(
         self,
         prompt: str,
-        rag_query_function: Callable[[str, Optional[str], int, float], List[Dict[str, Any]]],
+        use_mcps: Union[None, bool, List[str]] = None,
+        use_data_store: Union[None, Dict[str, Callable]] = None,
         system_prompt: str = None,
         objective_extraction_system_prompt="Extract objectives",
         images: Optional[List[str]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
         max_tool_calls: int = 10,
         max_llm_iterations: int = 15,
         tool_call_decision_temperature: float = 0.0,
         final_answer_temperature: float = None,
         streaming_callback: Optional[Callable[[str, MSG_TYPE, Optional[Dict], Optional[List]], bool]] = None,
         build_plan: bool = True,
-        rag_vectorizer_name: Optional[str] = None,
         rag_top_k: int = 5,
         rag_min_similarity_percent: float = 70.0,
         **llm_generation_kwargs
     ) -> Dict[str, Any]:
         """
         Generates a response using a stateful agent that can choose between calling standard
-        MCP tools and querying a RAG database, all within a unified reasoning loop.
+        MCP tools and querying one or more RAG databases, all within a unified reasoning loop.
         """
         if not self.binding:
             return {"final_answer": "", "tool_calls": [], "error": "LLM binding not initialized."}
-        if not self.mcp:
-            return {"final_answer": "", "tool_calls": [], "error": "MCP binding not initialized."}
 
         # --- Initialize Agent State ---
         turn_history: List[Dict[str, Any]] = []
@@ -1320,48 +1468,56 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         tool_calls_made_this_turn = []
         llm_iterations = 0
 
-        # --- 1. Discover MCP Tools and Inject the RAG Tool ---
-        if tools is None:
-            try:
-                mcp_tools = self.mcp.discover_tools(force_refresh=True)
-                if not mcp_tools: ASCIIColors.warning("No MCP tools discovered.")
-            except Exception as e_disc:
-                return {"final_answer": "", "tool_calls": [], "error": f"Failed to discover MCP tools: {e_disc}"}
-        else:
-            mcp_tools = tools
-
-        # Define the RAG tool and add it to the list
-        rag_tool_definition = {
-            "name": "research::query_database",
-            "description": (
-                "Queries a vector database to find relevant text chunks based on a natural language query. "
-                "Use this to gather information, answer questions, or find context for a task before using other tools."
-            ),
-            "input_schema": {
-                "type": "object",
-                "properties": {
-                    "query": {
-                        "type": "string",
-                        "description": "The natural language query to search for. Be specific to get the best results."
+        # --- 1. Discover Available Tools (MCP and RAG) ---
+        available_tools = []
+        
+        # Discover MCP tools if requested
+        if use_mcps and self.mcp:
+            discovered_mcp_tools = self.mcp.discover_tools(force_refresh=True)
+            if isinstance(use_mcps, list):
+                # Filter for specific MCP tools
+                available_tools.extend([t for t in discovered_mcp_tools if t['name'] in use_mcps])
+            else: # use_mcps is True
+                available_tools.extend(discovered_mcp_tools)
+        
+        # Define and add RAG tools if requested
+        if use_data_store:
+            for store_name, _ in use_data_store.items():
+                rag_tool_definition = {
+                    "name": f"research::{store_name}",
+                    "description": (
+                        f"Queries the '{store_name}' information database to find relevant text chunks based on a natural language query. "
+                        "Use this to gather information, answer questions, or find context for a task before using other tools."
+                    ),
+                    "input_schema": {
+                        "type": "object",
+                        "properties": {
+                            "query": {
+                                "type": "string",
+                                "description": "The natural language query to search for. Be specific to get the best results."
+                            }
+                        },
+                        "required": ["query"]
                     }
-                },
-                "required": ["query"]
-            }
-        }
-        available_tools = [rag_tool_definition] + mcp_tools
+                }
+                available_tools.append(rag_tool_definition)
+        
+        if not available_tools:
+            # If no tools are available, just do a simple text generation
+            final_answer_text = self.generate_text(prompt=prompt, system_prompt=system_prompt, stream=streaming_callback is not None, streaming_callback=streaming_callback)
+            return {"final_answer": self.remove_thinking_blocks(final_answer_text), "tool_calls": [], "error": None}
+
 
-        # --- 2. Optional Initial Objectives Extraction ---
         formatted_tools_list = "\n".join([
             f"- Full Tool Name: {t.get('name')}\n  Description: {t.get('description')}\n  Input Schema: {json.dumps(t.get('input_schema'))}"
             for t in available_tools
-        ])        
+        ])
+
+        # --- 2. Optional Initial Objectives Extraction ---
         if build_plan:
             if streaming_callback:
                 streaming_callback("Extracting initial objectives...", MSG_TYPE.MSG_TYPE_STEP_START, {"id": "objectives_extraction"}, turn_history)
             
-            # The enhanced prompt is placed inside the original parenthesis format.
-            # The f-strings for tool lists and user prompts are preserved.
-
             obj_prompt = (
                 "You are a hyper-efficient and logical project planner. Your sole purpose is to analyze the user's request and create a concise, numbered list of actionable steps to fulfill it.\n\n"
                 "Your plan must be the most direct and minimal path to the user's goal.\n\n"
@@ -1390,8 +1546,6 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
 
         turn_history.append({"type": "initial_objectives", "content": current_objectives})
 
-
-
         # --- 3. Main Agent Loop ---
         while llm_iterations < max_llm_iterations:
             llm_iterations += 1
@@ -1403,15 +1557,19 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             if agent_work_history:
                 history_parts = []
                 for i, entry in enumerate(agent_work_history):
+                    # Sanitize the result for history display, similar to knowledge synthesis
+                    sanitized_hist_result = entry['tool_result'].copy()
+                    if 'image_base64' in sanitized_hist_result: sanitized_hist_result.pop('image_base64')
+                    if 'content' in sanitized_hist_result and len(sanitized_hist_result['content']) > 200: sanitized_hist_result['content'] = sanitized_hist_result['content'][:200] + '... (truncated)'
+
                     history_parts.append(
                         f"### Step {i+1}:\n"
                         f"**Thought:** {entry['thought']}\n"
                         f"**Action:** Called tool `{entry['tool_name']}` with parameters `{json.dumps(entry['tool_params'])}`\n"
-                        f"**Observation:**\n```json\n{json.dumps(entry['tool_result'], indent=2)}\n```"
+                        f"**Observation:**\n```json\n{json.dumps(sanitized_hist_result, indent=2)}\n```"
                     )
                 formatted_agent_history = "\n\n".join(history_parts)
 
-            # Construct the "Thinking & Planning" prompt
             decision_prompt_template = f"""You are a strategic AI assistant. Your goal is to achieve a set of objectives by intelligently using research and system tools.
 
 --- AVAILABLE TOOLS ---
@@ -1431,50 +1589,47 @@ Knowledge Scratchpad (our current understanding):
 --- INSTRUCTIONS ---
 1.  **Analyze:** Review the entire work history, objectives, and scratchpad.
 2.  **Update State:** Based on the latest observations, update the scratchpad and refine the objectives. The scratchpad should be a comprehensive summary of ALL knowledge gathered.
-3.  **Decide Next Action:** Choose ONE of the following: `call_tool`, `final_answer`, or `clarify`. Always prefer to gather information with `research::query_database` before attempting to use other tools if you lack context.
-
---- OUTPUT FORMAT ---
-Respond with a single JSON object inside a JSON markdown tag. Use this exact schema:
-```json
-{{
-    "thought": "Your reasoning for the chosen action, analyzing how the work history informs your next step. Explain why you are choosing a specific tool (or to answer).",
-    "updated_scratchpad": "The new, complete, and comprehensive summary of all knowledge gathered. Integrate new findings with old ones. if no new knowledge is gathered, this should be an empty string.",
-    "updated_objectives": "The full, potentially revised, list of objectives. If no change, repeat the current list.",
-    "action": "The chosen action: 'call_tool', 'final_answer', or 'clarify'.",
-    "tool_name": "(string, if action is 'call_tool') The full 'alias::tool_name' of the tool to use.",
-    "tool_params": {{"query": "...", "param2": "..."}},
-    "clarification_request": "(string, if action is 'clarify') Your question to the user."
-}}
-```
+3.  **Decide Next Action:** Choose ONE of the following: `call_tool`, `final_answer`, or `clarify`. Always prefer to gather information with a `research::` tool before attempting to use other tools if you lack context.
 """
-            raw_llm_decision_json = self.generate_text(
-                prompt=decision_prompt_template, n_predict=2048, temperature=tool_call_decision_temperature
+            decision_template = {
+                "thought": "Your reasoning for the chosen action, analyzing how the work history informs your next step. Explain why you are choosing a specific tool (or to answer).",
+                "updated_scratchpad": "The new, complete, and comprehensive summary of all knowledge gathered. Integrate new findings with old ones. If no new knowledge is gathered, this should be an empty string.",
+                "updated_objectives": "The full, potentially revised, list of objectives. If no change, repeat the current list.",
+                "action": "The chosen action: 'call_tool', 'final_answer', or 'clarify'.",
+                "action_details": {
+                    "tool_name": "(string, if action is 'call_tool') The full 'alias::tool_name' of the tool to use.",
+                    "tool_params": {"query": "...", "param2": "..."},
+                    "clarification_request": "(string, if action is 'clarify') Your question to the user."
+                }
+            }
+            llm_decision = self.generate_structured_content(
+                prompt=decision_prompt_template, 
+                template=decision_template,
+                temperature=tool_call_decision_temperature
             )
+            
+            if not llm_decision:
+                ASCIIColors.error("LLM failed to generate a valid decision JSON. Aborting loop.")
+                break
 
             # --- 4. Parse LLM's plan and update state ---
-            try:
-                llm_decision = robust_json_parser(raw_llm_decision_json)
-                turn_history.append({"type": "llm_plan", "content": llm_decision})
-                
-                current_objectives = llm_decision.get("updated_objectives", current_objectives)
-                new_scratchpad = llm_decision.get("updated_scratchpad")
-                
-                if new_scratchpad and new_scratchpad != knowledge_scratchpad:
-                    knowledge_scratchpad = new_scratchpad
-                    if streaming_callback:
-                        streaming_callback(f"Knowledge scratchpad updated.", MSG_TYPE.MSG_TYPE_STEP, {"id": "scratchpad_update"}, turn_history)
-                        streaming_callback(f"New Scratchpad:\n{knowledge_scratchpad}", MSG_TYPE.MSG_TYPE_INFO, {"id":"scratch_pad_update"}, turn_history)
-                
-            except (json.JSONDecodeError, AttributeError, KeyError) as e:
-                ASCIIColors.error(f"Failed to parse LLM decision JSON: {raw_llm_decision_json}. Error: {e}")
-                turn_history.append({"type": "error", "content": f"Failed to parse LLM plan: {raw_llm_decision_json}"})
-                break
+            turn_history.append({"type": "llm_plan", "content": llm_decision})
+            
+            current_objectives = llm_decision.get("updated_objectives", current_objectives)
+            new_scratchpad = llm_decision.get("updated_scratchpad")
+            
+            if new_scratchpad and new_scratchpad.strip() and new_scratchpad != knowledge_scratchpad:
+                knowledge_scratchpad = new_scratchpad
+                if streaming_callback:
+                    streaming_callback(f"Knowledge scratchpad updated.", MSG_TYPE.MSG_TYPE_STEP, {"id": "scratchpad_update"}, turn_history)
+                    streaming_callback(f"New Scratchpad:\n{knowledge_scratchpad}", MSG_TYPE.MSG_TYPE_INFO, {"id":"scratch_pad_update"}, turn_history)
 
             if streaming_callback:
                 streaming_callback(f"LLM thought: {llm_decision.get('thought', 'N/A')}", MSG_TYPE.MSG_TYPE_INFO, {"id": "llm_thought"}, turn_history)
 
             # --- 5. Execute the chosen action ---
             action = llm_decision.get("action")
+            action_details = llm_decision.get("action_details", {})
             tool_result = None
 
             if action == "call_tool":
@@ -1482,40 +1637,53 @@ Respond with a single JSON object inside a JSON markdown tag. Use this exact sch
                     ASCIIColors.warning("Max tool calls reached. Forcing final answer.")
                     break
 
-                tool_name = llm_decision.get("tool_name")
-                tool_params = llm_decision.get("tool_params", {})
+                tool_name = action_details.get("tool_name")
+                tool_params = action_details.get("tool_params", {})
 
                 if not tool_name or not isinstance(tool_params, dict):
                     ASCIIColors.error(f"Invalid tool call from LLM: name={tool_name}, params={tool_params}")
                     break
 
                 if streaming_callback:
-                    streaming_callback(f"Executing tool: {tool_name}...", MSG_TYPE.MSG_TYPE_STEP_START, {"id": f"tool_exec_{llm_iterations}"}, turn_history)
+                    streaming_callback(f"Executing tool: {tool_name}...", MSG_TYPE.MSG_TYPE_STEP_START, {"id": f"tool_exec_{llm_iterations}", "tool_name": tool_name}, turn_history)
                 
                 try:
                     # ** DYNAMIC TOOL/RAG DISPATCH **
-                    if tool_name == "research::query_database":
-                        query = tool_params.get("query")
-                        if not query:
-                            tool_result = {"error": "RAG tool called without a 'query' parameter."}
+                    if tool_name.startswith("research::") and use_data_store:
+                        store_name = tool_name.split("::")[1]
+                        rag_query_function_local = use_data_store.get(store_name)
+                        if not rag_query_function_local:
+                            tool_result = {"error": f"RAG data store '{store_name}' not found or provided."}
                         else:
-                            retrieved_chunks = rag_query_function(query, rag_vectorizer_name, rag_top_k, rag_min_similarity_percent)
-                            if not retrieved_chunks:
-                                tool_result = {"summary": "No relevant documents found for the query.", "chunks": []}
+                            query = tool_params.get("query")
+                            if not query:
+                                tool_result = {"error": "RAG tool called without a 'query' parameter."}
                             else:
-                                tool_result = {
-                                    "summary": f"Found {len(retrieved_chunks)} relevant document chunks.",
-                                    "chunks": retrieved_chunks
-                                }
-                    else:
+                                retrieved_chunks = rag_query_function_local.get("callable", lambda: {'Search error'})(query, rag_top_k, rag_min_similarity_percent)
+                                if not retrieved_chunks:
+                                    tool_result = {"summary": "No relevant documents found for the query.", "chunks": []}
+                                else:
+                                    tool_result = {
+                                        "summary": f"Found {len(retrieved_chunks)} relevant document chunks.",
+                                        "chunks": retrieved_chunks
+                                    }
+                    elif use_mcps and self.mcp:
                         # Standard MCP tool execution
                         tool_result = self.mcp.execute_tool(tool_name, tool_params, lollms_client_instance=self)
+                    else:
+                        tool_result = {"error": f"Tool '{tool_name}' cannot be executed. RAG store not found or MCP binding not configured."}
                 
                 except Exception as e_exec:
                     trace_exception(e_exec)
                     tool_result = {"error": f"An exception occurred while executing tool '{tool_name}': {e_exec}"}
 
-                # Record the work cycle in the agent's history
+                if streaming_callback:
+                    streaming_callback(f"Tool {tool_name} finished.", MSG_TYPE.MSG_TYPE_STEP_END, {"id": f"tool_exec_{llm_iterations}", "result": tool_result}, turn_history)
+                
+                knowledge_scratchpad = self._synthesize_knowledge(knowledge_scratchpad, tool_name, tool_params, tool_result)
+                if streaming_callback:
+                    streaming_callback(f"Knowledge scratchpad updated after {tool_name} call.", MSG_TYPE.MSG_TYPE_INFO, {"id": "scratchpad_update"}, turn_history)
+
                 work_entry = {
                     "thought": llm_decision.get("thought", "N/A"),
                     "tool_name": tool_name,
@@ -1524,13 +1692,9 @@ Respond with a single JSON object inside a JSON markdown tag. Use this exact sch
                 }
                 agent_work_history.append(work_entry)
                 tool_calls_made_this_turn.append({"name": tool_name, "params": tool_params, "result": tool_result})
-                
-                if streaming_callback:
-                    streaming_callback(f"Tool {tool_name} finished.", MSG_TYPE.MSG_TYPE_STEP_END, {"id": f"tool_exec_{llm_iterations}"}, turn_history)
-                    streaming_callback(json.dumps(tool_result, indent=2), MSG_TYPE.MSG_TYPE_TOOL_OUTPUT, tool_result, turn_history)
 
             elif action == "clarify":
-                clarification_request = llm_decision.get("clarification_request", "I need more information. Could you please clarify?")
+                clarification_request = action_details.get("clarification_request", "I need more information. Could you please clarify?")
                 return {"final_answer": clarification_request, "tool_calls": tool_calls_made_this_turn, "error": None, "clarification": True}
 
             elif action == "final_answer":
@@ -1544,7 +1708,8 @@ Respond with a single JSON object inside a JSON markdown tag. Use this exact sch
                 streaming_callback(f"LLM reasoning step (iteration {llm_iterations})...", MSG_TYPE.MSG_TYPE_STEP_END, {"id": f"planning_step_{llm_iterations}"}, turn_history)
        
         if streaming_callback:
-            streaming_callback(f"LLM reasoning step (iteration {llm_iterations})...", MSG_TYPE.MSG_TYPE_STEP_END, {"id": f"planning_step_{llm_iterations}"}, turn_history)
+             streaming_callback(f"LLM reasoning loop finished.", MSG_TYPE.MSG_TYPE_STEP, {"id": "reasoning_loop_end"}, turn_history)
+
         # --- 6. Generate Final Answer ---
         if streaming_callback:
             streaming_callback("Synthesizing final answer...", MSG_TYPE.MSG_TYPE_STEP_START, {"id": "final_answer_synthesis"}, turn_history)
@@ -1579,7 +1744,8 @@ Original User Request: "{original_user_prompt}"
         turn_history.append({"type":"final_answer_generated", "content": final_answer})
         
         return {"final_answer": final_answer, "tool_calls": tool_calls_made_this_turn, "error": None}
-
+    
+    
     def generate_code(
                         self,
                         prompt,

lollms_client/lollms_discussion.py

@@ -26,10 +26,10 @@ try:
 except ImportError:
     ENCRYPTION_AVAILABLE = False
 
+from lollms_client.lollms_types import MSG_TYPE
 # Type hint placeholders for classes defined externally
 if False: 
     from lollms_client import LollmsClient
-    from lollms_client.lollms_types import MSG_TYPE
     from lollms_personality import LollmsPersonality
 
 class EncryptedString(TypeDecorator):
@@ -341,102 +341,162 @@ class LollmsDiscussion:
             current_id = msg_orm.parent_id
         return [LollmsMessage(self, orm) for orm in reversed(branch_orms)]
 
-    def chat(self, user_message: str, personality: Optional['LollmsPersonality'] = None, **kwargs) -> LollmsMessage:
+
+
+    def chat(
+        self, 
+        user_message: str, 
+        personality: Optional['LollmsPersonality'] = None,
+        use_mcps: Union[None, bool, List[str]] = None,
+        use_data_store: Union[None, Dict[str, Callable]] = None,
+        build_plan: bool = True,
+        add_user_message: bool = True, # New parameter
+        max_tool_calls = 10,
+        rag_top_k = 5,
+        **kwargs
+    ) -> Dict[str, 'LollmsMessage']: # Return type changed
+        """
+        Main interaction method for the discussion. It can perform a simple chat or
+        trigger a complex agentic loop with RAG and MCP tool use.
+
+        Args:
+            user_message (str): The new message from the user.
+            personality (Optional[LollmsPersonality], optional): The personality to use. Defaults to None.
+            use_mcps (Union[None, bool, List[str]], optional): Controls MCP tool usage. Defaults to None.
+            use_data_store (Union[None, Dict[str, Callable]], optional): Controls RAG usage. Defaults to None.
+            build_plan (bool, optional): If True, the agent will generate an initial plan. Defaults to True.
+            add_user_message (bool, optional): If True, a new user message is created from the prompt. 
+                If False, it assumes regeneration on the current active user message. Defaults to True.
+            **kwargs: Additional keyword arguments passed to the underlying generation method.
+
+        Returns:
+            Dict[str, LollmsMessage]: A dictionary with 'user_message' and 'ai_message' objects.
+        """
         if self.max_context_size is not None:
             self.summarize_and_prune(self.max_context_size)
 
-        if user_message:
-            self.add_message(sender="user", sender_type="user", content=user_message)
-
+        # Add user message to the discussion or get the existing one
+        if add_user_message:
+            # Pass kwargs to capture images, etc., sent from the router
+            user_msg = self.add_message(sender="user", sender_type="user", content=user_message, **kwargs)
+        else:
+            # We are regenerating. The current active branch tip must be the user message.
+            if self.active_branch_id not in self._message_index:
+                raise ValueError("Regeneration failed: active branch tip not found or is invalid.")
+            user_msg_orm = self._message_index[self.active_branch_id]
+            if user_msg_orm.sender_type != 'user':
+                raise ValueError(f"Regeneration failed: active branch tip is a '{user_msg_orm.sender_type}' message, not 'user'.")
+            user_msg = LollmsMessage(self, user_msg_orm)
+        
+        # --- (The existing generation logic remains the same) ---
+        is_agentic_turn = (use_mcps is not None and len(use_mcps)>0) or (use_data_store is not None and len(use_data_store)>0)
         rag_context = None
         original_system_prompt = self.system_prompt
         if personality:
             self.system_prompt = personality.system_prompt
-            if user_message:
+            if user_message and not is_agentic_turn:
                 rag_context = personality.get_rag_context(user_message)
-        
         if rag_context:
             self.system_prompt = f"{original_system_prompt or ''}\n\n--- Relevant Information ---\n{rag_context}\n---"
-
-        from lollms_client.lollms_types import MSG_TYPE
-        is_streaming = "streaming_callback" in kwargs and kwargs.get("streaming_callback") is not None
-        
-        final_raw_response = ""
         start_time = datetime.now()
-
-        if personality and personality.script_module and hasattr(personality.script_module, 'run'):
-            try:
-                print(f"[{personality.name}] Running custom script...")
-                final_raw_response = personality.script_module.run(self, kwargs.get("streaming_callback"))
-            except Exception as e:
-                print(f"[{personality.name}] Error in custom script: {e}")
-                final_raw_response = f"Error executing personality script: {e}"
+        if is_agentic_turn:
+            # --- FIX: Provide the full conversation context to the agent ---
+            # 1. Get the model's max context size.
+            max_ctx = self.lollmsClient.binding.get_ctx_size(self.lollmsClient.binding.model_name) if self.lollmsClient.binding else None
+            
+            # 2. Format the entire discussion up to this point, including the new user message.
+            #    This ensures the agent has the full history.
+            full_context_prompt = self.format_discussion(max_allowed_tokens=max_ctx)
+
+            # 3. Call the agent with the complete context.
+            #    We pass the full context to the 'prompt' argument. The `system_prompt` is already
+            #    included within the formatted text, so we don't pass it separately to avoid duplication.
+            agent_result = self.lollmsClient.generate_with_mcp_rag(
+                prompt=full_context_prompt, 
+                use_mcps=use_mcps, 
+                use_data_store=use_data_store, 
+                build_plan=build_plan,
+                max_tool_calls = max_tool_calls,
+                rag_top_k= rag_top_k,
+                **kwargs
+            )
+            final_content = agent_result.get("final_answer", "")
+            thoughts_text = None 
+            final_raw_response = json.dumps(agent_result)
         else:
-            raw_response_accumulator = []
-            if is_streaming:
-                full_response_parts, token_buffer, in_thought_block = [], "", False
-                original_callback = kwargs.get("streaming_callback")
-                def accumulating_callback(token: str, msg_type: MSG_TYPE = MSG_TYPE.MSG_TYPE_CHUNK):
-                    nonlocal token_buffer, in_thought_block
-                    raw_response_accumulator.append(token)
-                    continue_streaming = True
-                    if token: token_buffer += token
-                    while True:
-                        if in_thought_block:
-                            end_tag_pos = token_buffer.find("</think>")
-                            if end_tag_pos != -1:
-                                thought_chunk = token_buffer[:end_tag_pos]
-                                if self.show_thoughts and original_callback and thought_chunk:
-                                    if not original_callback(thought_chunk, MSG_TYPE.MSG_TYPE_THOUGHT_CHUNK): continue_streaming = False
-                                in_thought_block, token_buffer = False, token_buffer[end_tag_pos + len("</think>"):]
-                            else:
-                                if self.show_thoughts and original_callback and token_buffer:
-                                    if not original_callback(token_buffer, MSG_TYPE.MSG_TYPE_THOUGHT_CHUNK): continue_streaming = False
-                                token_buffer = ""; break
-                        else:
-                            start_tag_pos = token_buffer.find("<think>")
-                            if start_tag_pos != -1:
-                                response_chunk = token_buffer[:start_tag_pos]
-                                if response_chunk:
-                                    full_response_parts.append(response_chunk)
-                                    if original_callback:
-                                        if not original_callback(response_chunk, MSG_TYPE.MSG_TYPE_CHUNK): continue_streaming = False
-                                in_thought_block, token_buffer = True, token_buffer[start_tag_pos + len("<think>"):]
-                            else:
-                                if token_buffer:
-                                    full_response_parts.append(token_buffer)
-                                    if original_callback:
-                                        if not original_callback(token_buffer, MSG_TYPE.MSG_TYPE_CHUNK): continue_streaming = False
-                                token_buffer = ""; break
-                    return continue_streaming
-                kwargs["streaming_callback"], kwargs["stream"] = accumulating_callback, True
-                self.lollmsClient.chat(self, **kwargs)
-                final_raw_response = "".join(raw_response_accumulator)
+            if personality and personality.script_module and hasattr(personality.script_module, 'run'):
+                try:
+                    final_raw_response = personality.script_module.run(self, kwargs.get("streaming_callback"))
+                except Exception as e:
+                    final_raw_response = f"Error executing personality script: {e}"
             else:
-                kwargs["stream"] = False
-                final_raw_response = self.lollmsClient.chat(self, **kwargs) or ""
-
-        end_time = datetime.now()
-        if rag_context:
+                is_streaming = "streaming_callback" in kwargs and kwargs.get("streaming_callback") is not None
+                if is_streaming:
+                    raw_response_accumulator = self.lollmsClient.chat(self, **kwargs)
+                    final_raw_response = "".join(raw_response_accumulator)
+                else:
+                    kwargs["stream"] = False
+                    final_raw_response = self.lollmsClient.chat(self, **kwargs) or ""
+            thoughts_match = re.search(r"<think>(.*?)</think>", final_raw_response, re.DOTALL)
+            thoughts_text = thoughts_match.group(1).strip() if thoughts_match else None
+            final_content = self.lollmsClient.remove_thinking_blocks(final_raw_response)
+        if rag_context or (personality and self.system_prompt != original_system_prompt):
             self.system_prompt = original_system_prompt
-        
+        end_time = datetime.now()
         duration = (end_time - start_time).total_seconds()
-        thoughts_match = re.search(r"<think>(.*?)</think>", final_raw_response, re.DOTALL)
-        thoughts_text = thoughts_match.group(1).strip() if thoughts_match else None
-        final_content = self.lollmsClient.remove_thinking_blocks(final_raw_response)
         token_count = self.lollmsClient.count_tokens(final_content)
         tok_per_sec = (token_count / duration) if duration > 0 else 0
-        
+        # --- (End of existing logic) ---
+
+        # --- FIX: Store agentic results in metadata ---
+        message_meta = {}
+        if is_agentic_turn and isinstance(agent_result, dict):
+            # We store the 'steps' and 'sources' if they exist in the agent result.
+            # This makes them available to the frontend in the final message object.
+            if "steps" in agent_result:
+                message_meta["steps"] = agent_result["steps"]
+            if "sources" in agent_result:
+                message_meta["sources"] = agent_result["sources"]
+
         ai_message_obj = self.add_message(
-            sender="assistant", sender_type="assistant", content=final_content,
+            sender=personality.name if personality else "assistant", sender_type="assistant", content=final_content,
             raw_content=final_raw_response, thoughts=thoughts_text, tokens=token_count,
             binding_name=self.lollmsClient.binding.binding_name, model_name=self.lollmsClient.binding.model_name,
-            generation_speed=tok_per_sec
+            generation_speed=tok_per_sec,
+            parent_id=user_msg.id, # Ensure the AI response is a child of the user message
+            metadata=message_meta # Pass the collected metadata here
         )
-
-        if self._is_db_backed and not self.autosave:
+        if self._is_db_backed and self.autosave:
             self.commit()
-        return ai_message_obj
+            
+        return {"user_message": user_msg, "ai_message": ai_message_obj}
+
+    def regenerate_branch(self, **kwargs) -> Dict[str, 'LollmsMessage']:
+        if not self.active_branch_id or self.active_branch_id not in self._message_index:
+            raise ValueError("No active message to regenerate from.")
+        
+        last_message_orm = self._message_index[self.active_branch_id]
+        
+        # If the current active message is the assistant's, we need to delete it
+        # and set the active branch to its parent (the user message).
+        if last_message_orm.sender_type == 'assistant':
+            parent_id = last_message_orm.parent_id
+            if not parent_id:
+                raise ValueError("Cannot regenerate from an assistant message with no parent.")
+                
+            last_message_id = last_message_orm.id
+            self._db_discussion.messages.remove(last_message_orm)
+            del self._message_index[last_message_id]
+            if self._is_db_backed:
+                self._messages_to_delete_from_db.add(last_message_id)
+            
+            self.active_branch_id = parent_id
+            self.touch()
+
+        # The active branch is now guaranteed to be on a user message.
+        # Call chat, but do not add a new user message.
+        prompt_to_regenerate = self._message_index[self.active_branch_id].content
+        return self.chat(user_message=prompt_to_regenerate, add_user_message=False, **kwargs)
 
     def process_and_summarize(self, large_text: str, user_prompt: str, chunk_size: int = 4096, **kwargs) -> LollmsMessage:
         user_msg = self.add_message(sender="user", sender_type="user", content=user_prompt)
@@ -459,20 +519,6 @@ class LollmsDiscussion:
             self.commit()
         return ai_message_obj
 
-    def regenerate_branch(self, **kwargs) -> LollmsMessage:
-        if not self.active_branch_id or self.active_branch_id not in self._message_index:
-            raise ValueError("No active message to regenerate from.")
-        last_message_orm = self._message_index[self.active_branch_id]
-        if last_message_orm.sender_type != 'assistant':
-            raise ValueError("Can only regenerate from an assistant's message.")
-        parent_id, last_message_id = last_message_orm.parent_id, last_message_orm.id
-        self._db_discussion.messages.remove(last_message_orm)
-        del self._message_index[last_message_id]
-        if self._is_db_backed:
-            self._messages_to_delete_from_db.add(last_message_id)
-        self.active_branch_id = parent_id
-        self.touch()
-        return self.chat("", **kwargs)
 
     def delete_branch(self, message_id: str):
         if not self._is_db_backed:

lollms_client/lollms_llm_binding.py

@@ -115,6 +115,9 @@ class LollmsLLMBinding(ABC):
         """
         pass
 
+    def get_ctx_size(self, model_name):
+        return 32000
+
 
     @abstractmethod
     def tokenize(self, text: str) -> list:

lollms_client/lollms_types.py

@@ -63,4 +63,4 @@ class ELF_COMPLETION_FORMAT(Enum):
             raise ValueError(f"Invalid format string: {format_string}. Must be one of {list(format_mapping.keys())}.")
     
     def __str__(self):
-        return self.name    
+        return self.name    

{lollms_client-0.22.0.dist-info → lollms_client-0.23.0.dist-info}/METADATA

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

{lollms_client-0.22.0.dist-info → lollms_client-0.23.0.dist-info}/RECORD

@@ -1,16 +1,11 @@
 examples/console_discussion.py,sha256=JxjVaAxtt1WEXLN8vCJosu-cYNgfIX2JGO25kg1FFNY,20490
-examples/external_mcp.py,sha256=swx1KCOz6jk8jGTAycq-xu7GXPAhRMDe1x--SKocugE,13371
 examples/function_calling_with_local_custom_mcp.py,sha256=g6wOFRB8-p9Cv7hKmQaGzPvtMX3H77gas01QVNEOduM,12407
 examples/generate_a_benchmark_for_safe_store.py,sha256=bkSt0mrpNsN0krZAUShm0jgVM1ukrPpjI7VwSgcNdSA,3974
 examples/generate_text_with_multihop_rag_example.py,sha256=riEyVYo97r6ZYdySL-NJkRhE4MnpwbZku1sN8RNvbvs,11519
 examples/gradio_chat_app.py,sha256=ZZ_D1U0wvvwE9THmAPXUvNKkFG2gi7tQq1f2pQx_2ug,15315
 examples/gradio_lollms_chat.py,sha256=z5FDE62dmPU3nb16zbZX6jkVitML1PMfPxYyWr8VLz8,10135
 examples/internet_search_with_rag.py,sha256=ioTb_WI2M6kFeh1Dg-EGcKjccphnCsIGD_e9PZgZshw,12314
-examples/local_mcp.py,sha256=w40dgayvHYe01yvekEE0LjcbkpwKjWwJ-9v4_wGYsUk,9113
 examples/lollms_discussions_test.py,sha256=Jk1cCUDBBhTcK5glI50jAgzfB3IOiiUlnK3q7RYfMkA,6796
-examples/openai_mcp.py,sha256=7IEnPGPXZgYZyiES_VaUbQ6viQjenpcUxGiHE-pGeFY,11060
-examples/run_remote_mcp_example copy.py,sha256=pGT8A5iXK9oHtjGNEUCm8fnj9DQ37gcznjLYqAEI20o,10075
-examples/run_standard_mcp_example.py,sha256=GSZpaACPf3mDPsjA8esBQVUsIi7owI39ca5avsmvCxA,9419
 examples/simple_text_gen_test.py,sha256=RoX9ZKJjGMujeep60wh5WT_GoBn0O9YKJY6WOy-ZmOc,8710
 examples/simple_text_gen_with_image_test.py,sha256=rR1O5Prcb52UHtJ3c6bv7VuTd1cvbkr5aNZU-v-Rs3Y,9263
 examples/text_2_audio.py,sha256=MfL4AH_NNwl6m0I0ywl4BXRZJ0b9Y_9fRqDIe6O-Sbw,3523
@@ -24,13 +19,18 @@ examples/deep_analyze/deep_analyse.py,sha256=fZNmDrfEAuxEAfdbjAgJYIh1k6wbiuZ4Rvw
 examples/deep_analyze/deep_analyze_multiple_files.py,sha256=fOryShA33P4IFxcxUDe-nJ2kW0v9w9yW8KsToS3ETl8,1032
 examples/generate_and_speak/generate_and_speak.py,sha256=RAlvRwtEKXCh894l9M3iQbADe8CvF5N442jtRurK02I,13908
 examples/generate_game_sfx/generate_game_fx.py,sha256=MgLNGi4hGBRoyr4bqYuCUdCSqd-ldDVfF0VSDUjgzsg,10467
+examples/mcp_examples/external_mcp.py,sha256=swx1KCOz6jk8jGTAycq-xu7GXPAhRMDe1x--SKocugE,13371
+examples/mcp_examples/local_mcp.py,sha256=w40dgayvHYe01yvekEE0LjcbkpwKjWwJ-9v4_wGYsUk,9113
+examples/mcp_examples/openai_mcp.py,sha256=7IEnPGPXZgYZyiES_VaUbQ6viQjenpcUxGiHE-pGeFY,11060
+examples/mcp_examples/run_remote_mcp_example_v2.py,sha256=bbNn93NO_lKcFzfIsdvJJijGx2ePFTYfknofqZxMuRM,14626
+examples/mcp_examples/run_standard_mcp_example.py,sha256=GSZpaACPf3mDPsjA8esBQVUsIi7owI39ca5avsmvCxA,9419
 examples/test_local_models/local_chat.py,sha256=slakja2zaHOEAUsn2tn_VmI4kLx6luLBrPqAeaNsix8,456
-lollms_client/__init__.py,sha256=Cd4G7paIm0kKNqc90yAJ7VJ8mpi2jfzoMBabmWRBZbY,1047
+lollms_client/__init__.py,sha256=NPKqkS85rJkCPyOZt06EJpLHhQEiopFnON4xF0kXwJ8,1047
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=y_KIVFCBsA0BYizGAbvQZrtWZCX5jB00yMuAgHlHaD4,143685
-lollms_client/lollms_discussion.py,sha256=zdAUOhbFod65-VZYfKaldHYURR7wWnuccqv6FJa1qrM,36291
+lollms_client/lollms_core.py,sha256=xG5Fdm21a4rTq4m1UAh9G0FYFssjfdSI5s2mQLkKeXQ,153747
+lollms_client/lollms_discussion.py,sha256=Z5Hs_faRdxldf4CbbjNSCdJ8FYnGEgL8wV43ZtanCUI,38685
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
-lollms_client/lollms_llm_binding.py,sha256=E81g4yBlQn76WTSLicnTETJuQhf_WZUMZaxotgRnOcA,12096
+lollms_client/lollms_llm_binding.py,sha256=Kpzhs5Jx8eAlaaUacYnKV7qIq2wbME5lOEtKSfJKbpg,12161
 lollms_client/lollms_mcp_binding.py,sha256=0rK9HQCBEGryNc8ApBmtOlhKE1Yfn7X7xIQssXxS2Zc,8933
 lollms_client/lollms_personality.py,sha256=dILUI5DZdzJ3NDDQiIsK2UptVF-jZK3XYXZ2bpXP_ew,8035
 lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_KonOMsADASxc,10246
@@ -39,7 +39,7 @@ lollms_client/lollms_tti_binding.py,sha256=afO0-d-Kqsmh8UHTijTvy6dZAt-XDB6R-IHmd
 lollms_client/lollms_ttm_binding.py,sha256=FjVVSNXOZXK1qvcKEfxdiX6l2b4XdGOSNnZ0utAsbDg,4167
 lollms_client/lollms_tts_binding.py,sha256=5cJYECj8PYLJAyB6SEH7_fhHYK3Om-Y3arkygCnZ24o,4342
 lollms_client/lollms_ttv_binding.py,sha256=KkTaHLBhEEdt4sSVBlbwr5i_g_TlhcrwrT-7DjOsjWQ,4131
-lollms_client/lollms_types.py,sha256=NfvTmICzRCgfjjy5zLMFeDaiW6zyUsdnxRF69gAEyAk,3110
+lollms_client/lollms_types.py,sha256=c2vkdmyCU5aCyOCfWmfJE-q74T8w1vHMzFoMy8453jY,3108
 lollms_client/lollms_utilities.py,sha256=qK5iNmrFD7NGaEVW3nCWT6AtEhLIVHCXMzEpYxG_M5w,11293
 lollms_client/llm_bindings/__init__.py,sha256=9sWGpmWSSj6KQ8H4lKGCjpLYwhnVdL_2N7gXCphPqh4,14
 lollms_client/llm_bindings/llamacpp/__init__.py,sha256=Qj5RvsgPeHGNfb5AEwZSzFwAp4BOWjyxmm9qBNtstrc,63716
@@ -78,9 +78,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.22.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-personalities/parrot.py,sha256=-HdbK1h7Ixvp8FX69Nv92Z_El6_UVtsF8WuAvNpKbfg,478
-lollms_client-0.22.0.dist-info/METADATA,sha256=71v2Qlp7tSyr_fL9I8Nw-9LLlncfuUkYgtJkK1EKayc,13374
-lollms_client-0.22.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.22.0.dist-info/top_level.txt,sha256=vgtOcmtJbKs9gEiIIPp2scIsvtvU2y5u3tngqlme1RU,37
-lollms_client-0.22.0.dist-info/RECORD,,
+lollms_client-0.23.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.23.0.dist-info/METADATA,sha256=62EWlcBzFSaYzS_288ZzzGMiXMhe2lmBCONfstVSYLk,13374
+lollms_client-0.23.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.23.0.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.23.0.dist-info/RECORD,,

{lollms_client-0.22.0.dist-info → lollms_client-0.23.0.dist-info}/top_level.txt

@@ -1,3 +1,2 @@
 examples
 lollms_client
-personalities

personalities/parrot.py

@@ -1,10 +0,0 @@
-
-def run(discussion, on_chunk_callback):
-    # This script overrides the normal chat flow.
-    user_message = discussion.get_branch(discussion.active_branch_id)[-1].content
-    response = f"Squawk! {user_message}! Squawk!"
-    if on_chunk_callback:
-        # We need to simulate the message type for the callback
-        from lollms_client import MSG_TYPE
-        on_chunk_callback(response, MSG_TYPE.MSG_TYPE_CHUNK)
-    return response # Return the full raw response