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

examples/gradio_chat_app.py

@@ -0,0 +1,228 @@
+# final_working_chat_app.py
+
+import sys
+import os
+import json
+import gradio as gr
+import requests
+from typing import List, Dict, Optional, Tuple
+
+# --- Dependency Installation ---
+try:
+    import pipmaster as pm
+    print("Pipmaster found. Ensuring dependencies are installed...")
+    pm.ensure_packages(["gradio", "requests", "ascii_colors"])
+except ImportError:
+    pass
+
+# --- Import Core Components ---
+try:
+    from lollms_client import LollmsClient
+    from lollms_client.lollms_discussion import LollmsDiscussion 
+    from ascii_colors import ASCIIColors
+except ImportError as e:
+    print(f"\nFATAL: A required library is missing.\nPlease ensure lollms-client and ascii_colors are installed.")
+    print(f"Error: {e}"); sys.exit(1)
+
+# --- Standalone Helper Functions for LollmsDiscussion ---
+def export_for_chatbot(discussion: Optional[LollmsDiscussion]) -> List[Dict[str, str]]:
+    if not discussion: return []
+    branch = discussion.get_branch(discussion.active_branch_id)
+    return [{"role": discussion.participants.get(msg.sender, "user"), "content": msg.content} for msg in branch]
+
+def render_discussion_tree(discussion: Optional[LollmsDiscussion]) -> str:
+    if not discussion or not discussion.messages: return "No messages yet."
+    tree_markdown = "### Discussion Tree\n\n"; root_ids = [msg.id for msg in discussion.messages if msg.parent_id is None]
+    def _render_node(node_id: str, depth: int) -> str:
+        node = discussion.message_index.get(node_id)
+        if not node: return ""
+        is_active = "  <span class='activ'>[ACTIVE]</span>" if node.id == discussion.active_branch_id else ""
+        line = f"{'    ' * depth}- **{node.sender}**: _{node.content.replace(chr(10), ' ').strip()[:60]}..._{is_active}\n"
+        for child_id in discussion.children_index.get(node.id, []): line += _render_node(child_id, depth + 1)
+        return line
+    for root_id in root_ids: tree_markdown += _render_node(root_id, 0)
+    return tree_markdown
+
+def get_message_choices(discussion: Optional[LollmsDiscussion]) -> List[tuple]:
+    if not discussion: return []
+    return [(f"{msg.sender}: {msg.content[:40]}...", msg.id) for msg in discussion.messages]
+
+# --- Configuration & File Management ---
+CONFIG_FILE = "config.json"; DISCUSSIONS_DIR = "discussions"; os.makedirs(DISCUSSIONS_DIR, exist_ok=True)
+DEFAULT_CONFIG = {"binding_name": "ollama", "model_name": "mistral:latest", "host_address": "http://localhost:11434", "openai_api_key": "", "openai_model_name": "gpt-4o"}
+def load_config() -> Dict:
+    if os.path.exists(CONFIG_FILE):
+        try:
+            with open(CONFIG_FILE, 'r') as f: ASCIIColors.info(f"Loaded config from {CONFIG_FILE}"); return json.load(f)
+        except: ASCIIColors.warning(f"Could not load {CONFIG_FILE}, using defaults."); return DEFAULT_CONFIG
+    return DEFAULT_CONFIG
+def save_config(config: Dict):
+    with open(CONFIG_FILE, 'w') as f: json.dump(config, f, indent=2); ASCIIColors.green(f"Saved config to {CONFIG_FILE}")
+
+# --- LollmsClient & Discussion Management ---
+def create_lollms_client(config: Dict) -> Optional[LollmsClient]:
+    try:
+        if config["binding_name"] == "ollama": client = LollmsClient(binding_name="ollama", host_address=config["host_address"], model_name=config["model_name"])
+        elif config["binding_name"] == "openai":
+            if not config.get("openai_api_key"): gr.Warning("OpenAI API key missing."); return None
+            client = LollmsClient(binding_name="openai", model_name=config["openai_model_name"], service_key=config["openai_api_key"])
+        else: gr.Warning(f"Unsupported binding: {config['binding_name']}"); return None
+        ASCIIColors.green("LollmsClient created successfully."); return client
+    except Exception as e: gr.Error(f"Failed to create LollmsClient: {e}"); return None
+def get_discussions_list() -> List[str]: return sorted([f for f in os.listdir(DISCUSSIONS_DIR) if f.endswith(".yaml")])
+def load_discussion(filename: str, client: LollmsClient) -> Optional[LollmsDiscussion]:
+    if not client: ASCIIColors.warning("Cannot load discussion: client is not initialized."); return None
+    try:
+        discussion = LollmsDiscussion(client); discussion.load_from_disk(os.path.join(DISCUSSIONS_DIR, filename))
+        ASCIIColors.info(f"Loaded discussion: {filename}"); return discussion
+    except Exception as e: gr.Error(f"Failed to load discussion {filename}: {e}"); return None
+def list_ollama_models(host: str) -> List[str]:
+    try:
+        r = requests.get(f"{host}/api/tags"); r.raise_for_status(); return [m["name"] for m in r.json().get("models", [])]
+    except: gr.Warning(f"Could not fetch models from {host}."); return []
+
+# --- Gradio UI & Logic ---
+with gr.Blocks(theme=gr.themes.Soft(), css=".activ { font-weight: bold; color: #FF4B4B; }") as demo:
+    client_state = gr.State()
+    discussion_state = gr.State()
+    
+    gr.Markdown("# 🌿 Multi-Branch Discussion App")
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📝 Session & Branch Management")
+            discussion_selector = gr.Dropdown(label="Load Discussion", interactive=True)
+            new_discussion_name = gr.Textbox(label="New Discussion Name", placeholder="Enter name and press Enter...")
+            delete_discussion_button = gr.Button("Delete Current Discussion", variant="stop")
+            branch_selector = gr.Dropdown(label="Select Message to Branch From", interactive=True)
+            discussion_tree_display = gr.Markdown("No discussion loaded.")
+        with gr.Column(scale=2):
+            with gr.Accordion("⚙️ Settings & System Prompt", open=False):
+                system_prompt_input = gr.Textbox(label="System Prompt", lines=3, interactive=True)
+                with gr.Row():
+                    binding_selector = gr.Radio(["ollama", "openai"], label="AI Binding")
+                    save_settings_button = gr.Button("Save Settings & Re-initialize", variant="primary")
+                with gr.Group(visible=True) as ollama_settings_group:
+                    ollama_host_input = gr.Textbox(label="Ollama Host Address"); ollama_model_selector = gr.Dropdown(label="Ollama Model", interactive=True); refresh_ollama_button = gr.Button("Refresh Ollama Models")
+                with gr.Group(visible=False) as openai_settings_group:
+                    openai_api_key_input = gr.Textbox(label="OpenAI API Key", type="password"); openai_model_selector = gr.Dropdown(choices=["gpt-4o", "gpt-4o-mini", "gpt-4-turbo"], label="OpenAI Model", interactive=True)
+            chatbot = gr.Chatbot(label="Conversation", height=600, type="messages")
+            user_input = gr.Textbox(show_label=False, placeholder="Type your message here...", lines=3)
+            send_button = gr.Button("Send", variant="primary")
+
+    # --- Event Handler Functions ---
+    def on_load():
+        config = load_config(); client = create_lollms_client(config)
+        discussions_list = get_discussions_list(); discussion = load_discussion(discussions_list[0], client) if discussions_list else (LollmsDiscussion(client) if client else None)
+        active_discussion_file = discussions_list[0] if discussions_list else None
+        
+        history = export_for_chatbot(discussion) if discussion else [{"role": "assistant", "content": "Welcome! Configure client in Settings and create a new chat."}]
+        tree = render_discussion_tree(discussion); branch_choices = get_message_choices(discussion)
+        sys_prompt = discussion.system_prompt if discussion else ""
+        active_branch_id = discussion.active_branch_id if discussion else None
+        is_ollama = config['binding_name'] == 'ollama'; ollama_models = list_ollama_models(config['host_address']) if is_ollama and client else []
+
+        return (client, discussion, gr.update(choices=discussions_list, value=active_discussion_file), config['binding_name'], 
+                gr.update(visible=is_ollama), gr.update(visible=not is_ollama), config['host_address'], 
+                gr.update(choices=ollama_models, value=config.get('model_name')), config['openai_api_key'], 
+                config.get('openai_model_name'), sys_prompt, history, tree, gr.update(choices=branch_choices, value=active_branch_id))
+
+    def handle_save_settings(binding, host, ollama_model, openai_key, openai_model):
+        config = {"binding_name": binding, "host_address": host, "model_name": ollama_model, "openai_api_key": openai_key, "openai_model_name": openai_model}
+        save_config(config); gr.Info("Settings saved! Reloading application..."); return on_load()
+
+    def handle_new_discussion(client, name):
+        if not client: gr.Error("Client not initialized."); return (gr.skip(),) * 5
+        if not name.strip(): gr.Warning("Provide a name."); return (gr.skip(),) * 5
+        filename = f"{name.strip().replace(' ', '_')}.yaml"
+        if os.path.exists(os.path.join(DISCUSSIONS_DIR, filename)): gr.Warning(f"Discussion '{name}' already exists."); return (gr.skip(),) * 5
+        discussion = LollmsDiscussion(client); discussion.set_participants({"user": "user", "assistant": "assistant"})
+        discussion.add_message("assistant", f"This is the beginning of '{name}'."); discussion.save_to_disk(os.path.join(DISCUSSIONS_DIR, filename))
+        return discussion, gr.update(choices=get_discussions_list(), value=filename), export_for_chatbot(discussion), render_discussion_tree(discussion), gr.update(choices=get_message_choices(discussion), value=discussion.active_branch_id)
+
+    def handle_load_discussion(client, filename):
+        if not client: gr.Error("Client not initialized."); return (gr.skip(),) * 5
+        if not filename: return (gr.skip(),) * 5
+        discussion = load_discussion(filename, client)
+        if not discussion: return (gr.skip(),) * 5
+        return discussion, discussion.system_prompt or "", export_for_chatbot(discussion), render_discussion_tree(discussion), gr.update(choices=get_message_choices(discussion), value=discussion.active_branch_id)
+
+    def handle_delete_discussion(filename):
+        if not filename: gr.Warning("No discussion selected to delete."); return (gr.skip(),) * 14
+        try:
+            os.remove(os.path.join(DISCUSSIONS_DIR, filename)); ASCIIColors.red(f"Deleted discussion: {filename}"); gr.Info(f"Deleted {filename}.")
+            return on_load()
+        except Exception as e:
+            gr.Error(f"Failed to delete file: {e}"); return (gr.skip(),) * 14
+
+    def handle_chat_submit(client, discussion, user_text, history, filename):
+        if not client: gr.Error("Client not initialized."); return
+        if not discussion: gr.Error("No discussion loaded."); return
+        if not user_text.strip(): return
+        if not filename: gr.Error("No active discussion file. Cannot save."); return
+        
+        parent_id = discussion.active_branch_id
+        discussion.add_message(sender="user", content=user_text, parent_id=parent_id)
+        history.append({"role": "user", "content": user_text}); history.append({"role": "assistant", "content": ""})
+        yield history
+        
+        full_response = ""
+        try:
+            # The callback must return True to continue the stream.
+            for chunk in client.chat(discussion, stream=True, streaming_callback=lambda c,t: True):
+                full_response += chunk; history[-1]["content"] = full_response; yield history
+            discussion.add_message(sender="assistant", content=full_response); discussion.save_to_disk(os.path.join(DISCUSSIONS_DIR, filename))
+        except Exception as e:
+            full_response = f"An error occurred: {e}"; gr.Error(full_response); history[-1]["content"] = full_response
+            discussion.add_message(sender="assistant", content=f"ERROR: {full_response}")
+
+    def on_chat_finish(discussion):
+        # This function updates non-streaming components after the chat is done
+        if not discussion: return gr.skip(), gr.skip()
+        return render_discussion_tree(discussion), gr.update(choices=get_message_choices(discussion), value=discussion.active_branch_id)
+
+    def handle_branch_change(discussion, selected_id):
+        if not discussion or not selected_id: return gr.skip(), gr.skip()
+        discussion.set_active_branch(selected_id)
+        return discussion, export_for_chatbot(discussion)
+
+    # --- Wire up Components ---
+    outputs_on_load = [client_state, discussion_state, discussion_selector, binding_selector, ollama_settings_group, openai_settings_group, ollama_host_input, ollama_model_selector, openai_api_key_input, openai_model_selector, system_prompt_input, chatbot, discussion_tree_display, branch_selector]
+    demo.load(on_load, outputs=outputs_on_load)
+    save_settings_button.click(handle_save_settings, [binding_selector, ollama_host_input, ollama_model_selector, openai_api_key_input, openai_model_selector], outputs_on_load)
+    binding_selector.change(lambda x: (gr.update(visible=x=='ollama'), gr.update(visible=x=='openai')), binding_selector, [ollama_settings_group, openai_settings_group])
+    refresh_ollama_button.click(list_ollama_models, ollama_host_input, ollama_model_selector)
+    system_prompt_input.blur(lambda d,t,f: d.set_system_prompt(t) and d.save_to_disk(os.path.join(DISCUSSIONS_DIR,f)) if d and f else None, [discussion_state, system_prompt_input, discussion_selector], [])
+
+    new_discussion_name.submit(handle_new_discussion, [client_state, new_discussion_name], [discussion_state, discussion_selector, chatbot, discussion_tree_display, branch_selector]).then(lambda: "", outputs=[new_discussion_name])
+    discussion_selector.change(handle_load_discussion, [client_state, discussion_selector], [discussion_state, system_prompt_input, chatbot, discussion_tree_display, branch_selector])
+    delete_discussion_button.click(handle_delete_discussion, [discussion_selector], outputs_on_load)
+
+    # --- CORRECTED WIRING FOR CHAT ---
+    chat_stream_event = user_input.submit(
+        fn=handle_chat_submit, 
+        inputs=[client_state, discussion_state, user_input, chatbot, discussion_selector], 
+        outputs=[chatbot],
+    )
+    # After the stream from handle_chat_submit is done, its input (discussion_state) will be updated.
+    # We can then pass that state to on_chat_finish.
+    chat_stream_event.then(
+        fn=on_chat_finish, 
+        inputs=[discussion_state], # The input is the state object that was modified by the previous function
+        outputs=[discussion_tree_display, branch_selector]
+    ).then(lambda: "", outputs=[user_input])
+    
+    send_button_stream_event = send_button.click(
+        fn=handle_chat_submit, 
+        inputs=[client_state, discussion_state, user_input, chatbot, discussion_selector], 
+        outputs=[chatbot]
+    )
+    send_button_stream_event.then(
+        fn=on_chat_finish, 
+        inputs=[discussion_state],
+        outputs=[discussion_tree_display, branch_selector]
+    ).then(lambda: "", outputs=[user_input])
+
+    branch_selector.change(handle_branch_change, [discussion_state, branch_selector], [discussion_state, chatbot])
+
+if __name__ == "__main__":
+    demo.launch()

examples/internet_search_with_rag.py

@@ -173,8 +173,7 @@ if __name__ == "__main__":
             rag_top_k=2, # Get 2 search results per query
             rag_min_similarity_percent=50.0,
             streaming_callback=rag_streaming_callback,
-            n_predict=400,
-            rag_hop_query_generation_temperature=0.1
+            n_predict=400
         )
         print("\n--- End of Multi-Hop Search RAG (1 hop max) ---")
         ASCIIColors.magenta("\nMulti-Hop Search RAG (1 hop max) Final Output Structure:")

examples/run_remote_mcp_example copy.py

@@ -0,0 +1,226 @@
+# File: run_lollms_client_with_mcp_example.py
+
+import sys
+import os
+import shutil
+from pathlib import Path
+import json
+from lollms_client import LollmsClient
+import subprocess
+# --- 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.
+# For example, if script is in 'lollms_client/examples/' and lollms_client code is in 'lollms_client/'
+# then the parent of the script's parent is the project root.
+
+# Get the directory of the current script
+current_script_dir = Path(__file__).resolve().parent
+
+# Option 1: If lollms_client is in the parent directory of this script's directory
+# (e.g. script is in 'project_root/examples' and lollms_client is in 'project_root/lollms_client')
+# project_root = current_script_dir.parent
+# lollms_client_path = project_root / "lollms_client" # Assuming this is where lollms_client.py and bindings are
+
+# Option 2: If lollms_client package is directly one level up
+# (e.g. script is in 'lollms_client/examples' and lollms_client package is 'lollms_client')
+project_root_for_lollms_client = current_script_dir.parent
+if str(project_root_for_lollms_client) not in sys.path:
+    sys.path.insert(0, str(project_root_for_lollms_client))
+    print(f"Added to sys.path: {project_root_for_lollms_client}")
+
+
+# --- Ensure pipmaster is available (core LoLLMs dependency) ---
+try:
+    import pipmaster as pm
+except ImportError:
+    print("ERROR: pipmaster is not installed or not in PYTHONPATH.")
+    sys.exit(1)
+
+# --- Import LollmsClient and supporting components ---
+try:
+
+    from lollms_client.lollms_llm_binding import LollmsLLMBinding # Base for LLM
+    from ascii_colors import ASCIIColors, trace_exception
+    from lollms_client.lollms_types import MSG_TYPE # Assuming MSG_TYPE is here
+except ImportError as e:
+    print(f"ERROR: Could not import LollmsClient components: {e}")
+    print("Ensure 'lollms_client' package structure is correct and accessible via PYTHONPATH.")
+    print(f"Current sys.path: {sys.path}")
+    trace_exception(e)
+    sys.exit(1)
+
+
+# --- Dummy Server Scripts using FastMCP (as per previous successful iteration) ---
+TIME_SERVER_PY = """
+import asyncio
+from datetime import datetime
+from mcp.server.fastmcp import FastMCP
+
+mcp_server = FastMCP("TimeMCP", description="A server that provides the current time.", host="localhost",
+            port=9624,
+            log_level="DEBUG")
+
+@mcp_server.tool(description="Returns the current server time and echoes received parameters.")
+def get_current_time(user_id: str = "unknown_user") -> dict:
+    return {"time": datetime.now().isoformat(), "params_received": {"user_id": user_id}, "server_name": "TimeServer"}
+
+if __name__ == "__main__":
+    mcp_server.run(transport="streamable-http")
+"""
+
+CALCULATOR_SERVER_PY = """
+import asyncio
+from typing import List, Union
+from mcp.server.fastmcp import FastMCP
+
+mcp_server = FastMCP("CalculatorMCP", description="A server that performs addition.", host="localhost",
+            port=9625,
+            log_level="DEBUG")
+
+@mcp_server.tool(description="Adds a list of numbers provided in the 'numbers' parameter.")
+def add_numbers(numbers: List[Union[int, float]]) -> dict:
+    if not isinstance(numbers, list) or not all(isinstance(x, (int, float)) for x in numbers):
+        return {"error": "'numbers' must be a list of numbers."}
+    return {"sum": sum(numbers), "server_name": "CalculatorServer"}
+
+if __name__ == "__main__":
+    mcp_server.run(transport="streamable-http")
+"""
+
+
+def main():
+    ASCIIColors.red("--- Example: Using LollmsClient with StandardMCPBinding ---")
+
+    # --- 1. Setup Temporary Directory for Dummy MCP Servers ---
+    example_base_dir = Path(__file__).parent / "temp_mcp_example_servers"
+    if example_base_dir.exists():
+        shutil.rmtree(example_base_dir)
+    example_base_dir.mkdir(exist_ok=True)
+
+    time_server_script_path = example_base_dir / "time_server.py"
+    with open(time_server_script_path, "w") as f: f.write(TIME_SERVER_PY)
+
+    calculator_server_script_path = example_base_dir / "calculator_server.py"
+    with open(calculator_server_script_path, "w") as f: f.write(CALCULATOR_SERVER_PY)
+    
+    subprocess.Popen(
+        [sys.executable, str(time_server_script_path.resolve())],
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True
+    )    
+
+    subprocess.Popen(
+        [sys.executable, str(calculator_server_script_path.resolve())],
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True
+    )        
+    # MCP Binding Configuration (for RemoteMCPBinding with multiple servers)
+    mcp_config = {
+        "servers_infos":{
+            "time_machine":{
+                "server_url": "http://localhost:9624/mcp",
+            },
+
+            "calc_unit":{
+                "server_url": "http://localhost:9625/mcp",
+            },
+        }
+    }
+    ASCIIColors.magenta("\n1. Initializing LollmsClient...")
+    try:
+        client = LollmsClient(
+            binding_name="ollama", # Use the dummy LLM binding
+            model_name="mistral-nemo:latest",
+            mcp_binding_name="remote_mcp",
+            mcp_binding_config=mcp_config,
+            
+        )
+    except Exception as e:
+        ASCIIColors.error(f"Failed to initialize LollmsClient: {e}")
+        trace_exception(e)
+        shutil.rmtree(example_base_dir)
+        sys.exit(1)
+
+    if not client.binding:
+        ASCIIColors.error("LollmsClient's LLM binding (dummy_llm) failed to load.")
+        shutil.rmtree(example_base_dir)
+        sys.exit(1)
+    if not client.mcp:
+        ASCIIColors.error("LollmsClient's MCP binding (standard_mcp) failed to load.")
+        client.close() # Close LLM binding if it loaded
+        shutil.rmtree(example_base_dir)
+        sys.exit(1)
+
+    ASCIIColors.green("LollmsClient initialized successfully with DummyLLM and StandardMCP bindings.")
+
+    # --- 3. Define a streaming callback for generate_with_mcp ---
+    def mcp_streaming_callback(chunk: str, msg_type: MSG_TYPE, metadata: dict = None, history: list = None) -> bool:
+        if metadata:
+            type_info = metadata.get('type', 'unknown_type')
+            if msg_type == MSG_TYPE.MSG_TYPE_STEP_START:
+                ASCIIColors.cyan(f"MCP Step Start ({type_info}): {chunk}")
+            elif msg_type == MSG_TYPE.MSG_TYPE_STEP_END:
+                ASCIIColors.cyan(f"MCP Step End ({type_info}): {chunk}")
+            elif msg_type == MSG_TYPE.MSG_TYPE_INFO:
+                ASCIIColors.yellow(f"MCP Info ({type_info}): {chunk}")
+            elif msg_type == MSG_TYPE.MSG_TYPE_CHUNK: # Part of final answer typically
+                ASCIIColors.green(chunk, end="") # type: ignore
+            else: # FULL, default, etc.
+                ASCIIColors.green(f"MCP Output ({str(msg_type)}, {type_info}): {chunk}")
+        else:
+             if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:
+                ASCIIColors.green(chunk, end="") # type: ignore
+             else:
+                ASCIIColors.green(f"MCP Output ({str(msg_type)}): {chunk}")
+        sys.stdout.flush()
+        return True # Continue streaming
+
+    # --- 4. Use generate_with_mcp ---
+    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(
+        prompt=time_prompt,
+        streaming_callback=mcp_streaming_callback,
+        interactive_tool_execution=False # Set to True to test interactive mode
+    )
+    print() # Newline after streaming
+    ASCIIColors.blue(f"Final response for time prompt: {json.dumps(time_response, indent=2)}")
+
+    assert time_response.get("error") is None, f"Time prompt resulted in an error: {time_response.get('error')}"
+    assert time_response.get("final_answer"), "Time prompt did not produce a final answer."
+    assert len(time_response.get("tool_calls", [])) > 0, "Time prompt should have called a tool."
+    assert time_response["tool_calls"][0]["name"] == "time_machine::get_current_time", "Incorrect tool called for time."
+    assert "time" in time_response["tool_calls"][0].get("result", {}).get("output", {}), "Time tool result missing time."
+
+
+    ASCIIColors.magenta("\n3. Calling generate_with_mcp for calculation...")
+    calc_prompt = "Can you please calculate the sum of 50, 25, and 7.5 for me?"
+    calc_response = client.generate_with_mcp(
+        prompt=calc_prompt,
+        streaming_callback=mcp_streaming_callback
+    )
+    print() # Newline
+    ASCIIColors.blue(f"Final response for calc prompt: {json.dumps(calc_response, indent=2)}")
+
+    assert calc_response.get("error") is None, f"Calc prompt resulted in an error: {calc_response.get('error')}"
+    assert calc_response.get("final_answer"), "Calc prompt did not produce a final answer."
+    assert len(calc_response.get("tool_calls", [])) > 0, "Calc prompt should have called a tool."
+    assert calc_response["tool_calls"][0]["name"] == "calc_unit::add_numbers", "Incorrect tool called for calculation."
+    # The dummy LLM uses hardcoded params [1,2,3] for calc, so result will be 6.
+    # A real LLM would extract 50, 25, 7.5.
+    # For this dummy test, we check against the dummy's behavior.
+    assert calc_response["tool_calls"][0].get("result", {}).get("output", {}).get("sum") == 82.5, "Calculator tool result mismatch for dummy params."
+
+
+    # --- 5. Cleanup ---
+    ASCIIColors.info("Cleaning up temporary server scripts and dummy binding directory...")
+    shutil.rmtree(example_base_dir, ignore_errors=True)
+
+    ASCIIColors.red("\n--- LollmsClient with StandardMCPBinding Example Finished Successfully! ---")
+
+if __name__ == "__main__":
+    main()

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.20.3" # Updated version
+__version__ = "0.20.6" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [
@@ -19,4 +19,4 @@ __all__ = [
     "PromptReshaper",
     "LollmsMCPBinding", # Export LollmsMCPBinding ABC
     "LollmsMCPBindingManager", # Export LollmsMCPBindingManager
-]
+]

lollms_client/llm_bindings/llamacpp/__init__.py

@@ -635,6 +635,110 @@ class LlamaCppServerBinding(LollmsLLMBinding):
             error_message = f"Llama.cpp generation error: {str(ex)}"; trace_exception(ex)
             return {"status": False, "error": error_message}
 
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             n_predict: Optional[int] = None,
+             stream: Optional[bool] = None,
+             temperature: float = 0.7,
+             top_k: int = 40,
+             top_p: float = 0.9,
+             repeat_penalty: float = 1.1,
+             repeat_last_n: int = 64,
+             seed: Optional[int] = None,
+             n_threads: Optional[int] = None,
+             ctx_size: Optional[int] = None,
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+             **generation_kwargs
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with the llama.cpp server using a LollmsDiscussion object.
+
+        Args:
+            discussion (LollmsDiscussion): The discussion object containing the conversation history.
+            branch_tip_id (Optional[str]): The ID of the message to use as the tip of the conversation branch. Defaults to the active branch.
+            n_predict (Optional[int]): Maximum number of tokens to generate.
+            stream (Optional[bool]): Whether to stream the output.
+            temperature (float): Sampling temperature.
+            top_k (int): Top-k sampling parameter.
+            top_p (float): Top-p sampling parameter.
+            repeat_penalty (float): Penalty for repeated tokens.
+            repeat_last_n (int): Number of previous tokens to consider for repeat penalty.
+            seed (Optional[int]): Random seed for generation.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+
+        Returns:
+            Union[str, dict]: The generated text or an error dictionary.
+        """
+        if not self.server_process or not self.server_process.is_healthy:
+            return {"status": "error", "message": "Llama.cpp server is not running or not healthy."}
+
+        # 1. Export the discussion to the OpenAI chat format, which llama.cpp server understands.
+        # This handles system prompts, user/assistant roles, and multi-modal content.
+        messages = discussion.export("openai_chat", branch_tip_id)
+
+        # 2. Build the generation payload for the server
+        payload = {
+            "messages": messages,
+            "max_tokens": n_predict,
+            "temperature": temperature,
+            "top_k": top_k,
+            "top_p": top_p,
+            "repeat_penalty": repeat_penalty,
+            "seed": seed,
+            "stream": stream,
+            **generation_kwargs # Pass any extra parameters
+        }
+        # Remove None values, as the API expects them to be absent
+        payload = {k: v for k, v in payload.items() if v is not None}
+        
+        endpoint = "/v1/chat/completions"
+        request_url = self._get_request_url(endpoint)
+        full_response_text = ""
+
+        try:
+            # 3. Make the request to the server
+            response = self.server_process.session.post(request_url, json=payload, stream=stream, timeout=self.server_args.get("generation_timeout", 300))
+            response.raise_for_status()
+
+            if stream:
+                for line in response.iter_lines():
+                    if not line: continue
+                    line_str = line.decode('utf-8').strip()
+                    if line_str.startswith('data: '): line_str = line_str[6:]
+                    if line_str == '[DONE]': break
+                    try:
+                        chunk_data = json.loads(line_str)
+                        chunk_content = chunk_data.get('choices', [{}])[0].get('delta', {}).get('content', '')
+                        if chunk_content:
+                            full_response_text += chunk_content
+                            if streaming_callback and not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                ASCIIColors.info("Streaming callback requested stop.")
+                                response.close()
+                                break
+                    except json.JSONDecodeError:
+                        ASCIIColors.warning(f"Failed to decode JSON stream chunk: {line_str}")
+                        continue
+                return full_response_text
+            else: # Not streaming
+                response_data = response.json()
+                return response_data.get('choices', [{}])[0].get('message', {}).get('content', '')
+
+        except requests.exceptions.RequestException as e:
+            error_message = f"Llama.cpp server request error: {e}"
+            if e.response is not None:
+                try:
+                    error_details = e.response.json()
+                    error_message += f" - Details: {error_details.get('error', e.response.text)}"
+                except json.JSONDecodeError:
+                    error_message += f" - Response: {e.response.text[:200]}"
+            ASCIIColors.error(error_message)
+            return {"status": "error", "message": error_message}
+        except Exception as ex:
+            error_message = f"Llama.cpp generation error: {str(ex)}"
+            trace_exception(ex)
+            return {"status": "error", "message": error_message}
+        
     def tokenize(self, text: str) -> List[int]:
         if not self.server_process or not self.server_process.is_healthy: raise ConnectionError("Server not running.")
         try: